#include <psemek/ui/default_element_factory.hpp>

#include <psemek/ui/box_shape.hpp>

#include <psemek/io/memory_stream.hpp>

#include <psemek/ui/resources/cross_red_16x16_png.hpp>

namespace psemek::ui
{

	namespace
	{

		struct button_impl
			: rich_button
		{
			struct shape const & shape() const override
			{
				return shape_;
			}

			void reshape(geom::box<float, 2> const & bbox) override
			{
				shape_.box = bbox;
				auto st = merged_own_style();

				geom::vector offset{0.f, 0.f};
				if (state() == state_t::mousedown)
					offset = geom::cast<float>(*st->action_offset);

				element * c = label() ? (element *)label() : icon();
				if (c) c->reshape(geom::shrink(bbox, 1.f * (*st->border_width + *st->inner_margin)) + offset);
			}

			void on_state_changed(state_t old) override
			{
				rich_button::on_state_changed(old);

				gfx::color_rgba color{0, 0, 0, 0};

				switch (state()) {
				case state_t::mouseover:
					color = {255, 255, 255, 63};
					break;
				case state_t::mousedown:
					color = {0, 0, 0, 63};
					break;
				default:
					break;
				}

				if (icon())
					icon()->set_color(color);
			}

			void draw(painter & p) const override
			{
				auto st = merged_own_style();
				if (!st) return;

				if (st->shadow_offset != geom::vector{0, 0})
					p.draw_rect(shape_.box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);

				auto offset = geom::vector{0.f, 0.f};
				if (state() == state_t::mousedown)
					offset = geom::cast<float>(*st->action_offset);

				if (st->border_width > 0)
					p.draw_rect(shape_.box + offset, *st->border_color);

				gfx::color_rgba color = *st->fg_color;
				if (state() == state_t::mouseover)
					color = *st->highlight_color;
				else if (state() == state_t::mousedown)
					color = *st->action_color;
				p.draw_rect(geom::shrink(shape_.box, 1.f * (*st->border_width)) + offset, color);
			}

			geom::box<float, 2> size_constraints() const override
			{
				auto sc = element::size_constraints();

				element const * c = label() ? (element const *)label() : icon();

				if (c)
				{
					sc = c->size_constraints();

					if (auto st = merged_own_style())
					{
						float extra = 2.f * (*st->border_width + *st->inner_margin);
						sc[0] += extra;
						sc[1] += extra;
					}
				}

				return sc;
			}

		private:
			box_shape shape_;
		};

		struct frame_impl
			: frame
		{
			struct shape const & shape() const override { return shape_; }

			void reshape(geom::box<float, 2> const & bbox) override
			{
				shape_.box = bbox;
				auto st = merged_own_style();
				if (!st) return;
				for (auto c : children())
					if (c) c->reshape(geom::shrink(bbox, 1.f * (*st->border_width + *st->outer_margin)));
			}

			geom::box<float, 2> size_constraints() const override
			{
				geom::box<float, 2> r = element::size_constraints();

				for (auto c : children())
					if (c)
						r = c->size_constraints();

				auto st = merged_own_style();
				if (st)
				{
					float extra = 2.f * (*st->border_width + *st->outer_margin);
					r[0] += extra;
					r[1] += extra;
				}

				if (min_size())
				{
					auto s = *min_size();
					r[0].min = s[0];
					r[1].min = s[1];
				}

				if (max_size())
				{
					auto s = *max_size();
					r[0].max = s[0];
					r[1].max = s[1];
				}

				return r;
			}

			void draw(painter & p) const override
			{
				auto st = merged_own_style();
				if (!st) return;

				if (st->shadow_offset != geom::vector{0, 0})
					p.draw_rect(shape_.box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);

				if (st->border_width > 0)
					p.draw_rect(shape_.box, *st->border_color);
				p.draw_rect(geom::shrink(shape_.box, 1.f * (*st->border_width)), *st->bg_color);
			}

		private:
			box_shape shape_;
		};

		struct window_impl
			: window
		{
			window_impl(std::shared_ptr<gfx::texture_2d> close_icon)
				: caption_(std::make_shared<label>())
				, close_button_(std::make_shared<button_impl>())
			{
				close_button_->set_icon(std::make_shared<image_view>());
				close_button_->icon()->set_image(close_icon);

				caption_->set_parent(this);
				close_button_->set_parent(this);

				caption_->set_valign(label::valignment::center);
				caption_->set_overflow(label::overflow_mode::ellipsis);

				auto close_button_style = std::make_shared<struct style>();
				close_button_style->shadow_offset = {0, 0};
				close_button_->set_style(close_button_style);

				children_[0] = caption_.get();
				children_[1] = close_button_.get();
				children_[2] = nullptr;

				on_close_ = [this]
				{
					if (auto p = dynamic_cast<container *>(parent()))
						p->remove_child(this);
					else
						throw std::runtime_error("Cannot remove window from non-container parent");
				};
			}

			void setup_close()
			{
				auto weak_self = weak_from_this();
				close_button_->on_click([weak_self]{
					if (auto self = std::dynamic_pointer_cast<window_impl>(weak_self.lock()))
					{
						if (self->on_close_)
							self->on_close_();
					}
				});
			}

			void set_caption(std::string caption) override
			{
				caption_->set_text(caption);
			}

			std::shared_ptr<element> set_child(std::shared_ptr<element> c) override
			{
				if (child_) child_->set_parent(nullptr);
				std::swap(child_, c);
				if (child_) child_->set_parent(this);
				children_[2] = child_.get();
				return c;
			}

			children_range children() const override
			{
				return children_range{children_};
			}

			void on_close(on_close_callback callback) override
			{
				on_close_ = std::move(callback);
			}

			bool on_event(mouse_move  const & e) override
			{
				mouse_ = e.position;

				if (drag_ && *drag_ != e.position)
				{
					shape_.box += geom::cast<float>(e.position - *drag_);
					drag_ = e.position;
					post_reshape();
				}

				return shape().contains(geom::cast<float>(*mouse_));
			}

			bool on_event(mouse_click const & e) override
			{
				if (!mouse_ || !shape().contains(geom::cast<float>(*mouse_)))
					return false;

				if (e.button == mouse_button::left && mouse_)
				{
					if (e.down)
						drag_ = *mouse_;
					else
						drag_ = std::nullopt;
				}
				return true;
			}

			bool on_event(mouse_wheel const &) override
			{
				return mouse_ && shape().contains(geom::cast<float>(*mouse_));
			}

			struct shape const & shape() const override
			{
				return shape_;
			}

			void reshape(geom::box<float, 2> const & bbox) override
			{
				shape_.box = bbox;

				auto lc = caption_->size_constraints();
				auto bc = close_button_->size_constraints();

				auto st = merged_own_style();

				float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin) + 2.f * (*st->border_width), bc[1].min);

				{
					geom::box<float, 2> b;
					b[0].min = bbox[0].max - bc[0].min;
					b[0].max = bbox[0].max;
					b[1].min = bbox[1].min;
					b[1].max = bbox[1].min + header_height;
					close_button_->reshape(b);
				}

				{
					geom::box<float, 2> b;
					b[0].min = bbox[0].min + (*st->inner_margin) + (*st->border_width);
					b[0].max = bbox[0].max - (*st->inner_margin) - bc[0].min;
					b[1].min = bbox[1].min + (*st->inner_margin) + (*st->border_width);
					b[1].max = bbox[1].min + header_height - (*st->inner_margin) - (*st->border_width);
					caption_->reshape(b);
				}

				if (child_)
				{
					geom::box<float, 2> b;
					b[0].min = bbox[0].min + (*st->border_width);
					b[0].max = bbox[0].max - (*st->border_width);
					b[1].min = bbox[1].min + header_height;
					b[1].max = bbox[1].max - (*st->border_width);
					child_->reshape(b);
				}
			}

			geom::box<float, 2> size_constraints() const override
			{
				geom::box<float, 2> r = element::size_constraints();
				if (child_) r = child_->size_constraints();

				auto lc = caption_->size_constraints();
				auto bc = close_button_->size_constraints();

				auto st = merged_own_style();

				float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin) + 2.f * (*st->border_width), bc[1].min);

				r[0].min = std::max(r[0].min + 2.f * (*st->inner_margin) + 2.f * (*st->border_width), (*st->border_width) + lc[0].min + bc[0].min);
				r[1] += (*st->border_width) * 1.f + header_height;

				return r;
			}

			void draw(painter & p) const override
			{
				auto st = merged_own_style();

				auto lc = caption_->size_constraints();
				auto bc = close_button_->size_constraints();

				auto const & bb = shape_.box;

				if (*st->shadow_offset != geom::vector{0, 0})
					p.draw_rect(bb + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
				p.draw_rect(bb, *st->border_color);

				float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin) + 2.f * (*st->border_width), bc[1].min);
				p.draw_rect({{{bb[0].min + (*st->border_width), bb[0].max - bc[0].min}, {bb[1].min + (*st->border_width), bb[1].min + header_height - (*st->border_width)}}},
					*st->fg_color);
				p.draw_rect({{{bb[0].min + (*st->border_width), bb[0].max - (*st->border_width)}, {bb[1].min + header_height, bb[1].max - (*st->border_width)}}},
					*st->bg_color);
			}

		private:
			std::shared_ptr<label> caption_;
			std::shared_ptr<rich_button> close_button_;
			std::shared_ptr<element> child_;

			on_close_callback on_close_;

			std::optional<geom::point<int, 2>> mouse_;
			std::optional<geom::point<int, 2>> drag_;

			box_shape shape_;

			element * children_[3];
		};

		struct checkbox_impl
			: checkbox
		{
			struct shape const & shape() const override
			{
				return shape_;
			}

			void reshape(geom::box<float, 2> const & bbox) override
			{
				shape_.box = geom::expand(geom::box<float, 2>::singleton(bbox.center()), size() / 2.f);
			}

			void draw(painter & p) const override
			{
				auto st = merged_own_style();
				if (!st) return;

				geom::box<float, 2> boxes[5];

				boxes[0] = {{shape_.box[0], {shape_.box[1].min, shape_.box[1].min + outer_width()}}};
				boxes[1] = {{shape_.box[0], {shape_.box[1].max - outer_width(), shape_.box[1].max}}};
				boxes[2] = {{{shape_.box[0].min, shape_.box[0].min + outer_width()}, {shape_.box[1].min + outer_width(), shape_.box[1].max - outer_width()}}};
				boxes[3] = {{{shape_.box[0].max - outer_width(), shape_.box[0].max}, {shape_.box[1].min + outer_width(), shape_.box[1].max - outer_width()}}};
				boxes[4] = geom::shrink(shape_.box, 0.f + outer_width() + outer_margin());

				int const box_count = value() ? 5 : 4;

				if (st->shadow_offset != geom::vector{0, 0})
				{
					auto const offset = geom::cast<float>(*st->shadow_offset);
					for (int b = 0; b < box_count; ++b)
						p.draw_rect(boxes[b] + offset, *st->shadow_color);
				}

				auto offset = geom::vector{0.f, 0.f};
				if (state() == state_t::mousedown)
					offset = geom::cast<float>(*st->action_offset);

				gfx::color_rgba color = *st->fg_color;
				if (state() == state_t::mouseover)
					color = *st->highlight_color;
				else if (state() == state_t::mousedown)
					color = *st->action_color;

				for (int b = 0; b < box_count; ++b)
					p.draw_rect(boxes[b] + offset, color);
			}

			geom::box<float, 2> size_constraints() const override
			{
				auto sc = element::size_constraints();

				sc[0] &= geom::interval<float>{size(), std::numeric_limits<float>::infinity()};
				sc[1] &= geom::interval<float>{size(), std::numeric_limits<float>::infinity()};

				return sc;
			}

		private:
			box_shape shape_;

			int size() const
			{
				return *merged_own_style()->ref_height;
			}

			int outer_width() const
			{
				return *merged_own_style()->ref_height / 8;
			}

			int outer_margin() const
			{
				return *merged_own_style()->ref_height / 8;
			}
		};

		struct slider_impl
			: slider
		{
			struct shape const & shape() const override { return shape_; }

			void reshape(geom::box<float, 2> const & bbox) override
			{
				shape_.box = bbox;
			}

			geom::box<float, 2> size_constraints() const override
			{
				static float const inf = std::numeric_limits<float>::infinity();
				return {{{button_width(), inf}, {button_height(), inf}}};
			}

			void draw(painter & p) const override
			{
				auto st = merged_own_style();

				geom::box<float, 2> ab;
				ab[0] = shape_.box[0];
				ab[1] = geom::expand(geom::interval<float>::singleton(shape_.box[1].center()), axis_width() / 2.f);

				gfx::color_rgba c = *st->fg_color;
				if (state() == state_t::mouseover)
					c = *st->highlight_color;
				else if (state() == state_t::mousedown)
					c = *st->action_color;

				auto const r = slider_range();

				float x = geom::lerp(r, geom::unlerp<float>(geom::cast<float>(value_range()), value()));

				geom::box<float, 2> sb;
				sb[0] = geom::expand(geom::interval<float>::singleton(x), button_width() / 2.f);
				sb[1] = geom::expand(geom::interval<float>::singleton(shape_.box[1].center()), button_height() / 2.f);

				if (*st->shadow_offset != geom::vector{0, 0})
				{
					auto off = geom::cast<float>(*st->shadow_offset);
					p.draw_rect(ab + off, *st->shadow_color);
					p.draw_rect(sb + off, *st->shadow_color);
				}

				p.draw_rect(ab, *st->axis_color);
				if (*st->border_width != 0)
					p.draw_rect(sb, *st->border_color);
				p.draw_rect(geom::shrink(sb, 1.f * (*st->border_width)), c);
			}

		protected:

			geom::interval<float> slider_range() const override
			{
				return geom::shrink(shape_.box[0], button_width() / 2.f);
			}

		private:
			box_shape shape_;

			int button_width() const
			{
				auto st = merged_own_style();
				return *st->ref_height / 3;
			}

			int button_height() const
			{
				auto st = merged_own_style();
				return *st->ref_height;
			}

			int axis_width() const
			{
				auto st = merged_own_style();
				return *st->ref_height / 5;
			}
		};

		struct arrow_button_impl
			: button
		{
			arrow_button_impl(int direction)
				: direction_{direction}
			{}

			geom::box<float, 2> size_constraints() const override
			{
				auto b = button::size_constraints();

				auto st = merged_own_style();
				b[0].min = *st->ref_height / 2.f;
				b[1].min = *st->ref_height / 2.f;

				return b;
			}

			struct shape const & shape() const override
			{
				return shape_;
			}

			void reshape(geom::box<float, 2> const & box) override
			{
				shape_.box = box;

				switch (direction_)
				{
				case 0:
					triangle_[0] = box.corner(0.f, 1.f);
					triangle_[1] = box.corner(1.f, 1.f);
					triangle_[2] = box.corner(0.5f, 0.f);
					break;
				case 1:
					triangle_[0] = box.corner(0.f, 0.f);
					triangle_[1] = box.corner(1.f, 0.f);
					triangle_[2] = box.corner(0.5f, 1.f);
					break;
				case 2:
					triangle_[0] = box.corner(1.f, 0.f);
					triangle_[1] = box.corner(1.f, 1.f);
					triangle_[2] = box.corner(0.f, 0.5f);
					break;
				case 3:
					triangle_[0] = box.corner(0.f, 0.f);
					triangle_[1] = box.corner(0.f, 1.f);
					triangle_[2] = box.corner(1.f, 0.5f);
					break;
				default:
					throw std::runtime_error("Unknown arrow button direction");
				}

				if (geom::volume(triangle_[0], triangle_[1], triangle_[2]) < 0.f)
					std::swap(triangle_[1], triangle_[2]);
			}

			void draw(painter &p) const override
			{
				auto st = merged_own_style();

				if (*st->shadow_offset != geom::vector{0, 0})
					p.draw_triangle(triangle_ + geom::cast<float>(*st->shadow_offset), *st->shadow_color);

				geom::vector off{0.f, 0.f};
				if (state() == state_t::mousedown)
					off = geom::cast<float>(*st->action_offset);

				gfx::color_rgba color = *st->fg_color;
				if (state() == state_t::mouseover)
					color = *st->highlight_color;
				else if (state() == state_t::mousedown)
					color = *st->action_color;
				p.draw_triangle(triangle_ + off, color);
			}

		private:
			int const direction_;
			box_shape shape_;
			geom::triangle<geom::point<float, 2>> triangle_;
		};

		struct spinbox_impl
			: spinbox
		{
			spinbox_impl()
			{
				auto layout = std::make_shared<grid_layout>();
				layout->set_row_count(2);

				auto inc_button = std::make_shared<arrow_button_impl>(0);
				auto dec_button = std::make_shared<arrow_button_impl>(1);

				inc_button->on_click([this]{
					inc();
				});

				dec_button->on_click([this]{
					dec();
				});

				layout->set(0, 0, inc_button);
				layout->set(1, 0, dec_button);
				layout->set_outer_margin(false);

				child_ = layout;
				children_range_[0] = child_.get();
				child_->set_parent(this);
			}

			geom::box<float, 2> size_constraints() const override
			{
				return child_->size_constraints();
			}

			children_range children() const override
			{
				return {children_range_};
			}

			struct shape const & shape() const override
			{
				return child_->shape();
			}

			void reshape(geom::box<float, 2> const & box) override
			{
				child_->reshape(box);
			}

			void draw(painter &) const override
			{}

			~spinbox_impl()
			{
				release_children();
			}

		private:
			std::shared_ptr<element> child_;
			element * children_range_[1] {nullptr};
		};

	}

	struct default_element_factory::impl
	{
		std::shared_ptr<gfx::texture_2d> cross_red_16x16;

		impl();
	};

	default_element_factory::impl::impl()
	{
		cross_red_16x16 = std::make_shared<gfx::texture_2d>(gfx::texture_2d::from_pixmap(gfx::read_png(io::memory_istream{resources::cross_red_16x16_png})));
		cross_red_16x16->nearest_filter();
	}

	default_element_factory::default_element_factory()
		: pimpl_{make_impl()}
	{}

	default_element_factory::~default_element_factory() = default;

	std::shared_ptr<rich_button> default_element_factory::make_button()
	{
		return std::make_shared<button_impl>();
	}

	std::shared_ptr<frame> default_element_factory::make_frame()
	{
		return std::make_shared<frame_impl>();
	}

	std::shared_ptr<window> default_element_factory::make_window(std::string caption)
	{
		auto r = std::make_shared<window_impl>(impl().cross_red_16x16);
		r->setup_close();
		r->set_caption(std::move(caption));
		return r;
	}

	std::shared_ptr<spinbox> default_element_factory::make_spinbox()
	{
		return std::make_shared<spinbox_impl>();
	}

	std::shared_ptr<checkbox> default_element_factory::make_checkbox(bool value)
	{
		auto c = std::make_shared<checkbox_impl>();
		c->set_value(value);
		return c;
	}

	std::shared_ptr<slider> default_element_factory::make_slider()
	{
		return std::make_shared<slider_impl>();
	}

	std::shared_ptr<button> default_element_factory::make_arrow_button(int direction)
	{
		return std::make_shared<arrow_button_impl>(direction);
	}

}