#pragma once

#include <optional>
#include <print>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>

class ArgParser {
public:
  void add(const std::string& shortOpt, const std::string& longOpt, const std::string& description, bool requiresValue = true) {
    Argument arg{shortOpt, longOpt, description, std::nullopt, requiresValue, false};
    m_arguments.push_back(arg);
    if (!shortOpt.empty())
      m_optMap[shortOpt] = &m_arguments.back();
    if (!longOpt.empty())
      m_optMap[longOpt] = &m_arguments.back();
  }

  bool parse(int argc, char* argv[]) {
    if (argc == 1) {
      printHelp();
      return false;
    }

    for (int i = 1; i < argc; ++i) {
      std::string arg = argv[i];

      if (arg == "-h" || arg == "--help") {
        printHelp();
        return false;
      }

      if (auto* argument = findArgument(arg); argument) {
        argument->exists = true;
        if (argument->requiresValue) {
          if (i + 1 >= argc)
            throw std::invalid_argument("Missing value for " + arg);
          argument->value = argv[++i];
        }
      } else {
        throw std::invalid_argument("Unknown option: " + arg);
      }
    }
    return true;
  }

  template <typename T>
  T get(const std::string& arg) const {
    const Argument* argument = findArgument(arg);
    if (!argument || !argument->value)
      throw std::runtime_error(arg + " has no value");

    return convertToType<T>(*argument->value);
  }

  bool has(const std::string& arg) const {
    const Argument* argument = findArgument(arg);
    return argument && argument->exists;
  }

  void printHelp() const {
    std::println("Usage: [options]");
    for (const auto& arg : m_arguments) {
      std::println("   {}, {}: {}", arg.shortOpt, arg.longOpt, arg.description);
    }
  }

private:
  struct Argument {
    std::string                shortOpt;
    std::string                longOpt;
    std::string                description;
    std::optional<std::string> value;
    bool                       requiresValue;
    bool                       exists = false;
  };

  Argument* findArgument(const std::string& opt) {
    if (auto it = m_optMap.find(opt); it != m_optMap.end())
      return it->second;
    return nullptr;
  }

  const Argument* findArgument(const std::string& opt) const {
    if (auto it = m_optMap.find(opt); it != m_optMap.end())
      return it->second;
    return nullptr;
  }

  template <typename T>
  T convertToType(const std::string& value) const {
    if constexpr (std::is_same_v<T, std::string>) {
      return value;
    } else if constexpr (std::is_same_v<T, int>) {
      return std::stoi(value);
    } else if constexpr (std::is_same_v<T, double>) {
      return std::stod(value);
    } else {
      throw std::runtime_error("Unsupported type for argument conversion");
    }
  }

  std::vector<Argument>                      m_arguments;
  std::unordered_map<std::string, Argument*> m_optMap;
};