#include "converter.h"

#include <array>
#include <cerrno>
#include <cstring>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <unordered_map>
#include <utility>
#include <vector>

#include "typefactory.h"

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

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 title) {
    cur_title = std::move (title);
    cur_meta.clear();
    cur_text.clear();
  }

  void set_meta (std::string meta) {
    cur_meta = std::move (meta);
  }

  void add_text (std::string line) {
    cur_text.push_back (std::move (line));
  }

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

    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();
  }
};

enum class Stage { Title, Meta, Body };

static constexpr std::array<Stage, 3> kAllStages = {
  Stage::Title, Stage::Meta, Stage::Body
};

struct ILineHandler {
  virtual ~ILineHandler() = default;

  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 {
    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 {
    if (line == "==========") {
      ctx.finalize_quote();
      next = Stage::Title;
      return;
    }

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

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

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

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

  return factory;
}

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

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

  for (Stage stage : kAllStages) {
    try {
      auto handler = factory.create (stage);
      if (!handler)
        throw std::runtime_error ("Factory returned null handler");
      handlers.emplace (stage, std::move (handler));
    } catch (const std::out_of_range &) {
      throw std::runtime_error ("Missing handler registration for Stage");
    }
  }

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

  return handlers;
}

struct Converter::Impl {
  ParseContext context;
};

Converter::Converter (std::string input_file_name)
  : input_file_name_ (std::move (input_file_name))
  , impl_ (std::make_unique<Impl>()) {
}

Converter::~Converter() = default;

int Converter::error_code() const noexcept {
  return error_code_;
}

bool Converter::parse() {
  std::ifstream input (input_file_name_);
  if (!input.is_open()) {
    std::cerr << "Failed to open input file: "
              << input_file_name_
              << " (" << std::strerror (errno) << ")\n";
    error_code_ = 2;
    return false;
  }

  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";
    error_code_ = 4;
    return false;
  }

  impl_->context = ParseContext{};
  Stage stage = Stage::Title;

  std::string line;
  while (std::getline (input, 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";
      error_code_ = 4;
      return false;
    }

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

  impl_->context.finalize_quote();
  error_code_ = 0;
  return true;
}

bool Converter::save (const std::string &output_file_name) {
  if (!parse())
    return false;

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

  const ParseContext &ctx = impl_->context;
  for (std::size_t i = 0; i < ctx.order.size(); ++i) {
    const auto &title = ctx.order[i];
    output << "\\section {" << latex_escape (title) << "}\n";

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

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

      for (const auto &text_line : quote.text_lines)
        output << "    " << latex_escape (text_line) << "\n";

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

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

  error_code_ = 0;
  return true;
}