#include "galaxy.h"

#include <algorithm>  // sort
#include <boost/format.hpp>
#include <exception>
#include <fstream>
#include <ostream>
#include <set>
#include <string>

#include "logging.h"
#include "yaml-cpp/yaml.h"

// c++ default exceptions list
// https://en.cppreference.com/w/cpp/error/exception

bool buysell::operator==(const buysell &rhs) const {
  return ((foe[0] == rhs.foe[0]) && (foe[1] == rhs.foe[1]) &&
          (foe[2] == rhs.foe[2]));
}

std::ostream &operator<<(std::ostream &os, const buysell &bs) {
  os << bs.foe[0] << bs.foe[1] << bs.foe[2];
  return os;
}

bool buysell_text::operator==(const buysell_text &rhs) const {
  return ((txt[0] == rhs.txt[0]) && (txt[1] == rhs.txt[1]) &&
          (txt[2] == rhs.txt[2]));
}

std::ostream &operator<<(std::ostream &os, const buysell_text &bst) {
  os << '"' << bst.txt[0] << bst.txt[1] << bst.txt[2] << '"';
  return os;
}

std::ostream &operator<<(std::ostream &os, const port &p) {
  if (p.type == 0) {
    os << p.sector << ": " << (int)p.type;
  } else {
    os << p.sector << ": " << (int)p.type << " " << text_from_type(p.type)
       << " " << p.amount[0] << "," << p.amount[1] << "," << p.amount[2];
  }
  return os;
}

/*
// adding this breaks test-galaxy's port = {2, 2, {1,2,3}, {1,2,3}} code.
port::port() {
  sector = 0;
  type = 0;
  for (int x = 0; x < 3; x++) {
    amount[x] = 0;
    percent[x] = 0;
  }
}
*/

sector_warps::sector_warps() {
  sector = 0;
  // for (int x = 0; x < MAX_WARPS; ++x) warps[x] = 0;
}

void sector_warps::add(sector_type new_sector) {
  warps.insert(new_sector);
  /*
  for (int x = 0; x < MAX_WARPS; ++x) {
    if (warps[x] == new_sector) return;
    if (warps[x] == 0) {
      warps[x] = new_sector;
      return;
    }
  }
  std::string message = str(boost::format("More then MAX %1% sectors for %2%") %
                            MAX_WARPS % (int)sector);
  throw std::out_of_range(message);
  */
}

std::ostream &operator<<(std::ostream &os, const sector_warps &warps) {
  os << "Sector: " << warps.sector << " ";
  bool comma = false;
  for (auto const &warp : warps.warps) {
    if (comma)
      os << ",";
    else
      comma = true;
    os << warp;
  }
  /*
  for (int x = 0; x < MAX_WARPS; ++x) {
    if (warps.warps[x] != 0) {
      if (x != 0) os << ",";
      os << warps.warps[x];
    }
  }
  */
  return os;
}

#ifdef NOT_SET
bool sector_sort(sector_type st1, sector_type st2) {
  /* Sort sectors, put 0's at the end. */
  if (st1 == 0) return false;
  if (st2 == 0) return false;
  return (st1 < st2);
}

void sector_warps::sort(void) {
  std::sort(&warps[0], &warps[MAX_WARPS], sector_sort);
}

bool sector_warps::operator==(const sector_warps &rhs) const {
  /*
  Comapre if the sector_warps are the same.
  They do not need to be in the same order.
  */
  std::set<sector_type> contains;
  if (sector == rhs.sector) {
    int x;
    for (x = 0; x < MAX_WARPS; ++x) {
      if (warps[x] == 0) break;
      contains.insert(warps[x]);
    }
    for (x = 0; x < MAX_WARPS; ++x) {
      if (warps[0] == 0) break;
      auto pos = contains.find(rhs.warps[x]);
      if (pos == contains.end()) return false;
      contains.erase(pos);
    }
    return contains.empty();
  }

  // sector number doesn't match!
  return false;
}
#endif

#define GTEST_COUT std::cerr << "[          ] [ INFO ]"
#define GTEST_DEBUG

struct port parse_portcim(const std::string line) {
  struct port p;
  p.sector = std::stoi(line);
  //  20 - 1708  97% -  710  56%    287  15%
  static std::regex portrx(
      "[ ]*([0-9]+) (.)[ ]+([0-9]+)[ ]+([0-9]+%) (.)[ "
      "]+([0-9]+)[ ]+([0-9]+%) (.)[ ]+([0-9]+)[ ]+([0-9]+%)[ ]*",
      std::regex_constants::ECMAScript);

  // does it not understand {3} ??
  // NO, it does not, from regex101.com:
  // A repeated capturing group will only capture the last iteration. Put a
  // capturing group around the repeated group to capture all iterations or use
  // a non-capturing group instead if you're not interested in the data
  //
  //  static std::regex portrx("[ ]*([0-9]+)( (.)[ ]+([0-9]+)[ ]+([0-9]+%)){3}[
  //  ]*",
  //                           std::regex_constants::ECMAScript);

  // sector + amount pct + amount pct + amount pct
  // 1      2 3      4   5 6      7   8 9      10

#ifdef GTEST_DEBUG
  GTEST_COUT << "Sector: " << p.sector << std::endl;
  GTEST_COUT << "Line: [" << line << "]" << std::endl;
#endif

  buysell port_buysell;

  std::smatch matches;
  if (std::regex_match(line, matches, portrx)) {
#ifdef GTEST_DEBUG
    for (size_t x = 1; x < matches.size(); ++x) {
      GTEST_COUT << x << " : " << matches[x] << std::endl;
    }
#endif

    if (matches.size() != 11) {
#ifdef GTEST_DEBUG
      GTEST_COUT << "Now you have 101 problems." << std::endl;
#endif
      p.sector = 0;
      p.type = 0;
      return p;
    }
    // GTEST_COUT << "matches: " << matches.size() << std::endl;
    p.sector = stoi(matches[1]);
    // GTEST_COUT << "sector: " << matches[1] << std::endl;
    // for (int x = 1; x < 11; ++x) {
    //   GTEST_COUT << x << " : " << matches[x] << std::endl;
    // }
    for (int x = 0; x < 3; ++x) {
      int pos = x * 3;
      port_buysell.foe[x] = matches[pos + 2] == "-";
      p.amount[x] = stoi(matches[pos + 3]);
      p.percent[x] = stoi(matches[pos + 4]);
    }
    p.type = type_from_buysell(port_buysell);
#ifdef GTEST_DEBUG
    GTEST_COUT << "port is type " << (int)p.type << std::endl;
#endif
    return p;
  } else {
#ifdef GTEST_DEBUG
    GTEST_COUT << "regex_match failed." << std::endl;
#endif
    p.type = 0;
    p.sector = 0;
    return p;
  }
}

Galaxy::Galaxy() {}
Galaxy::~Galaxy() { BUGZ_LOG(fatal) << "Galaxy::~Galaxy()"; }

void Galaxy::add_warp(sector_warps sw) {
  auto pos = warps.find(sw.sector);

  if (pos == warps.end()) {
    // not found
    // sw.sort();
    warps[sw.sector] = sw;
    BUGZ_LOG(info) << "add_warp NEW " << sw.sector;
  } else {
    // found!
    if (pos->second.warps == sw.warps) {
      BUGZ_LOG(trace) << "add_warp: Yup, I already know about " << sw.sector;
    } else {
      BUGZ_LOG(info) << "add_warp:  Warps don't match! Updating...";
      BUGZ_LOG(warning) << "Have: " << pos->second;
      BUGZ_LOG(warning) << "Got : " << sw;
      warps[sw.sector] = sw;
    }
  }
}

void Galaxy::add_port(sector_type sector, int port_class) {
  auto pos = ports.find(sector);
  if (pos == ports.end()) {
    // no such port.
    port p;
    p.sector = sector;
    p.type = port_class;
    for( int x= 0; x < 3; x++) {
      p.amount[x ] = 0;
      p.percent[x] = 0;
    }
    BUGZ_LOG(info) << "add_port: " << sector << ", " << port_class << " : " << p;
    ports[sector] = p;
  } else {
    // port was found, so:
    if ( pos->second.type == port_class) {
      BUGZ_LOG(info) << "add_port: Yup, port " << sector << " is class " << port_class;
    } else {
      BUGZ_LOG(fatal) << "add_port: " << sector << " shows " << pos->second.type << " >> set to " << port_class;
    }
  }
}

void Galaxy::add_port(port p) {
  auto pos = ports.find(p.sector);
  if (pos == ports.end()) {
    BUGZ_LOG(info) << "add_port: NEW " << p;
    ports[p.sector] = p;
  } else {
    if (pos->second.type != p.type) {
      if ( (pos->second.type == 9) && (p.type == 8) ) {
        BUGZ_LOG(info) << "add_port: StarDock " << p.sector;
        p.type = 9;
        ports[p.sector] = p;
      } else {
        BUGZ_LOG(fatal) << "add_port: " << pos->second << " NEW : " << p;
        ports[p.sector] = p;
      }
    } else {
      BUGZ_LOG(info) << "add_port: Yup " << p.sector;
    }
  }
}

#ifdef NO_NOT_EVER

namespace YAML {
template <>
struct convert<Galaxy> {
  static Node encode(const Galaxy &rhs) {
    Node node;
    for (auto const &config_iter : rhs.config) {
      node["config"][config_iter.first] = config_iter.second;
    }

    for (auto const &warp : rhs.warps) {
      for (int x = 0; x < MAX_WARPS; ++x) {
        if (warp.second.warps[x] == 0) break;
        node["warps"][warp.first].push_back(warp.second.warps[x]);
      }
    }

    /*
    node.push_back(rhs.x);
    node.push_back(rhs.y);
    node.push_back(rhs.z);
    return node;
    */
    return node;
  }

  static bool decode(const Node &node, Galaxy &rhs) {
    if (!node.IsMap()) return false;
    if (node["config"]) {
    } else {
      BUGZ_LOG(fatal) << "YAML missing config section.";
    }
    if (node["ports"]) {
    } else {
      BUGZ_LOG(fatal) << "YAML missing ports section.";
    }

    if (node["warps"]) {
      const Node &warps = node["warps"];
      if (warps.IsMap()) {
        for (auto const warp_iter : warps) {
          sector_warps sw;
          sw.sector = warp_iter.first.as<int>();
          for (auto const sector_iter : warp_iter.second) {
            sw.add(sector_iter.as<int>());
          }
          BUGZ_LOG(fatal) << "YAML warp: " << sw;
          rhs.add_warp(sw);
        }
      }
    } else {
      BUGZ_LOG(fatal) << "YAML missing warps section.";
    }
    /*
    if(!node.IsSequence() || node.size() != 3) {
      return false;
    }

    rhs.x = node[0].as<double>();
    rhs.y = node[1].as<double>();
    rhs.z = node[2].as<double>();
    */
    return true;
  }
};
}  // namespace YAML

#endif

void Galaxy::load(void) {
  std::string filename =
      str(boost::format("galaxy-%1%-%2%.json") % game % username);
  // reset ?
  config.clear();
  ports.clear();
  warps.clear();
  if (file_exists(filename)) {
    YAML::Node data = YAML::LoadFile(filename);
    if (data["config"]) {
    } else {
      BUGZ_LOG(fatal) << "YAML Missing config section.";
    }
    if (data["ports"]) {
      const YAML::Node ports = data["ports"];
      for (auto const &port_iter : ports) {
        port p;
        p.sector = port_iter.first.as<int>();
        p.type = port_iter.second["class"].as<int>();
        int x = 0;
        for (auto const &amount : port_iter.second["amount"]) {
          p.amount[x] = amount.as<int>();
          ++x;
        }
        x = 0;
        for (auto const &pct : port_iter.second["pct"]) {
          p.percent[x] = pct.as<int>();
          ++x;
        }
        add_port(p);
      }
    } else {
      BUGZ_LOG(fatal) << "YAML Missing ports section.";
    }
    if (data["warps"]) {
      const YAML::Node &warps = data["warps"];
      // if (warps.IsMap()) {
      for (auto const warp_iter : warps) {
        sector_warps sw;
        sw.sector = warp_iter.first.as<int>();
        for (auto const sector_iter : warp_iter.second) {
          sw.add(sector_iter.as<int>());
        }
        BUGZ_LOG(fatal) << "YAML warp: " << sw;
        add_warp(sw);
      }
      // }
    } else {
      BUGZ_LOG(fatal) << "YAML Missing warps section.";
    }

    BUGZ_LOG(fatal) << "YAML: config keys: " << config.size();
    BUGZ_LOG(fatal) << "YAML:   warp keys: " << warps.size();
    BUGZ_LOG(fatal) << "YAML:   port keys: " << ports.size();

  } else {
    BUGZ_LOG(fatal) << "Missing YAML: " << filename;
  }
}

void Galaxy::save(void) {
  std::string filename =
      str(boost::format("galaxy-%1%-%2%.json") % game % username);
  YAML::Node data;
  BUGZ_LOG(fatal) << "YAML config: " << config.size();
  for (auto const &config_iter : config) {
    data["config"][config_iter.first] = config_iter.second;
  }
  BUGZ_LOG(fatal) << "YAML warps: " << warps.size();
  for (auto const &warp : warps) {
    for (auto const &sector : warp.second.warps) {
      data["warps"][warp.first].push_back(sector);
    }
    /*
    for (int x = 0; x < MAX_WARPS; ++x) {
      if (warp.second.warps[x] == 0) break;
      data["warps"][warp.first].push_back(warp.second.warps[x]);
    }
    */
  }
  BUGZ_LOG(fatal) << "YAML ports: " << ports.size();
  /*
  When saving to yaml, my sector_type is like char.  So, it wants
  to save the values as a character.  Cast to int.
   */
  for (auto const &port : ports) {
    data["ports"][port.second.sector]["class"] = (int)port.second.type;
    for (int x = 0; x < 3; x++) {
      data["ports"][port.second.sector]["amount"].push_back(
          (int)port.second.amount[x]);
      data["ports"][port.second.sector]["pct"].push_back(
          (int)port.second.percent[x]);
    }
  }

  std::ofstream fout(filename);
  fout << data << std::endl;
  BUGZ_LOG(fatal) << "YAML: " << filename;
}