#include <algorithm>
#include <app/application.h>
#include <cmath>
#include <core/string.h>
#include <graphics/render_backend.h>
#include <ui/button.h>

namespace extra2d {

// ============================================================================
// Button 实现
// ============================================================================

/**
 * @brief 默认构造函数
 */
Button::Button() {
  setAnchor(0.0f, 0.0f);
  setSpatialIndexed(false);

  auto &dispatcher = getEventDispatcher();
  dispatcher.addListener(EventType::UIHoverEnter, [this](Event &) {
    hovered_ = true;
    auto &app = Application::instance();
    app.window().setCursor(hoverCursor_);
    cursorChanged_ = true;
  });
  dispatcher.addListener(EventType::UIHoverExit, [this](Event &) {
    hovered_ = false;
    pressed_ = false;
    if (cursorChanged_) {
      auto &app = Application::instance();
      app.window().resetCursor();
      cursorChanged_ = false;
    }
  });
  dispatcher.addListener(EventType::UIPressed,
                         [this](Event &) { pressed_ = true; });
  dispatcher.addListener(EventType::UIReleased,
                         [this](Event &) { pressed_ = false; });
  dispatcher.addListener(EventType::UIClicked, [this](Event &) {
    if (toggleMode_) {
      toggle();
    }
    if (onClick_) {
      onClick_();
    }
  });
}

/**
 * @brief 带文本的构造函数
 * @param text 按钮文本
 */
Button::Button(const std::string &text) : Button() { text_ = text; }

// ------------------------------------------------------------------------
// 静态创建方法
// ------------------------------------------------------------------------
/**
 * @brief 创建空按钮对象
 * @return 按钮对象指针
 */
Ptr<Button> Button::create() { return makePtr<Button>(); }

/**
 * @brief 创建带文本的按钮对象
 * @param text 按钮文本
 * @return 按钮对象指针
 */
Ptr<Button> Button::create(const std::string &text) {
  return makePtr<Button>(text);
}

/**
 * @brief 创建带文本和字体的按钮对象
 * @param text 按钮文本
 * @param font 字体图集
 * @return 按钮对象指针
 */
Ptr<Button> Button::create(const std::string &text, Ptr<FontAtlas> font) {
  auto btn = makePtr<Button>(text);
  btn->setFont(font);
  return btn;
}

// ------------------------------------------------------------------------
// 普通设置方法
// ------------------------------------------------------------------------
/**
 * @brief 设置按钮文本
 * @param text 文本内容
 */
void Button::setText(const std::string &text) {
  text_ = text;
  if (font_ && size().empty()) {
    Vec2 textSize = font_->measureText(text_);
    setSize(textSize.x + padding_.x * 2.0f, textSize.y + padding_.y * 2.0f);
  }
}

/**
 * @brief 设置字体
 * @param font 字体图集指针
 */
void Button::setFont(Ptr<FontAtlas> font) {
  font_ = font;
  if (font_ && size().empty() && !text_.empty()) {
    Vec2 textSize = font_->measureText(text_);
    setSize(textSize.x + padding_.x * 2.0f, textSize.y + padding_.y * 2.0f);
  }
}

/**
 * @brief 设置内边距（Vec2版本）
 * @param padding 内边距向量
 */
void Button::setPadding(const Vec2 &padding) {
  padding_ = padding;
  if (font_ && size().empty() && !text_.empty()) {
    Vec2 textSize = font_->measureText(text_);
    setSize(textSize.x + padding_.x * 2.0f, textSize.y + padding_.y * 2.0f);
  }
}

/**
 * @brief 设置内边距（分量版本）
 * @param x X方向内边距
 * @param y Y方向内边距
 */
void Button::setPadding(float x, float y) { setPadding(Vec2(x, y)); }

/**
 * @brief 设置文本颜色
 * @param color 文本颜色
 */
void Button::setTextColor(const Color &color) { textColor_ = color; }

/**
 * @brief 设置背景颜色
 * @param normal 普通状态颜色
 * @param hover 悬停状态颜色
 * @param pressed 按下状态颜色
 */
void Button::setBackgroundColor(const Color &normal, const Color &hover,
                                const Color &pressed) {
  bgNormal_ = normal;
  bgHover_ = hover;
  bgPressed_ = pressed;
}

/**
 * @brief 设置边框
 * @param color 边框颜色
 * @param width 边框宽度
 */
void Button::setBorder(const Color &color, float width) {
  borderColor_ = color;
  borderWidth_ = width;
}

/**
 * @brief 设置圆角半径
 * @param radius 圆角半径
 */
void Button::setCornerRadius(float radius) {
  cornerRadius_ = std::max(0.0f, radius);
}

/**
 * @brief 设置是否启用圆角
 * @param enabled 是否启用
 */
void Button::setRoundedCornersEnabled(bool enabled) {
  roundedCornersEnabled_ = enabled;
}

/**
 * @brief 设置是否使用Alpha遮罩进行点击检测
 * @param enabled 是否启用
 */
void Button::setUseAlphaMaskForHitTest(bool enabled) {
  useAlphaMaskForHitTest_ = enabled;
}

/**
 * @brief 设置点击回调
 * @param callback 回调函数
 */
void Button::setOnClick(Function<void()> callback) {
  onClick_ = std::move(callback);
}

/**
 * @brief 设置是否为切换模式
 * @param enabled 是否启用
 */
void Button::setToggleMode(bool enabled) { toggleMode_ = enabled; }

/**
 * @brief 设置开关状态
 * @param on 是否开启
 */
void Button::setOn(bool on) {
  if (isOn_ != on) {
    isOn_ = on;
    if (onStateChange_) {
      onStateChange_(isOn_);
    }
  }
}

/**
 * @brief 切换状态
 */
void Button::toggle() { setOn(!isOn_); }

/**
 * @brief 设置状态改变回调
 * @param callback 回调函数
 */
void Button::setOnStateChange(Function<void(bool)> callback) {
  onStateChange_ = std::move(callback);
}

/**
 * @brief 设置状态文字
 * @param textOff 关闭状态文字
 * @param textOn 开启状态文字
 */
void Button::setStateText(const std::string &textOff,
                          const std::string &textOn) {
  textOff_ = textOff;
  textOn_ = textOn;
  useStateText_ = true;
}

/**
 * @brief 设置状态文字颜色
 * @param colorOff 关闭状态颜色
 * @param colorOn 开启状态颜色
 */
void Button::setStateTextColor(const Color &colorOff, const Color &colorOn) {
  textColorOff_ = colorOff;
  textColorOn_ = colorOn;
  useStateTextColor_ = true;
}

/**
 * @brief 设置悬停光标
 * @param cursor 光标形状
 */
void Button::setHoverCursor(CursorShape cursor) { hoverCursor_ = cursor; }

/**
 * @brief 设置背景图片
 * @param normal 普通状态图片
 * @param hover 悬停状态图片
 * @param pressed 按下状态图片
 */
void Button::setBackgroundImage(Ptr<Texture> normal, Ptr<Texture> hover,
                                Ptr<Texture> pressed) {
  imgNormal_ = normal;
  imgHover_ = hover ? hover : normal;
  imgPressed_ = pressed ? pressed : (hover ? hover : normal);
  useImageBackground_ = (normal != nullptr);
  useTextureRect_ = false;

  if (useImageBackground_ && scaleMode_ == ImageScaleMode::Original && normal) {
    setSize(static_cast<float>(normal->width()),
            static_cast<float>(normal->height()));
  }
}

/**
 * @brief 设置背景图片（带矩形区域）
 * @param texture 纹理
 * @param rect 矩形区域
 */
void Button::setBackgroundImage(Ptr<Texture> texture, const Rect &rect) {
  imgNormal_ = texture;
  imgHover_ = texture;
  imgPressed_ = texture;
  imgNormalRect_ = rect;
  imgHoverRect_ = rect;
  imgPressedRect_ = rect;
  useImageBackground_ = (texture != nullptr);
  useTextureRect_ = true;
  useStateImages_ = false;

  if (useImageBackground_ && scaleMode_ == ImageScaleMode::Original) {
    setSize(rect.size.width, rect.size.height);
  }
}

/**
 * @brief 设置状态背景图片
 * @param offNormal 关闭状态普通图片
 * @param onNormal 开启状态普通图片
 * @param offHover 关闭状态悬停图片
 * @param onHover 开启状态悬停图片
 * @param offPressed 关闭状态按下图片
 * @param onPressed 开启状态按下图片
 */
void Button::setStateBackgroundImage(
    Ptr<Texture> offNormal, Ptr<Texture> onNormal, Ptr<Texture> offHover,
    Ptr<Texture> onHover, Ptr<Texture> offPressed, Ptr<Texture> onPressed) {
  imgOffNormal_ = offNormal;
  imgOnNormal_ = onNormal;
  imgOffHover_ = offHover ? offHover : offNormal;
  imgOnHover_ = onHover ? onHover : onNormal;
  imgOffPressed_ = offPressed ? offPressed : offNormal;
  imgOnPressed_ = onPressed ? onPressed : onNormal;

  useStateImages_ = (offNormal != nullptr && onNormal != nullptr);
  useImageBackground_ = useStateImages_;
  useTextureRect_ = false;

  if (useStateImages_ && scaleMode_ == ImageScaleMode::Original && offNormal) {
    setSize(static_cast<float>(offNormal->width()),
            static_cast<float>(offNormal->height()));
  }
}

/**
 * @brief 设置背景图片缩放模式
 * @param mode 缩放模式
 */
void Button::setBackgroundImageScaleMode(ImageScaleMode mode) {
  scaleMode_ = mode;
  if (useImageBackground_ && scaleMode_ == ImageScaleMode::Original &&
      imgNormal_) {
    setSize(static_cast<float>(imgNormal_->width()),
            static_cast<float>(imgNormal_->height()));
  }
}

/**
 * @brief 设置自定义尺寸（Vec2版本）
 * @param size 尺寸向量
 */
void Button::setCustomSize(const Vec2 &size) { setSize(size.x, size.y); }

/**
 * @brief 设置自定义尺寸（分量版本）
 * @param width 宽度
 * @param height 高度
 */
void Button::setCustomSize(float width, float height) {
  setSize(width, height);
}

/**
 * @brief 获取边界框
 * @return 边界矩形
 */
Rect Button::boundingBox() const {
  auto position = convertToWorldSpace(extra2d::Vec2::Zero());
  auto anchorPt = anchor();
  auto scaleVal = scale();
  auto widgetSize = size();

  if (widgetSize.empty()) {
    return Rect();
  }

  float w = widgetSize.width * scaleVal.x;
  float h = widgetSize.height * scaleVal.y;
  float x0 = position.x - widgetSize.width * anchorPt.x * scaleVal.x;
  float y0 = position.y - widgetSize.height * anchorPt.y * scaleVal.y;

  return Rect(x0, y0, w, h);
}

/**
 * @brief 计算图片尺寸
 * @param buttonSize 按钮尺寸
 * @param imageSize 图片尺寸
 * @return 计算后的图片尺寸
 */
Vec2 Button::calculateImageSize(const Vec2 &buttonSize, const Vec2 &imageSize) {
  switch (scaleMode_) {
  case ImageScaleMode::Original:
    return imageSize;

  case ImageScaleMode::Stretch:
    return buttonSize;

  case ImageScaleMode::ScaleFit: {
    float scaleX = buttonSize.x / imageSize.x;
    float scaleY = buttonSize.y / imageSize.y;
    float scale = std::min(scaleX, scaleY);
    return Vec2(imageSize.x * scale, imageSize.y * scale);
  }

  case ImageScaleMode::ScaleFill: {
    float scaleX = buttonSize.x / imageSize.x;
    float scaleY = buttonSize.y / imageSize.y;
    float scale = std::max(scaleX, scaleY);
    return Vec2(imageSize.x * scale, imageSize.y * scale);
  }
  }
  return imageSize;
}

/**
 * @brief 绘制背景图片
 * @param renderer 渲染后端
 * @param rect 绘制区域
 */
void Button::drawBackgroundImage(Renderer &renderer, const Rect &rect) {
  Texture *texture = nullptr;
  Rect srcRect;

  if (useStateImages_) {
    if (isOn_) {
      if (pressed_ && imgOnPressed_) {
        texture = imgOnPressed_.get();
      } else if (hovered_ && imgOnHover_) {
        texture = imgOnHover_.get();
      } else {
        texture = imgOnNormal_.get();
      }
    } else {
      if (pressed_ && imgOffPressed_) {
        texture = imgOffPressed_.get();
      } else if (hovered_ && imgOffHover_) {
        texture = imgOffHover_.get();
      } else {
        texture = imgOffNormal_.get();
      }
    }
    if (texture) {
      srcRect = Rect(0, 0, static_cast<float>(texture->width()),
                     static_cast<float>(texture->height()));
    }
  } else {
    if (pressed_ && imgPressed_) {
      texture = imgPressed_.get();
      srcRect = useTextureRect_
                    ? imgPressedRect_
                    : Rect(0, 0, static_cast<float>(imgPressed_->width()),
                           static_cast<float>(imgPressed_->height()));
    } else if (hovered_ && imgHover_) {
      texture = imgHover_.get();
      srcRect = useTextureRect_
                    ? imgHoverRect_
                    : Rect(0, 0, static_cast<float>(imgHover_->width()),
                           static_cast<float>(imgHover_->height()));
    } else if (imgNormal_) {
      texture = imgNormal_.get();
      srcRect = useTextureRect_
                    ? imgNormalRect_
                    : Rect(0, 0, static_cast<float>(imgNormal_->width()),
                           static_cast<float>(imgNormal_->height()));
    }
  }

  if (!texture)
    return;

  Vec2 imageSize(srcRect.size.width, srcRect.size.height);
  Vec2 buttonSize(rect.size.width, rect.size.height);
  Vec2 drawSize = calculateImageSize(buttonSize, imageSize);

  Vec2 drawPos(rect.origin.x + (rect.size.width - drawSize.x) * 0.5f,
               rect.origin.y + (rect.size.height - drawSize.y) * 0.5f);

  Rect destRect(drawPos.x, drawPos.y, drawSize.x, drawSize.y);

  renderer.drawSprite(*texture, destRect, srcRect, Colors::White, 0.0f,
                      Vec2::Zero());
}

/**
 * @brief 绘制圆角矩形边框
 * @param renderer 渲染后端
 * @param rect 矩形区域
 * @param color 颜色
 * @param radius 圆角半径
 */
void Button::drawRoundedRect(Renderer &renderer, const Rect &rect,
                             const Color &color, float radius) {
  float maxRadius = std::min(rect.size.width, rect.size.height) * 0.5f;
  radius = std::min(radius, maxRadius);

  if (radius <= 0.0f) {
    renderer.drawRect(rect, color, borderWidth_);
    return;
  }

  const int segments = 8;
  float x = rect.origin.x;
  float y = rect.origin.y;
  float w = rect.size.width;
  float h = rect.size.height;
  float r = radius;

  renderer.drawLine(Vec2(x + r, y), Vec2(x + w - r, y), color, borderWidth_);
  renderer.drawLine(Vec2(x + r, y + h), Vec2(x + w - r, y + h), color,
                    borderWidth_);
  renderer.drawLine(Vec2(x, y + r), Vec2(x, y + h - r), color, borderWidth_);
  renderer.drawLine(Vec2(x + w, y + r), Vec2(x + w, y + h - r), color,
                    borderWidth_);

  for (int i = 0; i < segments; i++) {
    float angle1 = 3.14159f * 0.5f * (float)i / segments + 3.14159f;
    float angle2 = 3.14159f * 0.5f * (float)(i + 1) / segments + 3.14159f;
    Vec2 p1(x + r + r * cosf(angle1), y + r + r * sinf(angle1));
    Vec2 p2(x + r + r * cosf(angle2), y + r + r * sinf(angle2));
    renderer.drawLine(p1, p2, color, borderWidth_);
  }
  for (int i = 0; i < segments; i++) {
    float angle1 = 3.14159f * 0.5f * (float)i / segments + 3.14159f * 1.5f;
    float angle2 =
        3.14159f * 0.5f * (float)(i + 1) / segments + 3.14159f * 1.5f;
    Vec2 p1(x + w - r + r * cosf(angle1), y + r + r * sinf(angle1));
    Vec2 p2(x + w - r + r * cosf(angle2), y + r + r * sinf(angle2));
    renderer.drawLine(p1, p2, color, borderWidth_);
  }
  for (int i = 0; i < segments; i++) {
    float angle1 = 3.14159f * 0.5f * (float)i / segments;
    float angle2 = 3.14159f * 0.5f * (float)(i + 1) / segments;
    Vec2 p1(x + w - r + r * cosf(angle1), y + h - r + r * sinf(angle1));
    Vec2 p2(x + w - r + r * cosf(angle2), y + h - r + r * sinf(angle2));
    renderer.drawLine(p1, p2, color, borderWidth_);
  }
  for (int i = 0; i < segments; i++) {
    float angle1 = 3.14159f * 0.5f * (float)i / segments + 3.14159f * 0.5f;
    float angle2 =
        3.14159f * 0.5f * (float)(i + 1) / segments + 3.14159f * 0.5f;
    Vec2 p1(x + r + r * cosf(angle1), y + h - r + r * sinf(angle1));
    Vec2 p2(x + r + r * cosf(angle2), y + h - r + r * sinf(angle2));
    renderer.drawLine(p1, p2, color, borderWidth_);
  }
}

/**
 * @brief 填充圆角矩形
 * @param renderer 渲染后端
 * @param rect 矩形区域
 * @param color 颜色
 * @param radius 圆角半径
 */
void Button::fillRoundedRect(Renderer &renderer, const Rect &rect,
                             const Color &color, float radius) {
  float maxRadius = std::min(rect.size.width, rect.size.height) * 0.5f;
  radius = std::min(radius, maxRadius);

  if (radius <= 0.0f) {
    renderer.fillRect(rect, color);
    return;
  }

  const int segments = 8;
  float x = rect.origin.x;
  float y = rect.origin.y;
  float w = rect.size.width;
  float h = rect.size.height;
  float r = radius;

  std::vector<Vec2> vertices;

  vertices.push_back(Vec2(x + r, y + r));
  vertices.push_back(Vec2(x + w - r, y + r));
  vertices.push_back(Vec2(x + w - r, y + h - r));
  vertices.push_back(Vec2(x + r, y + h - r));

  renderer.fillPolygon(vertices, color);

  renderer.fillRect(Rect(x + r, y, w - 2 * r, r), color);
  renderer.fillRect(Rect(x + r, y + h - r, w - 2 * r, r), color);
  renderer.fillRect(Rect(x, y + r, r, h - 2 * r), color);
  renderer.fillRect(Rect(x + w - r, y + r, r, h - 2 * r), color);

  vertices.clear();
  vertices.push_back(Vec2(x + r, y + r));
  for (int i = 0; i <= segments; i++) {
    float angle = 3.14159f + 3.14159f * 0.5f * (float)i / segments;
    vertices.push_back(Vec2(x + r + r * cosf(angle), y + r + r * sinf(angle)));
  }
  renderer.fillPolygon(vertices, color);

  vertices.clear();
  vertices.push_back(Vec2(x + w - r, y + r));
  for (int i = 0; i <= segments; i++) {
    float angle = 3.14159f * 1.5f + 3.14159f * 0.5f * (float)i / segments;
    vertices.push_back(
        Vec2(x + w - r + r * cosf(angle), y + r + r * sinf(angle)));
  }
  renderer.fillPolygon(vertices, color);

  vertices.clear();
  vertices.push_back(Vec2(x + w - r, y + h - r));
  for (int i = 0; i <= segments; i++) {
    float angle = 0 + 3.14159f * 0.5f * (float)i / segments;
    vertices.push_back(
        Vec2(x + w - r + r * cosf(angle), y + h - r + r * sinf(angle)));
  }
  renderer.fillPolygon(vertices, color);

  vertices.clear();
  vertices.push_back(Vec2(x + r, y + h - r));
  for (int i = 0; i <= segments; i++) {
    float angle = 3.14159f * 0.5f + 3.14159f * 0.5f * (float)i / segments;
    vertices.push_back(
        Vec2(x + r + r * cosf(angle), y + h - r + r * sinf(angle)));
  }
  renderer.fillPolygon(vertices, color);
}

/**
 * @brief 绘制组件
 * @param renderer 渲染后端
 */
void Button::onDrawWidget(Renderer &renderer) {
  Rect rect = boundingBox();
  if (rect.empty()) {
    return;
  }

  if (useImageBackground_) {
    drawBackgroundImage(renderer, rect);
  } else {
    renderer.endSpriteBatch();

    Color bg = bgNormal_;
    if (pressed_) {
      bg = bgPressed_;
    } else if (hovered_) {
      bg = bgHover_;
    }

    if (roundedCornersEnabled_) {
      fillRoundedRect(renderer, rect, bg, cornerRadius_);
    } else {
      renderer.fillRect(rect, bg);
    }

    renderer.beginSpriteBatch();

    renderer.endSpriteBatch();

    if (borderWidth_ > 0.0f) {
      if (roundedCornersEnabled_) {
        drawRoundedRect(renderer, rect, borderColor_, cornerRadius_);
      } else {
        renderer.drawRect(rect, borderColor_, borderWidth_);
      }
    }

    renderer.beginSpriteBatch();
  }

  if (font_) {
    std::string textToDraw;
    if (useStateText_) {
      textToDraw = isOn_ ? textOn_ : textOff_;
    } else {
      textToDraw = text_;
    }

    Color colorToUse;
    if (useStateTextColor_) {
      colorToUse = isOn_ ? textColorOn_ : textColorOff_;
    } else {
      colorToUse = textColor_;
    }

    if (!textToDraw.empty()) {
      Vec2 textSize = font_->measureText(textToDraw);

      Vec2 textPos(rect.center().x - textSize.x * 0.5f,
                   rect.center().y - textSize.y * 0.5f);

      float minX = rect.left() + padding_.x;
      float minY = rect.top() + padding_.y;
      float maxX = rect.right() - padding_.x - textSize.x;
      float maxY = rect.bottom() - padding_.y - textSize.y;

      textPos.x = std::max(minX, std::min(textPos.x, maxX));
      textPos.y = std::max(minY, std::min(textPos.y, maxY));

      colorToUse.a = 1.0f;

      renderer.drawText(*font_, textToDraw, textPos, colorToUse);
    }
  }
}

} // namespace extra2d