#pragma once

#include <iostream>
#include <utility>

#include "arguments.h"
#include "exception.h"
#include "utilities.h"

#ifndef PROGRAM_ARGS_NOEXIT_ON_HELP
#define PROGRAM_ARGS_EXIT(X) std::exit(X)
#else
#define PROGRAM_ARGS_EXIT(X) (void)X
#endif

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Action::operator T() const {
  static_assert(std::is_base_of_v<Arguments<T>, T>,
                "Action can only bind to Arguments");
  if (!primed()) {
    self->actions.emplace(name, [](int argc, char const * const * argv) {
      return [=](Impl const & args) {
        return std::make_shared<T>(T(argc, argv, &args));
      };
    });
  } else if (auto ptr = self->make_action<T>(name)) {
    return *ptr;
  }
  return T();
}

template <typename Impl> Arguments<Impl>::Action::operator bool() const {
  return primed() && self->arguments.size() > 0;
}

template <typename Impl> bool Arguments<Impl>::Action::primed() const {
  if (self->primed_) { return true; }
  if (self->has_arguments()) { throw ArgumentMixingError(); }
  self->action_descriptions.emplace(name, description);
  return false;
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Argument::operator T() const {
  if (!primed()) {
    return T();
  } else if (self->arguments.size() > index) {
    return convert<T>(name, self->arguments.at(index));
  }
  throw IllegalPositionError("No argument provided", index);
}

template <typename Impl> Arguments<Impl>::Argument::operator bool() const {
  return primed() && self->arguments.size() > index;
}

template <typename Impl>
template <typename T>
auto Arguments<Impl>::Argument::operator=(T && value) {
  is_optional = true;
  if (description.size()) {
    using ::program::to_string;
    description += "\n    Default Value: " + to_string(value);
  }
  return WithDefault<Argument, T>{*this, std::forward<T>(value)};
}

template <typename Impl> bool Arguments<Impl>::Argument::primed() const {
  if (self->primed_) { return true; }
  if (self->has_actions()) { throw ArgumentMixingError(); }
  if (is_optional) {
    self->optional_from = std::min(self->optional_from, index);
  } else if (self->optional_from < index) {
    throw ArgumentStructureError{"Required positional after optional", name};
  }
  if (!self->argument_names.emplace(index, name).second) {
    throw IllegalPositionError("Duplicate positional", index);
  }
  self->argument_descriptions.emplace(name, description);
  return false;
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Flag::operator T() const {
  return primed(false) ? static_cast<T>(self->flags.at(name)) : T();
}

template <typename Impl> Arguments<Impl>::Flag::operator bool() const {
  return primed(true) ? static_cast<bool>(self->flags.at(name)) : default_value;
}

template <typename Impl> auto Arguments<Impl>::Flag::operator=(bool && value) {
  if (description.size()) {
    description += "\n    Default Value: ";
    description += (value ? "true" : "false");
  }
  default_value = value;
  return *this;
}

template <typename Impl> bool Arguments<Impl>::Flag::primed(bool inv) const {
  if (self->primed_) { return self->flags.count(name); }
  std::vector<std::string> aliases;
  if (name.size() > 1 && inv) { aliases.push_back("no-" + name); }
  self->add_options(name, abbrev, description, aliases);
  self->flag_names.emplace(name);
  return false;
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Option::operator T() const {
  return (*this) ? convert<T>(name, self->options.at(name)) : T();
}

template <typename Impl> Arguments<Impl>::Option::operator bool() const {
  return primed() && self->options.count(name);
}

template <typename Impl>
template <typename T>
auto Arguments<Impl>::Option::operator=(T && value) {
  if (description.size()) {
    using ::program::to_string;
    description += "\n    Default Value: " + to_string(value);
  }
  return WithDefault<Option, T>{*this, std::forward<T>(value)};
}

template <typename Impl>
template <typename T>
auto Arguments<Impl>::Option::operator=(std::initializer_list<T> value) {
  if (description.size()) {
    using ::program::to_string;
    description += "\n    Default Value: " + to_string(value);
  }
  return WithDefault<Option, std::initializer_list<T>>{*this, value};
}

template <typename Impl> bool Arguments<Impl>::Option::primed() const {
  if (self->primed_) { return true; }
  self->add_options(name, abbrev, description);
  return false;
}

}

namespace program {
template <typename Impl>
template <typename T>
auto Arguments<Impl>::Rest::operator=(T && value) {
  return WithDefault<Rest, T>{*this, std::forward<T>(value)};
}

template <typename Impl>
Arguments<Impl>::Rest::operator std::vector<std::string>() const {
  return self->args();
}

template <typename Impl> Arguments<Impl>::Rest::operator bool() const {
  return self->arguments.size() > self->argument_names.size();
}
}

namespace program {

template <typename Impl>
template <typename B, typename V>
template <typename T>
Arguments<Impl>::WithDefault<B, V>::operator T() const {
  if (impl) { return impl; }
  if constexpr (std::is_invocable_r<T, V>{}) {
    return T{default_value()};
  } else {
    return T{default_value};
  }
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Arguments(int argc, char const * const * const argv,
                           T const * parent) {
  Impl generator(parent);
  *this = static_cast<Arguments const &>(generator);
  if (argument_names.size() &&
      argument_names.rbegin()->first != argument_names.size() - 1) {
    throw IllegalPositionError("Higher positional than number recorded",
                               argument_names.rbegin()->first);
  }

  primed_ = true;
  program = argv[0];
  for (size_t i = 1; i < argc; ++i) {
    std::string arg = argv[i];
    char const * const next = argv[i + 1];
    char abbrev = arg[1];
    if (arg == "--help") {
      usage();
      PROGRAM_ARGS_EXIT(0);
    } else if (arg == "--") {
      arguments.insert(arguments.end(), &next, &argv[argc]);
      break;
    } else if (auto hook = actions[arg]) {
      action_name_ = arg;
      make_action_ = hook(argc - i, argv + i);
      return;
    } else if (arg == "help" && next && actions[next]) {
      char const * const help[] = {next, "--help"};
      action_name_ = next;
      make_action_ = hook(2, help);
      return;
    } else if (arg[0] != '-') {
      arguments.emplace_back(arg);
    } else if (is_flag(arg)) {
      if (arg.substr(0, 5) == "--no-") {
        flags[id(arg)] = 0;
      } else {
        ++flags[id(arg)];
      }
    } else if (is_option(arg)) {
      options[id(arg)].emplace_back(argv[++i]);
    } else if (is_flag(abbrev) && arg.find_last_not_of("0123456789") == 1) {
      flags[id(abbrev)] = std::stoi(arg.substr(2));
    } else if (is_flag(abbrev)) {
      for (auto c : arg.substr(1)) {
        if (!is_flag(c)) { throw NotAnArgumentError({'-', c}); }
        ++flags[id(c)];
      }
    } else if (is_option(abbrev)) {
      options[id(abbrev)].emplace_back(arg.substr(2));
    } else {
      throw NotAnArgumentError(arg);
    }
  }
}

template <typename Impl> void Arguments<Impl>::usage() const {
  std::cout << program << " [options...]";
  for (auto & [index, name] : argument_names) {
    std::cout << " " << (index == optional_from ? "[" : "") << name;
  }
  if (rest_name.size()) { std::cout << " [" << rest_name << "...]"; }
  if (optional_from != no_optional_args) { std::cout << "]"; }
  std::cout << "\nArgument Arguments:\n";
  for (auto & [name, desc] : argument_descriptions) {
    std::cout << "  " << name << ": " << desc << "\n";
  }
  std::cout << "Options:\n";
  for (auto & [opt, desc] : option_descriptions) {
    std::cout << "  " << opt << ": " << desc << "\n";
  }
}

template <typename Impl>
void Arguments<Impl>::add_options(std::string const & name, char abbrev,
                                  std::string const & description,
                                  std::vector<std::string> aliases) {
  for (auto & str : aliases) {
    str = "--" + str;
  }
  if (name.size() > 1) { aliases.push_back("--" + name); }
  if (abbrev) { aliases.push_back(std::string{'-', abbrev}); }
  for (auto & str : aliases) {
    if (!option_names.emplace(str, name).second) {
      throw ArgumentStructureError("Duplicate option string", str);
    }
  }
  option_descriptions.emplace(join(",", aliases), description);
}

template <typename Impl>
auto Arguments<Impl>::id(std::string const & arg) const -> option_id {
  if (!is_option(arg)) { throw NotAnArgumentError(arg); }
  return option_names.at(arg);
}

template <typename Impl>
bool Arguments<Impl>::is_option(std::string const & arg) const {
  return option_names.count(arg);
}

template <typename Impl>
bool Arguments<Impl>::is_flag(std::string const & arg) const {
  return is_option(arg) && flag_names.count(id(arg));
}

template <typename Impl>
auto Arguments<Impl>::action(LongArg name, std::string const & description) {
  return Action{this, name, description};
}

template <typename Impl>
auto Arguments<Impl>::argument(size_t index, LongArg name,
                               std::string const & description) {
  return Argument{this, index, false, name, description};
}

template <typename Impl>
auto Arguments<Impl>::rest(LongArg name, std::string const & description) {
  if (has_actions()) { throw ArgumentMixingError(); }
  if (!rest_name.empty() && rest_name != name.str) {
    throw ArgumentStructureError("duplicate rest() parameter", name);
  }
  rest_name = name;
  argument_descriptions.emplace(name, description);
  return Rest{this};
}

template <typename Impl>
auto Arguments<Impl>::flag(LongArg name, std::string const & description) {
  return Flag{this, name, 0, description, false};
}

template <typename Impl>
auto Arguments<Impl>::flag(LongArg name, char abbrev,
                           std::string const & description) {
  return Flag{this, name, abbrev, description, false};
}

template <typename Impl>
auto Arguments<Impl>::flag(char abbrev, std::string const & description) {
  return Flag{this, {abbrev}, abbrev, description, false};
}

template <typename Impl>
auto Arguments<Impl>::option(LongArg name, std::string const & description) {
  return Option{this, name, 0, description};
}

template <typename Impl>
auto Arguments<Impl>::option(LongArg name, char abbrev,
                             std::string const & description) {
  return Option{this, name, abbrev, description};
}

template <typename Impl>
auto Arguments<Impl>::option(char abbrev, std::string const & description) {
  return Option{this, {abbrev}, abbrev, description};
}

template <typename Impl>
template <typename DA, typename T, size_t... Is, typename... Ps>
int Arguments<Impl>::invoke_action(DA const & default_action, T const & tuple,
                                   std::index_sequence<Is...>,
                                   Ps const &... ps) const {
  // Only actions that were reached in the constructor will ever have the
  // primed_ flag set to true. Therefore, there is a guarantee that this
  // function will only call invoke() on a child one or zero times.
  auto invoke_one = [this, &ps...](auto const & action) {
    if (!action.primed_) { return std::make_pair(false, 0); }
    return std::make_pair(true, action.invoke(ps..., self()));
  };

  // Because of that, it is safe to use a map from bool => status
  // Since we only care about the case where an action was invoked.
  std::map<bool, int> const rval{invoke_one(std::get<Is>(tuple))...};
  if (rval.count(true)) { return rval.at(true); }

  // If no action was invoked, then we need to handle the fallthrough case
  // For certain circumstances, such as how git allows custom actions with
  // a plugin system, we allow you to specify a default action of self.
  if constexpr (std::is_same_v<DA, require_action_t>) {
    usage();
    return 1;
  } else if constexpr (std::is_same_v<DA, Impl>) {
    return typed_main(ps..., self());
  } else {
    return default_action.invoke(ps..., self());
  }
}

}

namespace program {
template <typename... Ts> auto actions(Ts const &... ts) {
  return std::forward_as_tuple(ts...);
}

template <typename... Ts> auto count(Ts const &...) {
  return std::make_index_sequence<sizeof...(Ts)>{};
}
}