#include "ColorPickerPopup.hpp"

#include <algorithm>
#include <cmath>

namespace jdi
{

	namespace
	{
		const float kPanelWidth = 214.0f;		/**< 面板宽度（逻辑像素）。 */
		const float kPadH = 12.0f;				/**< 面板左右内边距。 */
		const float kPadV = 10.0f;				/**< 面板上下内边距。 */
		const float kTitleHeight = 20.0f;		/**< 标题行高度。 */
		const float kTitleGap = 8.0f;			/**< 标题与滑块区间距。 */
		const float kRowHeight = 26.0f;			/**< 单个滑块行高度。 */
		const float kRowGap = 2.0f;				/**< 滑块行间距。 */
		const float kPreviewGap = 10.0f;		/**< 滑块区与预览区间距。 */
		const float kPreviewHeight = 24.0f;		/**< 预览行高度。 */
		const float kLabelWidth = 16.0f;		/**< 通道标签宽度。 */
		const float kLabelGap = 6.0f;			/**< 标签与滑块间距。 */
		const float kValueWidth = 40.0f;		/**< 数值文本宽度。 */
		const float kTrackHeight = 6.0f;		/**< 滑块轨道高度。 */
		const float kCorner = 6.0f;				/**< 面板圆角半径。 */

		/** @brief 通道显示名称。 */
		const wchar_t* kChannelNames[3] = {L"R", L"G", L"B"};

		/** @brief 通道滑块填充色。 */
		const std::uint32_t kChannelColors[3] = {0xFFDC322Fu, 0xFF859900u, 0xFF268BD2u};

		/**
		 * @brief 绘制水平滑块（轨道 + 已填充部分 + 圆钮）。
		 * @param [IN,OUT] g 绘图上下文。
		 * @param [IN] track 轨道矩形。
		 * @param [IN] ratio 当前值比例（0-1）。
		 * @param [IN] fillColor 已填充部分颜色。
		 * @param [IN] hovered 是否处于悬停或拖拽状态。
		 * @param [IN] scale 缩放比例。
		 */
		void DrawChannelSlider(gd::Graphics& g, const gd::RectF& track, double ratio, std::uint32_t fillColor,
		                       bool hovered, float scale)
		{
			const float radius = track.Height * 0.5f;
			UiFillRoundRect(g, track, radius, 0x2A657B83u);

			ratio = std::max(0.0, std::min(1.0, ratio));
			const float fillWidth = std::max(track.Height, static_cast<float>(ratio) * track.Width);
			UiFillRoundRect(g, gd::RectF(track.X, track.Y, fillWidth, track.Height), radius, fillColor);

			const float knobX = track.X + static_cast<float>(ratio) * track.Width;
			const float knobRadius = radius + (hovered ? 2.5f * scale : 0.8f * scale);

			gd::SolidBrush knob(ToGdiColor(0xFFFFFFFFu));
			gd::Pen knobPen(ToGdiColor(0xFF586E75u), 1.4f * scale);
			g.FillEllipse(&knob, knobX - knobRadius, track.Y + radius - knobRadius, knobRadius * 2.0f,
			              knobRadius * 2.0f);
			g.DrawEllipse(&knobPen, knobX - knobRadius, track.Y + radius - knobRadius, knobRadius * 2.0f,
			              knobRadius * 2.0f);
		}

		/**
		 * @brief 将 0-1 分量换算为 0-255 整数。
		 * @param [IN] value 分量值。
		 * @return 整数分量。
		 */
		unsigned int ToByte(double value)
		{
			const double scaled = value * 255.0 + 0.5;
			if (scaled < 0.0)
			{
				return 0u;
			}
			if (scaled > 255.0)
			{
				return 255u;
			}
			return static_cast<unsigned int>(scaled);
		}
	}

	ColorPickerPopup::ColorPickerPopup() = default;

	void ColorPickerPopup::Setup(const UiFonts* fonts, const Theme* theme)
	{
		m_fonts = fonts;
		m_theme = theme;
	}

	void ColorPickerPopup::SetScale(float scale)
	{
		m_scale = (scale > 0.1f) ? scale : 1.0f;
	}

	std::uint32_t ColorPickerPopup::CurrentColor() const
	{
		const unsigned int r = ToByte(m_channels[0]);
		const unsigned int g = ToByte(m_channels[1]);
		const unsigned int b = ToByte(m_channels[2]);
		return 0xFF000000u | (r << 16) | (g << 8) | b;
	}

	bool ColorPickerPopup::TakeChanged(std::uint32_t& color)
	{
		if (!m_changed)
		{
			return false;
		}
		m_changed = false;
		color = CurrentColor();
		return true;
	}

	void ColorPickerPopup::BuildLayout(const gd::RectF& bounds, int x, int y)
	{
		const float width = kPanelWidth * m_scale;
		const float height = (kPadV * 2.0f + kTitleHeight + kTitleGap + kRowHeight * 3.0f + kRowGap * 2.0f +
		                      kPreviewGap + kPreviewHeight) *
		                     m_scale;

		float left = static_cast<float>(x);
		float top = static_cast<float>(y);

		// 优先向右下展开；越界时翻转，最后做边界收敛。
		if (left + width > bounds.X + bounds.Width)
		{
			left = static_cast<float>(x) - width;
		}
		if (top + height > bounds.Y + bounds.Height)
		{
			top = static_cast<float>(y) - height;
		}
		left = std::max(bounds.X + 2.0f, std::min(left, bounds.X + bounds.Width - width - 2.0f));
		top = std::max(bounds.Y + 2.0f, std::min(top, bounds.Y + bounds.Height - height - 2.0f));

		m_rect = gd::RectF(left, top, width, height);

		m_titleRect = gd::RectF(left + kPadH * m_scale, top + kPadV * m_scale,
		                        width - kPadH * 2.0f * m_scale, kTitleHeight * m_scale);

		const float trackLeft = left + (kPadH + kLabelWidth + kLabelGap) * m_scale;
		const float trackWidth =
		    std::max(40.0f, width - (trackLeft - left) - (kPadH + kValueWidth) * m_scale);
		const float firstTop = m_titleRect.Y + m_titleRect.Height + kTitleGap * m_scale;

		for (int index = 0; index < 3; ++index)
		{
			const float rowTop = firstTop + static_cast<float>(index) * (kRowHeight + kRowGap) * m_scale;
			m_tracks[static_cast<std::size_t>(index)] =
			    gd::RectF(trackLeft, rowTop + (kRowHeight * m_scale - kTrackHeight * m_scale) * 0.5f,
			              trackWidth, kTrackHeight * m_scale);
			m_values[static_cast<std::size_t>(index)] =
			    gd::RectF(trackLeft + trackWidth + 6.0f * m_scale, rowTop,
			              kValueWidth * m_scale - 6.0f * m_scale, kRowHeight * m_scale);
		}

		const float previewTop = firstTop + 3.0f * (kRowHeight + kRowGap) * m_scale + kPreviewGap * m_scale;
		m_previewRect = gd::RectF(trackLeft, previewTop + 2.0f * m_scale, 52.0f * m_scale, 20.0f * m_scale);
		m_hexRect = gd::RectF(m_previewRect.X + m_previewRect.Width + 8.0f * m_scale, previewTop + 2.0f * m_scale,
		                      96.0f * m_scale, 20.0f * m_scale);
	}

	void ColorPickerPopup::Open(const gd::RectF& bounds, int x, int y, std::uint32_t color)
	{
		m_channels[0] = static_cast<double>((color >> 16) & 0xFFu) / 255.0;
		m_channels[1] = static_cast<double>((color >> 8) & 0xFFu) / 255.0;
		m_channels[2] = static_cast<double>(color & 0xFFu) / 255.0;

		m_open = true;
		m_changed = false;
		m_draggingSlider = -1;
		m_hoverSlider = -1;

		BuildLayout(bounds, x, y);
	}

	void ColorPickerPopup::Close()
	{
		m_open = false;
		m_draggingSlider = -1;
		m_hoverSlider = -1;
	}

	bool ColorPickerPopup::ContainsPoint(int x, int y) const
	{
		if (!m_open)
		{
			return false;
		}
		return UiPointInRect(m_rect, static_cast<float>(x), static_cast<float>(y));
	}

	int ColorPickerPopup::SliderAtPoint(int x, int y) const
	{
		if (!m_open)
		{
			return -1;
		}

		const float fx = static_cast<float>(x);
		const float fy = static_cast<float>(y);
		for (int index = 0; index < 3; ++index)
		{
			const gd::RectF& track = m_tracks[static_cast<std::size_t>(index)];
			// 命中范围在纵向适当放宽，便于拖拽。
			const gd::RectF hit(track.X - 4.0f * m_scale, track.Y - 9.0f * m_scale,
			                    track.Width + 8.0f * m_scale, track.Height + 18.0f * m_scale);
			if (UiPointInRect(hit, fx, fy))
			{
				return index;
			}
		}
		return -1;
	}

	void ColorPickerPopup::ApplySlider(int index, float x)
	{
		if (index < 0 || index >= 3)
		{
			return;
		}
		const std::size_t slot = static_cast<std::size_t>(index);
		const double ratio = UiSliderRatioFromX(m_tracks[slot], x);
		if (std::fabs(ratio - m_channels[slot]) < 1.0e-6)
		{
			return;
		}
		m_channels[slot] = ratio;
		m_changed = true;
	}

	bool ColorPickerPopup::OnMouseMove(int x, int y)
	{
		if (!m_open)
		{
			return false;
		}

		if (m_draggingSlider >= 0)
		{
			ApplySlider(m_draggingSlider, static_cast<float>(x));
			return true;
		}

		const int hover = SliderAtPoint(x, y);
		if (hover == m_hoverSlider)
		{
			return false;
		}
		m_hoverSlider = hover;
		return true;
	}

	bool ColorPickerPopup::OnLButtonDown(int x, int y)
	{
		if (!m_open)
		{
			return false;
		}

		if (!ContainsPoint(x, y))
		{
			// 点击面板外部：收起面板（外部点击不再下传，避免误触其他控件）。
			Close();
			return true;
		}

		m_draggingSlider = SliderAtPoint(x, y);
		if (m_draggingSlider >= 0)
		{
			ApplySlider(m_draggingSlider, static_cast<float>(x));
			return true;
		}
		return true;
	}

	bool ColorPickerPopup::OnLButtonUp()
	{
		if (!m_open || m_draggingSlider < 0)
		{
			return false;
		}
		m_draggingSlider = -1;
		return true;
	}

	bool ColorPickerPopup::OnKeyDown(WPARAM key)
	{
		if (!m_open)
		{
			return false;
		}
		if (key == VK_ESCAPE)
		{
			Close();
		}
		return true;
	}

	void ColorPickerPopup::Paint(gd::Graphics& g)
	{
		if (!m_open || m_theme == nullptr || m_fonts == nullptr || m_rect.Width <= 0.0f)
		{
			return;
		}

		// 投影。
		UiFillRoundRect(g, gd::RectF(m_rect.X + 1.0f * m_scale, m_rect.Y + 2.0f * m_scale, m_rect.Width,
		                             m_rect.Height),
		                kCorner * m_scale, 0x14000000u);
		UiFillRoundRect(g, gd::RectF(m_rect.X + 2.0f * m_scale, m_rect.Y + 4.0f * m_scale, m_rect.Width,
		                             m_rect.Height),
		                kCorner * m_scale, 0x10000000u);

		UiFillRoundRect(g, m_rect, kCorner * m_scale, m_theme->cardBg);
		UiDrawRoundRect(g, m_rect, kCorner * m_scale, m_theme->borderStrong, 1.0f);

		UiText(g, L"自定义颜色", m_fonts->uiSmallBold, m_titleRect, m_theme->textMuted, TextAlign::LEFT);

		for (int index = 0; index < 3; ++index)
		{
			const std::size_t slot = static_cast<std::size_t>(index);
			const gd::RectF& track = m_tracks[slot];

			const gd::RectF labelRect(m_rect.X + kPadH * m_scale, track.Y - 9.0f * m_scale,
			                          kLabelWidth * m_scale, kRowHeight * m_scale);
			UiText(g, kChannelNames[index], m_fonts->uiSmall, labelRect, m_theme->textMuted, TextAlign::LEFT);

			const bool active = (m_draggingSlider == index) || (m_hoverSlider == index);
			DrawChannelSlider(g, track, m_channels[slot], kChannelColors[index], active, m_scale);

			UiText(g, std::to_wstring(ToByte(m_channels[slot])), m_fonts->monoSmall, m_values[slot],
			       m_theme->text, TextAlign::RIGHT);
		}

		// 预览与十六进制值。
		const std::uint32_t color = CurrentColor();
		UiFillRoundRect(g, m_previewRect, 3.0f * m_scale, color);
		UiDrawRoundRect(g, m_previewRect, 3.0f * m_scale, m_theme->borderStrong, 1.0f);

		wchar_t buffer[16];
		swprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), L"#%02X%02X%02X", (color >> 16) & 0xFFu,
		         (color >> 8) & 0xFFu, color & 0xFFu);
		UiText(g, std::wstring(buffer), m_fonts->monoSmall, m_hexRect, m_theme->text, TextAlign::LEFT);
	}

} // namespace jdi