#include <array>
#include <map>
#include <string>
#include <vector>

#include "director.h"
#include "galaxy.h"
#include "gtest/gtest.h"

/*

How can I add logging, but not really add/use it?

*/

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

namespace {

std::map<int, const char *> port_classes = {{1, "BBS"}, {2, "BSB"}, {3, "SBB"},
                                            {4, "SSB"}, {5, "SBS"}, {6, "BSS"},
                                            {7, "SSS"}, {8, "BBB"}, {9, "BBB"}};

/* From Galaxy.py
PORT_CLASSES = {
    1: "BBS",
    2: "BSB",
    3: "SBB",
    4: "SSB",
    5: "SBS",
    6: "BSS",
    7: "SSS",
    8: "BBB",
}*/

TEST(ports, get_buysell) {
  for (int type = 1; type < 10; ++type) {
    buysell expected;
    const char *flags;

    flags = port_classes[type];
    for (int x = 0; x < 3; ++x) expected.foe[x] = flags[x] == 'B';
    buysell result = get_buysell(type);
    for (int x = 0; x < 3; ++x)
      EXPECT_EQ(result.foe[x], expected.foe[x])
          << "type: " << type << " pos: " << x;
  }
}

TEST(ports, invert_buysell) {
  for (int type = 1; type < 10; ++type) {
    buysell expected;
    const char *flags;

    flags = port_classes[type];
    for (int x = 0; x < 3; ++x) expected.foe[x] = flags[x] != 'B';
    buysell result = get_buysell(type);
    buysell invert = invert_buysell(result);
    for (int x = 0; x < 3; ++x)
      EXPECT_EQ(invert.foe[x], expected.foe[x])
          << "type: " << type << " pos: " << x;
  }
}

TEST(ports, text_from_type) {
  for (int type = 1; type < 10; ++type) {
    buysell_text expected;
    const char *flags;

    flags = port_classes[type];
    for (int x = 0; x < 3; ++x) expected.txt[x] = flags[x];
    buysell_text result = text_from_type(type);
    EXPECT_EQ(result, expected) << "type: " << type;
  }
}

TEST(ports, text_from_buysell) {
  for (int type = 1; type < 10; ++type) {
    buysell source = get_buysell(type);
    buysell_text expected;
    const char *flags;

    flags = port_classes[type];
    for (int x = 0; x < 3; ++x) expected.txt[x] = flags[x];
    buysell_text result = text_from_buysell(source);
    EXPECT_EQ(result, expected) << "type: " << type;
  }
}

TEST(ports, type_from_buysell) {
  for (int type = 1; type < 9; ++type) {
    buysell source = get_buysell(type);
    int result = type_from_buysell(source);
    EXPECT_EQ(result, type) << "type: " << type;
  }
}

struct pair {
  int t1;
  int t2;
  friend bool operator<(const pair &lhs, const pair &rhs) {
    if (lhs.t1 == rhs.t1) {
      return lhs.t2 < rhs.t2;
    }
    return lhs.t1 < rhs.t1;
  };
  friend bool operator==(const pair &lhs, const pair &rhs) {
    return (lhs.t1 == rhs.t1) && (lhs.t2 == rhs.t2);
  };
};

#ifdef NOT_ANYMORE
TEST(ports, trade_types) {
  std::map<pair, int> expected;
  for (int x = 0; x < 9; ++x) {
    pair p{x, x};  // ; p.t1 = x; p.t2 = 2;
    expected[p] = 0;
  }

  expected[pair{1, 2}] = 1;
  expected[pair{1, 4}] = 1;
  expected[pair{2, 5}] = 1;
  expected[pair{4, 5}] = 1;

  // I'm checking 0's and 1's.
  expected[pair{1, 3}] = 2;
  expected[pair{2, 3}] = 2;
  expected[pair{4, 6}] = 2;
  expected[pair{5, 6}] = 2;

  /*
  GTEST_COUT << "size:" << expected.size() << std::endl;

  for (auto const & i : expected ) {
    GTEST_COUT << i.first.t1 << "," << i.first.t2 << " :" << i.second <<
  std::endl;
  }

  GTEST_COUT << "Done!" << std::endl;
  */

  for (int p1 = 1; p1 <= 8; ++p1) {
    for (int p2 = p1; p2 <= 8; ++p2) {
      // GTEST_COUT << "Type " << p1 << " and " << p2 << std::endl;
      int t = trade_type(p1, p2);
      int t2 = trade_type(p2, p1);
      EXPECT_EQ(t, t2) << "Comparing reversed types";
      pair p{p1, p2};
      auto r = expected.find(p);
      if (r != expected.end()) {
        EXPECT_EQ(t, r->second) << "Comparision";
      } else {
        GTEST_COUT << "TODO: Need type for " << p1 << " " << text_from_type(p1)
                   << " , " << p2 << " " << text_from_type(p2) << " : " << t
                   << std::endl;
      }
    }
  }
}
#endif

TEST(ports, parse_portcim) {
  // This really needs to be checked against real lines from a log file
  // THis was copied directly from client (indentation may be off)
  std::map<std::string, port> data = {
      {"  2 - 2420 100%    612  35% - 2020 100% ",  // BSB
       {2, 2, {2420, 612, 2020}, {100, 35, 100}}},
      {"  4 - 2880 100% -  275  23%     61   6% ",  // BBS
       {4, 1, {2880, 275, 61}, {100, 23, 6}}},
      {"  6 -  820 100%   1952  89% - 2680 100% ",  // BSB
       {6, 2, {820, 1952, 2680}, {100, 89, 100}}},
      {"  8 - 1000 100% -  855  85% - 1000 100% ",  // BBB
       {8, 8, {1000, 855, 1000}, {100, 85, 100}}},
      {" 20 - 1708  97% -  710  56%    287  15% ",  // BBS
       {20, 1, {1708, 710, 287}, {97, 56, 15}}},
      {" 23 - 2120 100% -  709  40%   1902  69% ",  // BBS
       {23, 1, {2120, 709, 1902}, {100, 40, 69}}},
      {" 28   1511  98% -  478  29%    589  35% ",  // SBS
       {28, 5, {1511, 478, 589}, {98, 29, 35}}},
      {" 29    913  56% -  970 100% - 1990 100% ",  // SBB
       {29, 3, {913, 970, 1990}, {56, 100, 100}}}};

  /*
  // If you could make this a map or something better please improve
  std::vector<port> ports;
  ports.push_back( port{ 2, 2, {2420, 612, 2020}, {100,35,100} });

  struct port p;
  p.sector = 2;
  p.type = 2;
  p.amount[0] = 2420;
  p.amount[1] = 612;
  p.amount[2] = 2020;
  p.percent[0] = 100;
  p.percent[1] = 35;
  p.percent[2] = 100;
  ports.push_back(p);
  p.sector = 4;
  p.type = 1;
  p.amount[0] = 2880;
  p.amount[1] = 275;
  p.amount[2] = 61;
  p.percent[0] = 100;
  p.percent[1] = 23;
  p.percent[2] = 6;
  ports.push_back(p);
    */

  for (auto testdata : data) {
    port parse = parse_portcim(testdata.first);
    EXPECT_EQ((int)parse.sector, (int)testdata.second.sector)
        << "Text: [" << testdata.first << "]";
    if (parse.sector != 0) {
      EXPECT_EQ(parse.type, testdata.second.type);
      for (int x = 0; x < 3; ++x) {
        EXPECT_EQ(parse.amount[x], testdata.second.amount[x])
            << "Sector:" << parse.sector;
        EXPECT_EQ(parse.percent[x], testdata.second.percent[x])
            << "Sector:" << parse.sector;
      }
    }
  }
  /*
  port parse = parse_portcim(data[0]);
  EXPECT_EQ(parse.sector, 2 );
  EXPECT_EQ(parse.type, 2);
  EXPECT_EQ(parse.amount[0], 2420);

  EXPECT_EQ(parse.sector, ports[0].sector);
  EXPECT_EQ(parse.type, ports[0].type);
    */
  /*
  this can't work.  trying to compare "pointers" .. that's why the numbers are
  huge: Expected equality of these values: parse.amount Which is: 0x7fffc5ef83f6
  ports[0].amount
    Which is: 0x5556513ddb94
  */

  // EXPECT_EQ(parse.amount, ports[0].amount);
  // EXPECT_EQ(parse.percent, ports[0].percent);
}

TEST(galaxy, trade_type_info) {
  // test this code to see that we get the correct trade type results.
  Galaxy g;
  g.add_port(port{68, 1, {1290, 557, 561}, {100, 47, 56}});
  g.add_port(port{706, 4, {2490, 2590, 743}, {100, 100, 94}});
  trade_type_result ttr = g.trade_type_info(68, 706);
  EXPECT_EQ(ttr.type, BEST) << "Expect Trade Type BEST";
  // burn out equipment
  g.add_port(port{68, 1, {1290, 557, 161}, {100, 47, 16}});
  ttr = g.trade_type_info(68, 706);
  EXPECT_EQ(ttr.type, FAIR_O) << "Expect Trade Type FAIR_O";
  std::vector<port_pair_type> vppt = g.find_trades(68);
  EXPECT_EQ(vppt.size(), 0) << "Should have no trades, because no warps";
  g.add_warp(sector_warps{706, {68}});
  g.add_warp(sector_warps{68, {51, 693, 706, 904}});
  vppt = g.find_trades(68);
  EXPECT_EQ(vppt.size(), 1) << "Found a trade";
}

}  // namespace