#include "ScreenComponents.h"

#include <GfxRenderer.h>

#include <algorithm>
#include <cstdint>
#include <string>

#include "Battery.h"
#include "fontIds.h"

void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left, const int top,
                                   const bool showPercentage) {
  // Left aligned battery icon and percentage
  const uint16_t percentage = battery.readPercentage();
  const auto percentageText = showPercentage ? std::to_string(percentage) + "%" : "";
  renderer.drawText(SMALL_FONT_ID, left + 20, top, percentageText.c_str());

  // 1 column on left, 2 columns on right, 5 columns of battery body
  constexpr int batteryWidth = 15;
  constexpr int batteryHeight = 12;
  const int x = left;
  const int y = top + 6;

  // Top line
  renderer.drawLine(x + 1, y, x + batteryWidth - 3, y);
  // Bottom line
  renderer.drawLine(x + 1, y + batteryHeight - 1, x + batteryWidth - 3, y + batteryHeight - 1);
  // Left line
  renderer.drawLine(x, y + 1, x, y + batteryHeight - 2);
  // Battery end
  renderer.drawLine(x + batteryWidth - 2, y + 1, x + batteryWidth - 2, y + batteryHeight - 2);
  renderer.drawPixel(x + batteryWidth - 1, y + 3);
  renderer.drawPixel(x + batteryWidth - 1, y + batteryHeight - 4);
  renderer.drawLine(x + batteryWidth - 0, y + 4, x + batteryWidth - 0, y + batteryHeight - 5);

  // The +1 is to round up, so that we always fill at least one pixel
  int filledWidth = percentage * (batteryWidth - 5) / 100 + 1;
  if (filledWidth > batteryWidth - 5) {
    filledWidth = batteryWidth - 5;  // Ensure we don't overflow
  }

  renderer.fillRect(x + 2, y + 2, filledWidth, batteryHeight - 4);
}

void ScreenComponents::drawBatteryLarge(const GfxRenderer& renderer, const int left, const int top,
                                        const bool showPercentage) {
  // Larger battery icon with UI_10 font for bottom button hint area
  const uint16_t percentage = battery.readPercentage();
  const auto percentageText = showPercentage ? std::to_string(percentage) + "%" : "";
  renderer.drawText(UI_10_FONT_ID, left + 28, top, percentageText.c_str());

  // Scaled up battery dimensions (~33% larger)
  constexpr int batteryWidth = 20;
  constexpr int batteryHeight = 16;
  const int x = left;
  const int y = top + 6;

  // Top line
  renderer.drawLine(x + 1, y, x + batteryWidth - 4, y);
  // Bottom line
  renderer.drawLine(x + 1, y + batteryHeight - 1, x + batteryWidth - 4, y + batteryHeight - 1);
  // Left line
  renderer.drawLine(x, y + 1, x, y + batteryHeight - 2);
  // Battery end (right side with nub)
  renderer.drawLine(x + batteryWidth - 3, y + 1, x + batteryWidth - 3, y + batteryHeight - 2);
  // Battery nub
  renderer.drawPixel(x + batteryWidth - 2, y + 4);
  renderer.drawPixel(x + batteryWidth - 2, y + batteryHeight - 5);
  renderer.drawLine(x + batteryWidth - 1, y + 5, x + batteryWidth - 1, y + batteryHeight - 6);

  // The +1 is to round up, so that we always fill at least one pixel
  int filledWidth = percentage * (batteryWidth - 6) / 100 + 1;
  if (filledWidth > batteryWidth - 6) {
    filledWidth = batteryWidth - 6;  // Ensure we don't overflow
  }

  renderer.fillRect(x + 2, y + 2, filledWidth, batteryHeight - 4);
}

void ScreenComponents::drawBookProgressBar(const GfxRenderer& renderer, const size_t bookProgress) {
  int vieweableMarginTop, vieweableMarginRight, vieweableMarginBottom, vieweableMarginLeft;
  renderer.getOrientedViewableTRBL(&vieweableMarginTop, &vieweableMarginRight, &vieweableMarginBottom,
                                   &vieweableMarginLeft);

  const int progressBarMaxWidth = renderer.getScreenWidth() - vieweableMarginLeft - vieweableMarginRight;
  const int progressBarY = renderer.getScreenHeight() - vieweableMarginBottom - BOOK_PROGRESS_BAR_HEIGHT;
  const int barWidth = progressBarMaxWidth * bookProgress / 100;
  renderer.fillRect(vieweableMarginLeft, progressBarY, barWidth, BOOK_PROGRESS_BAR_HEIGHT, true);
}

int ScreenComponents::drawTabBar(const GfxRenderer& renderer, const int y, const std::vector<TabInfo>& tabs) {
  constexpr int tabPadding = 20;      // Horizontal padding between tabs
  constexpr int leftMargin = 20;      // Left margin for first tab
  constexpr int underlineHeight = 2;  // Height of selection underline
  constexpr int underlineGap = 4;     // Gap between text and underline

  const int lineHeight = renderer.getLineHeight(UI_12_FONT_ID);
  const int tabBarHeight = lineHeight + underlineGap + underlineHeight;

  int currentX = leftMargin;

  for (const auto& tab : tabs) {
    const int textWidth =
        renderer.getTextWidth(UI_12_FONT_ID, tab.label, tab.selected ? EpdFontFamily::BOLD : EpdFontFamily::REGULAR);

    // Draw tab label
    renderer.drawText(UI_12_FONT_ID, currentX, y, tab.label, true,
                      tab.selected ? EpdFontFamily::BOLD : EpdFontFamily::REGULAR);

    // Draw underline for selected tab
    if (tab.selected) {
      renderer.fillRect(currentX, y + lineHeight + underlineGap, textWidth, underlineHeight);
    }

    currentX += textWidth + tabPadding;
  }

  return tabBarHeight;
}

void ScreenComponents::drawScrollIndicator(const GfxRenderer& renderer, const int currentPage, const int totalPages,
                                           const int contentTop, const int contentHeight) {
  if (totalPages <= 1) {
    return;  // No need for indicator if only one page
  }

  const int screenWidth = renderer.getScreenWidth();
  constexpr int indicatorWidth = 20;
  constexpr int arrowSize = 6;
  constexpr int margin = 15;  // Offset from right edge

  const int centerX = screenWidth - indicatorWidth / 2 - margin;
  const int indicatorTop = contentTop + 60;  // Offset to avoid overlapping side button hints
  const int indicatorBottom = contentTop + contentHeight - 30;

  // Draw up arrow at top (^) - narrow point at top, wide base at bottom
  for (int i = 0; i < arrowSize; ++i) {
    const int lineWidth = 1 + i * 2;
    const int startX = centerX - i;
    renderer.drawLine(startX, indicatorTop + i, startX + lineWidth - 1, indicatorTop + i);
  }

  // Draw down arrow at bottom (v) - wide base at top, narrow point at bottom
  for (int i = 0; i < arrowSize; ++i) {
    const int lineWidth = 1 + (arrowSize - 1 - i) * 2;
    const int startX = centerX - (arrowSize - 1 - i);
    renderer.drawLine(startX, indicatorBottom - arrowSize + 1 + i, startX + lineWidth - 1,
                      indicatorBottom - arrowSize + 1 + i);
  }

  // Draw page fraction in the middle (e.g., "1/3")
  const std::string pageText = std::to_string(currentPage) + "/" + std::to_string(totalPages);
  const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, pageText.c_str());
  const int textX = centerX - textWidth / 2;
  const int textY = (indicatorTop + indicatorBottom) / 2 - renderer.getLineHeight(SMALL_FONT_ID) / 2;

  renderer.drawText(SMALL_FONT_ID, textX, textY, pageText.c_str());
}

void ScreenComponents::drawProgressBar(const GfxRenderer& renderer, const int x, const int y, const int width,
                                       const int height, const size_t current, const size_t total) {
  if (total == 0) {
    return;
  }

  // Use 64-bit arithmetic to avoid overflow for large files
  const int percent = static_cast<int>((static_cast<uint64_t>(current) * 100) / total);

  // Draw outline
  renderer.drawRect(x, y, width, height);

  // Draw filled portion
  const int fillWidth = (width - 4) * percent / 100;
  if (fillWidth > 0) {
    renderer.fillRect(x + 2, y + 2, fillWidth, height - 4);
  }

  // Draw percentage text centered below bar
  const std::string percentText = std::to_string(percent) + "%";
  renderer.drawCenteredText(UI_10_FONT_ID, y + height + 15, percentText.c_str());
}

int ScreenComponents::drawPillBadge(const GfxRenderer& renderer, const int x, const int y, const char* text,
                                    const int fontId, const bool inverted) {
  // Calculate dimensions
  const int textWidth = renderer.getTextWidth(fontId, text);
  const int lineHeight = renderer.getLineHeight(fontId);

  // Badge padding and sizing
  constexpr int horizontalPadding = 5;
  constexpr int verticalPadding = 2;
  constexpr int cornerRadius = 5;

  const int badgeWidth = textWidth + horizontalPadding * 2;
  const int badgeHeight = lineHeight + verticalPadding * 2;
  const int badgeY = y - verticalPadding;  // Adjust y to center around text baseline

  // Fill color: inverted = white fill (false), normal = black fill (true)
  const bool fillColor = !inverted;

  // Ensure radius doesn't exceed half the badge dimensions
  const int radius = std::min({cornerRadius, badgeWidth / 2, badgeHeight / 2});

  // Fill center rectangle (between left and right corner columns)
  if (badgeWidth > radius * 2) {
    renderer.fillRect(x + radius, badgeY, badgeWidth - radius * 2, badgeHeight, fillColor);
  }

  // Fill left and right edge strips (between top and bottom corners)
  if (badgeHeight > radius * 2) {
    renderer.fillRect(x, badgeY + radius, radius, badgeHeight - radius * 2, fillColor);
    renderer.fillRect(x + badgeWidth - radius, badgeY + radius, radius, badgeHeight - radius * 2, fillColor);
  }

  // Fill the four corner arcs using distance-squared check
  const int radiusSq = radius * radius;

  // Top-left corner: center at (x + radius, badgeY + radius), direction (-1, -1)
  for (int dy = 0; dy < radius; ++dy) {
    for (int dx = 0; dx < radius; ++dx) {
      const int distSq = (radius - 1 - dx) * (radius - 1 - dx) + (radius - 1 - dy) * (radius - 1 - dy);
      if (distSq < radiusSq) {
        renderer.drawPixel(x + dx, badgeY + dy, fillColor);
      }
    }
  }

  // Top-right corner: center at (x + badgeWidth - radius, badgeY + radius), direction (+1, -1)
  for (int dy = 0; dy < radius; ++dy) {
    for (int dx = 0; dx < radius; ++dx) {
      const int distSq = dx * dx + (radius - 1 - dy) * (radius - 1 - dy);
      if (distSq < radiusSq) {
        renderer.drawPixel(x + badgeWidth - radius + dx, badgeY + dy, fillColor);
      }
    }
  }

  // Bottom-left corner: center at (x + radius, badgeY + badgeHeight - radius), direction (-1, +1)
  for (int dy = 0; dy < radius; ++dy) {
    for (int dx = 0; dx < radius; ++dx) {
      const int distSq = (radius - 1 - dx) * (radius - 1 - dx) + dy * dy;
      if (distSq < radiusSq) {
        renderer.drawPixel(x + dx, badgeY + badgeHeight - radius + dy, fillColor);
      }
    }
  }

  // Bottom-right corner: center at (x + badgeWidth - radius, badgeY + badgeHeight - radius), direction (+1, +1)
  for (int dy = 0; dy < radius; ++dy) {
    for (int dx = 0; dx < radius; ++dx) {
      const int distSq = dx * dx + dy * dy;
      if (distSq < radiusSq) {
        renderer.drawPixel(x + badgeWidth - radius + dx, badgeY + badgeHeight - radius + dy, fillColor);
      }
    }
  }

  // Draw text centered in badge
  // Text color: inverted = black (true), normal = white (false)
  const int textX = x + horizontalPadding;
  renderer.drawText(fontId, textX, y, text, inverted);

  return badgeWidth;
}