#include "render.h"
#include "common.h"
#include "items.h"
#include "raylib.h"
#include "settings.h"
#include <stddef.h>
#include <stdio.h>
#include <string.h>

void render_map(const Map *map) {
  for (int y = 0; y < MAP_HEIGHT; y++) {
    for (int x = 0; x < MAP_WIDTH; x++) {
      Rectangle rect = {(float)(x * TILE_SIZE), (float)(y * TILE_SIZE), (float)TILE_SIZE, (float)TILE_SIZE};

      switch (map->tiles[y][x]) {
      case TILE_WALL:
        DrawRectangleRec(rect, DARKGRAY);
        break;
      case TILE_FLOOR:
        DrawRectangleRec(rect, BLACK);
        break;
      case TILE_STAIRS:
        DrawRectangleRec(rect, (Color){100, 100, 100, 255});
        // Draw stairs marker
        DrawText(">", x * TILE_SIZE + 4, y * TILE_SIZE + 2, 12, WHITE);
        break;
      }
    }
  }
}

void render_player(const Player *p) {
  Rectangle rect = {(float)(p->x * TILE_SIZE), (float)(p->y * TILE_SIZE), (float)TILE_SIZE, (float)TILE_SIZE};
  DrawRectangleRec(rect, BLUE);
}

void render_enemies(const Enemy *enemies, int count) {
  for (int i = 0; i < count; i++) {
    if (!enemies[i].alive)
      continue;

    Rectangle rect = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE), (float)TILE_SIZE,
                      (float)TILE_SIZE};

    // Different colors based on enemy type
    Color enemy_color;
    switch (enemies[i].type) {
    case ENEMY_GOBLIN:
      enemy_color = (Color){150, 50, 50, 255};  // dark red
      break;
    case ENEMY_SKELETON:
      enemy_color = (Color){200, 200, 200, 255};  // light gray
      break;
    case ENEMY_ORC:
      enemy_color = (Color){50, 150, 50, 255};  // dark green
      break;
    default:
      enemy_color = RED;
      break;
    }

    DrawRectangleRec(rect, enemy_color);

    // Draw hp bar above enemy
    int hp_percent = (enemies[i].hp * TILE_SIZE) / enemies[i].max_hp;
    if (hp_percent > 0) {
      Rectangle hp_bar = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE - 4), (float)hp_percent,
                          3};
      DrawRectangleRec(hp_bar, GREEN);
    }
  }
}

void render_items(const Item *items, int count) {
  for (int i = 0; i < count; i++) {
    if (items[i].picked_up)
      continue;

    Rectangle rect = {(float)(items[i].x * TILE_SIZE), (float)(items[i].y * TILE_SIZE), (float)TILE_SIZE,
                      (float)TILE_SIZE};

    // Different colors based on item type
    Color item_color;
    switch (items[i].type) {
    case ITEM_POTION:
      item_color = (Color){255, 100, 100, 255};  // red/pink
      break;
    case ITEM_WEAPON:
      item_color = (Color){255, 255, 100, 255};  // yellow
      break;
    case ITEM_ARMOR:
      item_color = (Color){100, 100, 255, 255};  // blue
      break;
    default:
      item_color = GREEN;
      break;
    }

    DrawRectangleRec(rect, item_color);
  }
}

void render_ui(const Player *p) {
  // UI background bar (taller for two rows)
  Rectangle ui_bg = {0, (float)(MAP_HEIGHT * TILE_SIZE), (float)SCREEN_WIDTH, 60};
  DrawRectangleRec(ui_bg, (Color){15, 15, 15, 255});

  // Draw dividing line
  DrawLine(0, MAP_HEIGHT * TILE_SIZE, SCREEN_WIDTH, MAP_HEIGHT * TILE_SIZE, (Color){50, 50, 50, 255});

  // HP Bar (row 1, left)
  int bar_x = 10;
  int bar_y = MAP_HEIGHT * TILE_SIZE + 10;
  int bar_width = 140;
  int bar_height = 18;

  // Bar background
  DrawRectangle(bar_x, bar_y, bar_width, bar_height, (Color){30, 30, 30, 255});

  // Bar fill based on HP percentage
  float hp_percent = (float)p->hp / p->max_hp;
  int fill_width = (int)(bar_width * hp_percent);

  // Color gradient: green > yellow > red
  Color hp_color;
  if (hp_percent > 0.6f) {
    hp_color = (Color){60, 180, 60, 255};
  } else if (hp_percent > 0.3f) {
    hp_color = (Color){200, 180, 40, 255};
  } else {
    hp_color = (Color){200, 60, 60, 255};
  }
  DrawRectangle(bar_x, bar_y, fill_width, bar_height, hp_color);

  // HP text inside bar
  char hp_text[32];
  snprintf(hp_text, sizeof(hp_text), "%d/%d", p->hp, p->max_hp);
  int hp_text_w = MeasureText(hp_text, 14);
  DrawText(hp_text, bar_x + (bar_width - hp_text_w) / 2, bar_y + 2, 14, WHITE);

  // Stats row 1: Floor, ATK, DEF, Inv
  int stats_y = bar_y;
  DrawText("F1", bar_x + bar_width + 15, stats_y, 14, WHITE);
  DrawText("ATK", bar_x + bar_width + 50, stats_y, 14, YELLOW);
  DrawText("DEF", bar_x + bar_width + 100, stats_y, 14, BLUE);
  DrawText("INV", bar_x + bar_width + 145, stats_y, 14, GREEN);

  // Row 2: equipment slots and controls
  int row2_y = stats_y + 24;

  // Equipment (left side of row 2)
  if (p->has_weapon) {
    char weapon_text[48];
    snprintf(weapon_text, sizeof(weapon_text), "Wpn:%s +%d", item_get_name(&p->equipped_weapon),
             p->equipped_weapon.power);
    DrawText(weapon_text, 10, row2_y, 12, YELLOW);
  } else {
    DrawText("Wpn:---", 10, row2_y, 12, (Color){60, 60, 60, 255});
  }

  if (p->has_armor) {
    char armor_text[48];
    snprintf(armor_text, sizeof(armor_text), "Arm:%s +%d", item_get_name(&p->equipped_armor), p->equipped_armor.power);
    DrawText(armor_text, 150, row2_y, 12, BLUE);
  } else {
    DrawText("Arm:---", 150, row2_y, 12, (Color){60, 60, 60, 255});
  }

  // Controls hint (right side)
  DrawText("[G] Pickup  [I] Inventory  [E] Equip  [D] Drop", 350, row2_y, 12, (Color){70, 70, 70, 255});
}

void render_action_log(const char log[5][128], int count, int head) {
  int log_x = 10;
  int log_y = MAP_HEIGHT * TILE_SIZE - 75;

  for (int i = 0; i < count && i < 5; i++) {
    int idx = (head - count + i + 5) % 5;
    if (log[idx][0] != '\0') {
      DrawText(log[idx], log_x, log_y + i * 14, 12, (Color){140, 140, 140, 255});
    }
  }
}

void render_inventory_overlay(const Player *p, int selected) {
  // Overlay dimensions
  int ov_width = 360;
  int ov_height = 300;
  Rectangle overlay = {(float)(SCREEN_WIDTH - ov_width) / 2, (float)(SCREEN_HEIGHT - ov_height) / 2 - 60,
                       (float)ov_width, (float)ov_height};
  DrawRectangleRec(overlay, (Color){12, 12, 12, 252});
  DrawRectangleLines((int)overlay.x, (int)overlay.y, (int)overlay.width, (int)overlay.height, (Color){70, 70, 70, 255});

  // Title
  const char *title = "INVENTORY";
  int title_w = MeasureText(title, 24);
  DrawText(title, overlay.x + (overlay.width - title_w) / 2, overlay.y + 12, 24, WHITE);

  // Draw each inventory slot
  char slot_text[64];
  int row_height = 26;
  int start_y = overlay.y + 50;

  for (int i = 0; i < MAX_INVENTORY; i++) {
    int y_pos = start_y + (i * row_height);

    if (i < p->inventory_count && !p->inventory[i].picked_up) {
      const Item *item = &p->inventory[i];

      // Selection highlight
      if (i == selected) {
        DrawRectangle((int)overlay.x + 6, y_pos, (int)overlay.width - 12, row_height - 2, (Color){45, 45, 45, 255});
        DrawRectangleLines((int)overlay.x + 6, y_pos, (int)overlay.width - 12, row_height - 2,
                           (Color){180, 160, 80, 255});
      }

      // Slot number
      snprintf(slot_text, sizeof(slot_text), "%d.", i + 1);
      DrawText(slot_text, overlay.x + 16, y_pos + 4, 14, (Color){80, 80, 80, 255});

      // Item name
      const char *name = item_get_name(item);
      Color name_color = (item->type == ITEM_POTION)   ? (Color){255, 140, 140, 255}
                         : (item->type == ITEM_WEAPON) ? (Color){255, 255, 140, 255}
                                                       : (Color){140, 140, 255, 255};
      DrawText(name, overlay.x + 45, y_pos + 4, 14, name_color);

      // Power
      snprintf(slot_text, sizeof(slot_text), "+%d", item->power);
      DrawText(slot_text, overlay.x + 150, y_pos + 4, 14, YELLOW);

      // Action
      if (item->type == ITEM_POTION) {
        DrawText("[U]se", overlay.x + 200, y_pos + 4, 14, GREEN);
      } else {
        DrawText("[E]quip [D]rop", overlay.x + 200, y_pos + 4, 14, GOLD);
      }
    } else {
      // Empty slot
      snprintf(slot_text, sizeof(slot_text), "%d.", i + 1);
      DrawText(slot_text, overlay.x + 16, y_pos + 4, 14, (Color){40, 40, 40, 255});
    }
  }

  // Instructions at bottom
  const char *hint = "[1-0] Select   [E] Equip   [U] Use   [D] Drop   [I/ESC] Close";
  int hint_w = MeasureText(hint, 12);
  DrawText(hint, overlay.x + (overlay.width - hint_w) / 2, overlay.y + overlay.height - 22, 12,
           (Color){65, 65, 65, 255});
}

void render_floating_texts(FloatingText *texts, int count, int shake_x, int shake_y) {
  for (int i = 0; i < count; i++) {
    if (texts[i].lifetime <= 0)
      continue;

    int x = texts[i].x + shake_x;
    int y = texts[i].y + shake_y - (60 - texts[i].lifetime);  // rise over time

    float alpha = (float)texts[i].lifetime / 60.0f;
    Color color =
        texts[i].is_critical ? (Color){255, 200, 50, (int)(255 * alpha)} : (Color){255, 100, 100, (int)(255 * alpha)};

    char text[16];
    snprintf(text, sizeof(text), "%d", texts[i].value);
    int text_w = MeasureText(text, 18);
    DrawText(text, x - text_w / 2, y, 18, color);
  }
}

void render_game_over(void) {
  // Semi-transparent overlay
  Rectangle overlay = {0, 0, (float)SCREEN_WIDTH, (float)SCREEN_HEIGHT};
  DrawRectangleRec(overlay, (Color){0, 0, 0, 210});

  // Game over text
  const char *title = "GAME OVER";
  int title_width = MeasureText(title, 60);
  DrawText(title, (SCREEN_WIDTH - title_width) / 2, SCREEN_HEIGHT / 2 - 30, 60, RED);

  const char *subtitle = "Press R to restart or Q to quit";
  int sub_width = MeasureText(subtitle, 20);
  DrawText(subtitle, (SCREEN_WIDTH - sub_width) / 2, SCREEN_HEIGHT / 2 + 40, 20, WHITE);
}

void render_message(const char *message) {
  if (message == NULL)
    return;
  int msg_len = strlen(message);
  float msg_ratio = 13.5;
  // Draw message box
  // Rectangle msg_bg = {(float)(SCREEN_WIDTH / 2.0f - 150.0f), (float)(SCREEN_HEIGHT / 2.0f - 30.0f), 300, 60};

  Rectangle msg_bg = {(float)(SCREEN_WIDTH / 2.0f - ((msg_ratio / 2.03f) * msg_len)),
                      (float)(SCREEN_HEIGHT / 2.0f - 30.0f), msg_ratio * msg_len, 60};
  DrawRectangleRec(msg_bg, (Color){45, 45, 45, 235});
  DrawRectangleLines((int)msg_bg.x, (int)msg_bg.y, (int)msg_bg.width, (int)msg_bg.height, (Color){180, 180, 180, 255});

  int msg_width = MeasureText(message, 20);
  DrawText(message, (SCREEN_WIDTH - msg_width) / 2, SCREEN_HEIGHT / 2 - 10, 20, WHITE);
}