#include <luma/window.hpp>

#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <expected>
#include <functional>
#include <string>
#include <utility>
#include <vector>

#include <modulus.hpp>
#include <modulus/log.hpp>

#include <luma/detail/errors.hpp>
#include <luma/geometry.hpp>
#include <luma/input.hpp>
#include <luma/render.hpp>
#include <luma/theme.hpp>


namespace {

class scope_exit {
public:
  explicit scope_exit(std::function<void()> action);
  scope_exit(scope_exit const &) = delete;
  auto operator=(scope_exit const &) -> scope_exit & = delete;
  ~scope_exit();
private:
  std::function<void()> action_{};
};

constexpr auto window_title_vertical_padding = std::float32_t{6.0F};

auto finite_rect(luma::rect value) -> std::bool_t {
  return std::isfinite(value.x) && std::isfinite(value.y) && std::isfinite(value.width) && std::isfinite(value.height) && value.width >= 0.0F && value.height >= 0.0F;
}

auto title_height(luma::window_options const &options, std::float32_t line_height) -> std::float32_t {
  if (!options.decorated) {
    return {};
  }
  auto desired = line_height + window_title_vertical_padding * 2.0F;
  return std::min(desired, options.bounds.height);
}

auto title_bounds(luma::window_options const &options, std::float32_t line_height) -> luma::rect {
  return {
    .x = options.bounds.x,
    .y = options.bounds.y,
    .width = options.bounds.width,
    .height = title_height(options, line_height),
  };
}

auto client_bounds(luma::window_options const &options, std::float32_t line_height) -> luma::rect {
  if (!options.decorated) {
    return options.bounds;
  }
  auto title = title_bounds(options, line_height);
  return {
    .x = options.bounds.x,
    .y = options.bounds.y + title.height,
    .width = options.bounds.width,
    .height = std::max(std::float32_t{}, options.bounds.height - title.height),
  };
}

template <typename VALUE>
auto invalid(std::string message) -> std::expected<VALUE, modulus::error> {
  return luma::detail::fail<VALUE>(luma::detail::error_invalid_argument, std::move(message));
}

template <typename VALUE>
auto unavailable(std::string message) -> std::expected<VALUE, modulus::error> {
  return luma::detail::fail<VALUE>(luma::detail::error_unavailable, std::move(message));
}

auto make_event(luma::touch_event const &event, luma::touch_point point) -> luma::touch_event {
  return {
    .points = {point},
    .time = event.time,
  };
}

scope_exit::scope_exit(std::function<void()> action)
    : action_{std::move(action)} {}

scope_exit::~scope_exit() {
  if (action_) {
    action_();
  }
}

}

luma::window::window(std::uint64_t id, luma::window_options options, std::unique_ptr<luma::control> content)
    : id_{id}, options_{std::move(options)}, content_{std::move(content)} {
  assert(id_ != 0);
  assert(finite_rect(options_.bounds));
  assert(content_ != nullptr);
}

auto luma::window::id() const -> std::uint64_t {
  assert(id_ != 0);
  return id_;
}

auto luma::window::options() const -> luma::window_options const & {
  assert(finite_rect(options_.bounds));
  return options_;
}

auto luma::window::set_bounds(luma::rect bounds) -> std::expected<void, modulus::error> {
  if (!finite_rect(bounds)) {
    return invalid<void>("window bounds must be finite and non-negative");
  }
  options_.bounds = bounds;
  return {};
}

auto luma::window::set_visible(std::bool_t value) -> void {
  options_.visible = value;
}

auto luma::window::visible() const -> std::bool_t {
  return options_.visible;
}

auto luma::window::content() -> luma::control * {
  assert(content_ != nullptr);
  return content_.get();
}

auto luma::window::content() const -> luma::control const * {
  assert(content_ != nullptr);
  return content_.get();
}

auto luma::window_manager::open(luma::window_options options, std::unique_ptr<luma::control> content) -> std::expected<std::uint64_t, modulus::error> {
  if (next_id_ == 0) {
    return unavailable<std::uint64_t>("window id space exhausted");
  }
  if (!finite_rect(options.bounds)) {
    return invalid<std::uint64_t>("window bounds must be finite and non-negative");
  }
  if (content == nullptr) {
    return invalid<std::uint64_t>("window content must not be null");
  }
  content->bind_layout_invalidator(layout_invalidator());
  auto id = next_id_++;
  auto created = std::unique_ptr<luma::window>{
    new luma::window{
      id,
      std::move(options),
      std::move(content),
    },
  };
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::OPEN,
      .id = id,
      .window = std::move(created),
    });
  } else {
    windows_.push_back(std::move(created));
  }
  modulus::log_debug("luma window opened: " + std::to_string(id));
  return modulus::success(id);
}

auto luma::window_manager::close(std::uint64_t id) -> std::expected<void, modulus::error> {
  if (id == 0) {
    return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
  }
  if (!contains_effective(id)) {
    return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
  }
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::CLOSE,
      .id = id,
    });
  } else {
    close_now(id);
  }
  modulus::log_debug("luma window close requested: " + std::to_string(id));
  return {};
}

auto luma::window_manager::bring_to_front(std::uint64_t id) -> std::expected<void, modulus::error> {
  if (id == 0) {
    return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
  }
  if (!contains_effective(id)) {
    return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
  }
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::BRING_TO_FRONT,
      .id = id,
    });
  } else {
    bring_to_front_now(id);
  }
  return {};
}

auto luma::window_manager::set_bounds(std::uint64_t id, luma::rect bounds) -> std::expected<void, modulus::error> {
  if (id == 0) {
    return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
  }
  if (!finite_rect(bounds)) {
    return invalid<void>("window bounds must be finite and non-negative");
  }
  if (!contains_effective(id)) {
    return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
  }
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::SET_BOUNDS,
      .id = id,
      .bounds = bounds,
    });
  } else {
    set_bounds_now(id, bounds);
  }
  return {};
}

auto luma::window_manager::set_visible(std::uint64_t id, std::bool_t visible) -> std::expected<void, modulus::error> {
  if (id == 0) {
    return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
  }
  if (!contains_effective(id)) {
    return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
  }
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::SET_VISIBLE,
      .id = id,
      .visible = visible,
    });
  } else {
    set_visible_now(id, visible);
  }
  return {};
}

auto luma::window_manager::find(std::uint64_t id) -> luma::window * {
  if (id == 0) {
    return nullptr;
  }
  auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
  return found == windows_.end() ? nullptr : found->get();
}

auto luma::window_manager::clear() -> void {
  if (mutation_depth_ > 0) {
    pending_operations_.push_back({
      .kind = luma::window_manager::pending_kind::CLEAR,
    });
    return;
  }
  windows_.clear();
  active_touches_.clear();
}

auto luma::window_manager::measure(luma::draw_context &context, luma::theme const &theme, luma::constraints limits) -> luma::size {
  title_line_height_ = theme.body.line_height;
  ++mutation_depth_;
  auto guard = scope_exit{[this] {
    assert(mutation_depth_ > 0);
    --mutation_depth_;
    apply_pending_operations();
  }};
  for (auto &window : windows_) {
    assert(window != nullptr);
    if (!window->visible()) {
      continue;
    }
    assert(window->content() != nullptr);
    auto client = client_bounds(window->options(), title_line_height_);
    window->content()->measure(context, theme, {
                                                 .min = {},
                                                 .max = {
                                                   .width = client.width,
                                                   .height = client.height,
                                                 },
                                               });
  }
  return luma::clamp(limits.max, limits);
}

auto luma::window_manager::arrange(luma::rect bounds) -> void {
  assert(finite_rect(bounds));
  ++mutation_depth_;
  auto guard = scope_exit{[this] {
    assert(mutation_depth_ > 0);
    --mutation_depth_;
    apply_pending_operations();
  }};
  luma::control::arrange(bounds);
  for (auto &window : windows_) {
    assert(window != nullptr);
    if (window->visible()) {
      assert(window->content() != nullptr);
      window->content()->arrange(client_bounds(window->options(), title_line_height_));
    }
  }
}

auto luma::window_manager::draw(luma::draw_context &context, luma::theme const &theme) const -> void {
  title_line_height_ = theme.body.line_height;
  ++mutation_depth_;
  auto guard = scope_exit{[this] {
    assert(mutation_depth_ > 0);
    --mutation_depth_;
    apply_pending_operations();
  }};
  for (auto const &window : windows_) {
    assert(window != nullptr);
    if (!window->visible()) {
      continue;
    }
    auto bounds = window->options().bounds;
    auto client = client_bounds(window->options(), title_line_height_);
    context.fill_rect(bounds, theme.surface);
    assert(window->content() != nullptr);
    context.push_clip(client);
    window->content()->draw(context, theme);
    context.pop_clip();
    if (window->options().decorated) {
      auto title = title_bounds(window->options(), title_line_height_);
      context.fill_rect(title, theme.surface_active);
      context.draw_text(window->options().title, {
                                                   .x = title.x + 8.0F,
                                                   .y = title.y + window_title_vertical_padding,
                                                 },
                        theme.body, theme.text);
    }
    context.stroke_rect(bounds, 1.0F, theme.border);
  }
}

auto luma::window_manager::handle_touch(luma::touch_event const &event) -> std::bool_t {
  if (event.points.empty()) {
    return false;
  }
  ++mutation_depth_;
  auto guard = scope_exit{[this] {
    assert(mutation_depth_ > 0);
    --mutation_depth_;
    apply_pending_operations();
  }};
  auto handled = false;
  for (auto const &point : event.points) {
    if (auto captured = active_touches_.find(point.id); captured != active_touches_.end()) {
      auto const window_id = captured->second;
      auto *captured_window = find(window_id);
      auto const captured_visible = captured_window != nullptr && captured_window->visible();
      if (captured_visible) {
        assert(captured_window->content() != nullptr);
        auto single = make_event(event, point);
        static_cast<void>(captured_window->content()->handle_touch(single));
        handled = true;
      }
      if (point.phase == luma::touch_phase::UP || point.phase == luma::touch_phase::CANCEL || !captured_visible) {
        active_touches_.erase(point.id);
      }
      continue;
    }
    for (auto current = windows_.rbegin(); current != windows_.rend(); ++current) {
      assert(*current != nullptr);
      if (!(*current)->visible()) {
        continue;
      }
      if (luma::contains((*current)->options().bounds, point.position)) {
        auto consumed = false;
        if (luma::contains(client_bounds((*current)->options(), title_line_height_), point.position)) {
          assert((*current)->content() != nullptr);
          auto single = make_event(event, point);
          consumed = (*current)->content()->handle_touch(single);
          if (point.phase == luma::touch_phase::DOWN && (consumed || (*current)->options().modal)) {
            active_touches_[point.id] = (*current)->id();
          }
        }
        handled = true;
        break;
      }
      if ((*current)->options().modal) {
        handled = true;
        break;
      }
    }
  }
  return handled;
}

auto luma::window_manager::contains_effective(std::uint64_t id) const -> std::bool_t {
  if (id == 0) {
    return false;
  }
  auto exists = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; }) != windows_.end();
  for (auto const &operation : pending_operations_) {
    switch (operation.kind) {
    case luma::window_manager::pending_kind::OPEN:
      if (operation.id == id) {
        exists = true;
      }
      break;
    case luma::window_manager::pending_kind::CLOSE:
      if (operation.id == id) {
        exists = false;
      }
      break;
    case luma::window_manager::pending_kind::BRING_TO_FRONT:
    case luma::window_manager::pending_kind::SET_BOUNDS:
    case luma::window_manager::pending_kind::SET_VISIBLE:
      break;
    case luma::window_manager::pending_kind::CLEAR:
      exists = false;
      break;
    }
  }
  return exists;
}

auto luma::window_manager::close_now(std::uint64_t id) const -> void {
  auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
  if (found == windows_.end()) {
    return;
  }
  auto const closed_id = (*found)->id();
  for (auto current = active_touches_.begin(); current != active_touches_.end();) {
    if (current->second == closed_id) {
      current = active_touches_.erase(current);
    } else {
      ++current;
    }
  }
  windows_.erase(found);
}

auto luma::window_manager::bring_to_front_now(std::uint64_t id) const -> void {
  auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
  if (found == windows_.end()) {
    return;
  }
  auto moved = std::move(*found);
  windows_.erase(found);
  windows_.push_back(std::move(moved));
}

auto luma::window_manager::set_bounds_now(std::uint64_t id, luma::rect bounds) const -> void {
  auto *window = const_cast<luma::window_manager *>(this)->find(id);
  if (window != nullptr) {
    static_cast<void>(window->set_bounds(bounds));
  }
}

auto luma::window_manager::set_visible_now(std::uint64_t id, std::bool_t visible) const -> void {
  auto *window = const_cast<luma::window_manager *>(this)->find(id);
  if (window != nullptr) {
    window->set_visible(visible);
  }
}

auto luma::window_manager::apply_pending_operations() const -> void {
  if (mutation_depth_ != 0 || pending_operations_.empty()) {
    return;
  }
  auto pending = std::vector<luma::window_manager::pending_operation>{};
  pending.swap(pending_operations_);
  for (auto &operation : pending) {
    switch (operation.kind) {
    case luma::window_manager::pending_kind::OPEN:
      if (operation.window) {
        windows_.push_back(std::move(operation.window));
      }
      break;
    case luma::window_manager::pending_kind::CLOSE:
      close_now(operation.id);
      break;
    case luma::window_manager::pending_kind::BRING_TO_FRONT:
      bring_to_front_now(operation.id);
      break;
    case luma::window_manager::pending_kind::SET_BOUNDS:
      set_bounds_now(operation.id, operation.bounds);
      break;
    case luma::window_manager::pending_kind::SET_VISIBLE:
      set_visible_now(operation.id, operation.visible);
      break;
    case luma::window_manager::pending_kind::CLEAR:
      windows_.clear();
      active_touches_.clear();
      break;
    }
  }
}

auto luma::window_manager::invalidate_layout() -> void {
  ++mutation_depth_;
  auto guard = scope_exit{[this] {
    assert(mutation_depth_ > 0);
    --mutation_depth_;
    apply_pending_operations();
  }};
  auto controls = std::vector<luma::control *>{};
  controls.reserve(windows_.size() + pending_operations_.size());
  for (auto &window : windows_) {
    assert(window != nullptr);
    assert(window->content() != nullptr);
    controls.push_back(window->content());
  }
  for (auto &operation : pending_operations_) {
    if (operation.window) {
      assert(operation.window->content() != nullptr);
      controls.push_back(operation.window->content());
    }
  }
  for (auto *control : controls) {
    assert(control != nullptr);
    control->invalidate_layout();
  }
}

auto luma::window_manager::bind_layout_invalidator(std::function<void()> invalidator) -> void {
  luma::control::bind_layout_invalidator(invalidator);
  for (auto &window : windows_) {
    assert(window != nullptr);
    assert(window->content() != nullptr);
    window->content()->bind_layout_invalidator(invalidator);
  }
  for (auto &operation : pending_operations_) {
    if (operation.window) {
      assert(operation.window->content() != nullptr);
      operation.window->content()->bind_layout_invalidator(invalidator);
    }
  }
}