#include <array>
#include <cerrno>
#include <cstring>
#include <fstream>
#include <getopt.h>
#include <iostream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include "typefactory.h"

// ------------------------------------------------------------
// Helpers
// ------------------------------------------------------------

static std::string rstrip_cr (std::string s) {
  if (!s.empty() && s.back() == '\r')
    s.pop_back();
  return s;
}

static std::string latex_escape (const std::string &s) {
  std::string out;
  out.reserve (s.size() + s.size() / 8);
  for (unsigned char ch : s) {
    switch (ch) {
      case '\\':
        out += "\\textbackslash{}";
        break;
      case '{':
        out += "\\{";
        break;
      case '}':
        out += "\\}";
        break;
      case '%':
        out += "\\%";
        break;
      case '$':
        out += "\\$";
        break;
      case '#':
        out += "\\#";
        break;
      case '&':
        out += "\\&";
        break;
      case '_':
        out += "\\_";
        break;
      case '^':
        out += "\\textasciicircum{}";
        break;
      case '~':
        out += "\\textasciitilde{}";
        break;
      default:
        out.push_back (static_cast<char> (ch));
        break;
    }
  }
  return out;
}

// ------------------------------------------------------------
// Data model
// ------------------------------------------------------------

struct Quote {
  std::string meta;
  std::vector<std::string> text_lines;
};

struct ParseContext {
  std::vector<std::string> order;
  std::unordered_map<std::string, std::vector<Quote>> by_title;
  std::unordered_map<std::string, std::size_t> seen;

  std::string cur_title;
  std::string cur_meta;
  std::vector<std::string> cur_text;

  void start_title (std::string t) {
    cur_title = std::move (t);
    cur_meta.clear();
    cur_text.clear();
  }

  void set_meta (std::string m) {
    cur_meta = std::move (m);
  }
  void add_text (std::string line) {
    cur_text.push_back (std::move (line));
  }

  void finalize_quote() {
    // Ignore incomplete entries
    if (cur_title.empty() || cur_meta.empty()) {
      cur_meta.clear();
      cur_text.clear();
      return;
    }

    // Preserve insertion order of sections
    if (seen.find (cur_title) == seen.end()) {
      seen.emplace (cur_title, order.size());
      order.push_back (cur_title);
    }

    by_title[cur_title].push_back (Quote{cur_meta, cur_text});

    cur_meta.clear();
    cur_text.clear();
  }
};

// ------------------------------------------------------------
// Parsing stages
// ------------------------------------------------------------

enum class Stage { Title, Meta, Body };

// Explicit list of all supported stages for runtime validation
static constexpr std::array<Stage, 3> kAllStages = {
  Stage::Title, Stage::Meta, Stage::Body
};

struct ILineHandler {
  virtual ~ILineHandler() = default;

  // Process a single line and decide the next stage
  virtual void handle (const std::string &line,
                       ParseContext &ctx,
                       Stage &next) = 0;
};

struct TitleHandler final : ILineHandler {
  void handle (const std::string &line,
               ParseContext &ctx,
               Stage &next) override {

    // Skip empty lines between entries
    if (line.empty()) {
      next = Stage::Title;
      return;
    }

    ctx.start_title (line);
    next = Stage::Meta;
  }
};

struct MetaHandler final : ILineHandler {
  void handle (const std::string &line,
               ParseContext &ctx,
               Stage &next) override {

    ctx.set_meta (line);
    next = Stage::Body;
  }
};

struct BodyHandler final : ILineHandler {
  void handle (const std::string &line,
               ParseContext &ctx,
               Stage &next) override {

    // Separator marks the end of a clipping block
    if (line == "==========") {
      ctx.finalize_quote();
      next = Stage::Title;
      return;
    }

    // Keep body lines as-is (including empty ones)
    ctx.add_text (line);
    next = Stage::Body;
  }
};

// ------------------------------------------------------------
// Factory wiring + handler caching
// ------------------------------------------------------------

using HandlerPtr = std::shared_ptr<ILineHandler>;
using HandlerMap = std::unordered_map<Stage, HandlerPtr>;

static TypeFactory<Stage, ILineHandler> build_factory() {
  TypeFactory<Stage, ILineHandler> f;

  f.registerType<TitleHandler> (Stage::Title);
  f.registerType<MetaHandler> (Stage::Meta);
  f.registerType<BodyHandler> (Stage::Body);

  return f;
}

static HandlerMap build_handlers_cache (
  const TypeFactory<Stage, ILineHandler> &factory) {

  HandlerMap handlers;
  handlers.reserve (kAllStages.size());

  // Runtime validation: ensure each stage has a registered handler
  for (Stage st : kAllStages) {
    try {
      auto h = factory.create (st);
      if (!h)
        throw std::runtime_error ("Factory returned null handler");
      handlers.emplace (st, std::move (h));
    } catch (const std::out_of_range &) {
      throw std::runtime_error ("Missing handler registration for Stage");
    }
  }

  // Extra consistency check
  if (handlers.size() != kAllStages.size())
    throw std::runtime_error ("Handler cache size mismatch");

  return handlers;
}

// ------------------------------------------------------------
// CLI handling
// ------------------------------------------------------------

struct CliArgs {
  std::string input;
  std::string output;
};

static void print_usage (const char *argv0) {
  std::cerr << "Usage: " << argv0
            << " --input <file> --output <file>\n";
}

static bool parse_args (int argc,
                        char **argv,
                        CliArgs &out) {

  static option long_opts[] = {
    {"input",  required_argument, nullptr, 'i'},
    {"output", required_argument, nullptr, 'o'},
    {"help",   no_argument,       nullptr, 'h'},
    {nullptr,  0,                 nullptr,  0 }
  };

  int c = 0;
  while ((c = ::getopt_long (argc, argv,
                             "i:o:h",
                             long_opts,
                             nullptr)) != -1) {
    switch (c) {
      case 'i':
        out.input = optarg;
        break;
      case 'o':
        out.output = optarg;
        break;
      case 'h':
        print_usage (argv[0]);
        return false;
      default:
        print_usage (argv[0]);
        return false;
    }
  }

  if (out.input.empty() || out.output.empty()) {
    print_usage (argv[0]);
    return false;
  }

  return true;
}

// ------------------------------------------------------------
// Conversion logic
// ------------------------------------------------------------

static int convert (const std::string &in_path,
                    const std::string &out_path) {

  std::ifstream in (in_path);
  if (!in.is_open()) {
    std::cerr << "Failed to open input file: "
              << in_path
              << " (" << std::strerror (errno) << ")\n";
    return 2;
  }

  // Build factory and cache handlers once
  TypeFactory<Stage, ILineHandler> factory = build_factory();

  HandlerMap handlers;
  try {
    handlers = build_handlers_cache (factory);
  } catch (const std::exception &e) {
    std::cerr << "Internal error while building handler cache: "
              << e.what() << "\n";
    return 4;
  }

  ParseContext ctx{};
  Stage stage = Stage::Title;

  std::string line;
  while (std::getline (in, line)) {
    line = rstrip_cr (std::move (line));

    auto it = handlers.find (stage);
    if (it == handlers.end() || !it->second) {
      std::cerr << "Internal error: missing handler at runtime\n";
      return 4;
    }

    Stage next = stage;
    it->second->handle (line, ctx, next);
    stage = next;
  }

  // Ensure the last entry is flushed if file does not end with separator
  ctx.finalize_quote();

  std::ofstream out (out_path, std::ios::trunc);
  if (!out.is_open()) {
    std::cerr << "Failed to open output file: "
              << out_path
              << " (" << std::strerror (errno) << ")\n";
    return 3;
  }

  // Generate LaTeX output
  for (std::size_t i = 0; i < ctx.order.size(); ++i) {
    const auto &title = ctx.order[i];
    out << "\\section {" << latex_escape (title) << "}\n";

    const auto it = ctx.by_title.find (title);
    if (it == ctx.by_title.end())
      continue;

    for (const auto &q : it->second) {
      out << "  \\subsection {" << latex_escape (q.meta) << "}\n";

      for (const auto &tl : q.text_lines)
        out << "    " << latex_escape (tl) << "\n";

      out << "      \\subsubsection{notes}\n\n";
    }

    if (i + 1 < ctx.order.size())
      out << "\n";
  }

  return 0;
}

int main (int argc, char **argv) {
  CliArgs args;
  if (!parse_args (argc, argv, args))
    return 1;

  return convert (args.input, args.output);
}