#include "builder.hpp"
#include "dbc.hpp"
#include <chrono>                     // for milliseconds
#include <fmt/core.h>
#include <fstream>
#include <git2.h>
#include <iostream>
#include <memory>                  // for allocator, shared_ptr
#include <regex>
#include <stdio.h>
#include <stdlib.h>                   // for EXIT_SUCCESS
#include <string>                  // for operator+, to_string
#include <unistd.h>
#include <nlohmann/json.hpp>
#include <fstream>
#include <future>

using std::string;
using namespace fmt;
using namespace nlohmann;
using namespace std::chrono_literals;

#define BUF_MAX 1024

Builder::Builder(GUI &g, GameEngine &engine)
  : gui(g), game(engine)
{
  std::ifstream infile(".tarpit.json");
  json config = json::parse(infile);

  config["git_path"].template get_to<string>(git_path);
  config["build_cmd"].template get_to<string>(build_cmd);
}

FILE *start_command(string &build_cmd) {
  FILE *build_out = popen(build_cmd.c_str(), "r");
  dbc::check(build_out != nullptr, "Failed to run command.");
  return build_out;
}

string read_line(FILE *build_out, bool &done_out) {
  char buffer[BUF_MAX];
  char *res = fgets(buffer, BUF_MAX, build_out);
  done_out = res == nullptr;

  if(!done_out) {
    return string{buffer};  // yeah, that's probably a problem
  } else {
    return "";
  }
}

MatchResult Builder::parse_line(const string &line) {
  std::regex err_re("(.*?):([0-9]+):([0-9]+):\\s*(.*?):\\s*(.*)\n*");

  std::smatch err;
  bool match = std::regex_match(line, err, err_re);

  if(match) {
    return {
      .match = true,
      .file_name = err[1].str(),
      .lnumber = err[2].str(),
      .col = err[3].str(),
      .type = err[4].str(),
      .message = err[5].str(),
    };
  } else {
    return { .match = false };
  }
}

void Builder::building(BuildEvent ev) {
  // check if there's output
  if(build_done) {
    int rc = pclose(build_out);

    if(rc == 0) {
      gui.build_works();
    } else {
      // BUG: make it not play two sounds
      gui.build_failed(true, build_cmd);
    }

    build_out = NULL;
    state(DONE);
  } else {
    auto m = parse_line(line);

    if(m.match) {
      gui.output(format("HIT WITH {} @ {}:{}:{} {}", m.type, m.file_name, m.lnumber, m.col, m.message));
      game.hit(m.type);
    }
    state(READING);
  }
}

void Builder::start(BuildEvent ev) {
  gui.output(format("Using build command: {}", build_cmd));
  fileWatcher = new efsw::FileWatcher();
  dbc::check(fileWatcher != nullptr, "Failed to create filewatcher.");

  git_libgit2_init();

  int err = git_repository_open(&repo, git_path.c_str());
  dbc::check(err == 0, git_error_last()->message);

  listener = new UpdateListener(repo);
  dbc::check(listener != nullptr, "Failed to create listener.");

  gui.output(format("Watching directory {} for changes...", git_path));
  wid = fileWatcher->addWatch(git_path, listener, true);
  fileWatcher->watch();

  state(WAITING);
}

void Builder::waiting(BuildEvent ev) {
  if(listener->changes) {
    game.start_round();
    gui.building();
    gui.output(format("CHANGES! Running build {}", build_cmd));
    build_fut = std::async([&]() {
        return start_command(build_cmd);
    });
    state(STARTING);
  }
}

void Builder::starting(BuildEvent ev) {
  std::future_status status = build_fut.wait_for(0ms);

  if(status == std::future_status::ready) {
    build_out = build_fut.get();
    state(READING);
  } else {
    state(STARTING);
  }
}

void Builder::reading(BuildEvent ev) {
  line = read_line(build_out, build_done);
  state(BUILDING);
}

void Builder::done(BuildEvent ev) {
  game.end_round();

  if(game.is_dead()) {
    gui.you_died();
    game.reset();
  }

  listener->reset_state();
  gui.output("^^^^^^^^^^^ END ^^^^^^^^^^^");
  state(WAITING);
}

void Builder::exit(BuildEvent ev) {
  if(ev == QUIT) {
    fileWatcher->removeWatch(wid);
    git_libgit2_shutdown();
    state(EXIT);
  }
}

void Builder::error(BuildEvent ev) {
  // how to avoid doing this more than once?
  if(ev == CRASH) {
    if(repo != nullptr) git_repository_free(repo);
    git_libgit2_shutdown();
  }
}