module;

#include <optional>
#include <string>

export module ttwhy.terminal:policies;

import :events;

namespace ttwhy::terminal
{

  namespace detail
  {
    constexpr auto map_vt220_keypad(char terminator) -> std::optional<navigation_key>
    {
      switch (terminator)
      {
        case '1':
        case '7':
          return navigation_key::home;
        case '2':
          return navigation_key::insert_key;
        case '3':
          return navigation_key::delete_key;
        case '4':
        case '8':
          return navigation_key::end;
        case '5':
          return navigation_key::page_up;
        case '6':
          return navigation_key::page_down;
        default:
          return std::nullopt;
      }
    }

    constexpr auto map_vt100_cursor(char terminator) -> std::optional<navigation_key>
    {
      switch (terminator)
      {
        case 'A':
          return navigation_key::up;
        case 'B':
          return navigation_key::down;
        case 'C':
          return navigation_key::right;
        case 'D':
          return navigation_key::left;
        case 'H':
          return navigation_key::home;
        case 'F':
          return navigation_key::end;
        default:
          return std::nullopt;
      }
    }

  }  // namespace detail

  //! Policy for decoding standard ANSI/VT escape sequences.
  export struct ansi_policy
  {
    //! Resolve a VT220 keypad sequence and emit the corresponding navigation event.
    //!
    //! @param buffer The CSI parameter buffer.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_vt220_keypad(std::string & buffer, event_sink auto & sink) -> void
    {
      if (buffer.empty())
      {
        return;
      }

      if (auto key = detail::map_vt220_keypad(buffer.front()))
      {
        sink(navigation_event{*key});
      }
      buffer.clear();
    }

    //! Resolve a VT100 cursor sequence and emit the corresponding navigation event.
    //!
    //! @param terminator The CSI terminator character indicating direction or key.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_vt100_cursor(char terminator, std::string &, event_sink auto & sink) -> void
    {
      if (auto key = detail::map_vt100_cursor(terminator))
      {
        sink(navigation_event{*key});
      }
    }

    //! Resolve an SS3 single-shift sequence and emit the corresponding navigation event.
    //!
    //! @param terminator The SS3 terminator character indicating direction or key.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_ss3(char terminator, event_sink auto & sink) -> void
    {
      if (auto key = detail::map_vt100_cursor(terminator))
      {
        sink(navigation_event{*key});
      }
    }
  };

  //! Policy for decoding xterm escape sequences, including modifier parameters.
  export struct xterm_policy
  {
    //! Parse keyboard modifier parameters from a CSI parameter buffer.
    //!
    //! @param buffer The CSI parameter buffer string view.
    //! @return The parsed modifier set, or empty if none present.
    constexpr auto static parse_modifiers(std::string_view buffer) -> modifier_set
    {
      auto delimiter = buffer.find(';');
      if (delimiter == std::string_view::npos)
      {
        return {};
      }

      auto modifier_string = buffer.substr(delimiter + 1);
      auto modifier_value = 0u;

      for (auto character : modifier_string)
      {
        if (character >= '0' && character <= '9')
        {
          modifier_value = modifier_value * 10 + static_cast<unsigned int>(character - '0');
        }
      }

      if (modifier_value <= 1)
      {
        return {};
      }

      return static_cast<modifier_set>(modifier_value - 1);
    }

    //! Resolve a VT220 keypad sequence with modifiers and emit the navigation event.
    //!
    //! @param buffer The CSI parameter buffer containing key and modifier values.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_vt220_keypad(std::string & buffer, event_sink auto & sink) -> void
    {
      if (buffer.empty())
      {
        return;
      }

      auto modifiers = parse_modifiers(buffer);

      if (auto key = detail::map_vt220_keypad(buffer.front()))
      {
        sink(navigation_event{*key, modifiers});
      }
      buffer.clear();
    }

    //! Resolve a VT100 cursor sequence with modifiers and emit the navigation event.
    //!
    //! @param terminator The CSI terminator character indicating direction or key.
    //! @param buffer The CSI parameter buffer containing modifier values.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_vt100_cursor(char terminator, std::string & buffer, event_sink auto & sink) -> void
    {
      auto modifiers = parse_modifiers(buffer);

      if (auto key = detail::map_vt100_cursor(terminator))
      {
        sink(navigation_event{*key, modifiers});
      }
    }

    //! Resolve an SS3 single-shift sequence and emit the corresponding navigation event.
    //!
    //! @param terminator The SS3 terminator character indicating direction or key.
    //! @param sink The event sink to receive the resolved navigation event.
    constexpr auto static resolve_ss3(char terminator, event_sink auto & sink) -> void
    {
      if (auto key = detail::map_vt100_cursor(terminator))
      {
        sink(navigation_event{*key});
      }
    }
  };

}  // namespace ttwhy::terminal