#include <luma/control.hpp>

#include <cassert>
#include <cmath>
#include <functional>
#include <utility>

#include <modulus.hpp>


namespace {

auto valid_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;
}

}

luma::control::~control() = default;

auto luma::control::arrange(luma::rect bounds) -> void {
  assert(valid_rect(bounds));
  bounds_ = bounds;
}

auto luma::control::handle_touch(luma::touch_event const &event) -> std::bool_t {
  static_cast<void>(event);
  return false;
}

auto luma::control::invalidate_layout() -> void {}

auto luma::control::bind_layout_invalidator(std::function<void()> invalidator) -> void {
  layout_invalidator_ = std::move(invalidator);
}

auto luma::control::focusable() const -> std::bool_t {
  return false;
}

auto luma::control::set_focused(std::bool_t value) -> void {
  assert(!value || focusable());
  focused_ = value;
}

auto luma::control::focused() const -> std::bool_t {
  return focused_;
}

auto luma::control::set_enabled(std::bool_t value) -> void {
  enabled_ = value;
  if (!enabled_) {
    focused_ = false;
  }
}

auto luma::control::enabled() const -> std::bool_t {
  return enabled_;
}

auto luma::control::bounds() const -> luma::rect {
  assert(valid_rect(bounds_));
  return bounds_;
}

auto luma::control::notify_layout_changed() const -> void {
  if (!layout_invalidator_) {
    return;
  }
  try {
    layout_invalidator_();
  } catch (...) {
  }
}

auto luma::control::layout_invalidator() const -> std::function<void()> {
  return layout_invalidator_;
}