#include "simdata/simDatabase.h"

namespace germanairlinesva
{
namespace file
{
  namespace simdata
  {
    SimDatabase::SimDatabase(int xPlaneVersion,
                             const char *hash,
                             std::unique_ptr<config::Config> &configuration,
                             std::function<void(const std::string)> toLog)
    {
      if (strcmp(configuration->getScenery().c_str(), hash) != 0 ||
          !util::fileExists(XPLANE_PLUGIN_DIRECTORY SIMDATABASE)) {
        scan(xPlaneVersion < 12000 ? XPLANE11_BASE_SCENERY
                                   : XPLANE12_BASE_SCENERY,
             XPLANE_CUSTOM_SCENERY,
             XPLANE_PLUGIN_DIRECTORY "log.txt",
             airports);

        configuration->updateScenery(hash);
        this->toFile();

        toLog("Sim Database updated");
      } else {
        this->fromFile();
      }
    }

    void SimDatabase::fromFile()
    {
      std::ifstream in(XPLANE_PLUGIN_DIRECTORY SIMDATABASE,
                       std::ifstream::binary);

      // File Header
      std::string ident = readString(in, 5);
      if (ident.compare("VGAS") != 0) {
        throw std::invalid_argument("Wrong file");
      }
      std::uint8_t version = read<std::uint8_t>(in);

      if (version == 1) {
        this->readVersion1(in);
      }
    }

    void SimDatabase::readVersion1(std::ifstream &in)
    {
      std::uint16_t numAirports = read<std::uint16_t>(in);

      for (int i = 0; i < numAirports; i++) {
        // ICAO
        std::string icao = readString(in);
        // Gates
        std::uint16_t numGates = read<std::uint16_t>(in);
        for (int j = 0; j < numGates; j++) {
          std::string designator = readString(in);
          struct germanairlinesva::geodata::point center =
              read<struct germanairlinesva::geodata::point>(in);
          std::uint8_t radius = read<std::uint8_t>(in);

          this->airports[icao].first.emplace_back(designator, center, radius);
        }
        // Runways
        std::uint8_t numRunways = read<std::uint8_t>(in);
        for (int j = 0; j < numRunways; j++) {
          std::string designator = readString(in);
          // Bounds
          struct germanairlinesva::geodata::box bounds =
              read<struct germanairlinesva::geodata::box>(in);
          std::uint8_t width = read<std::uint8_t>(in);
          std::uint16_t length = read<std::uint16_t>(in);
          std::uint16_t trueHeading = read<std::uint16_t>(in);

          this->airports[icao].second.emplace_back(designator,
                                                   bounds,
                                                   width,
                                                   length,
                                                   trueHeading);
        }
      }

      in.close();
    }

    void SimDatabase::toFile() const
    {
      std::ofstream out(XPLANE_PLUGIN_DIRECTORY SIMDATABASE,
                        std::fstream::binary);

      // File Header, Last member is version
      std::uint8_t header[] = {'V', 'G', 'A', 'S', '\0', 1};
      out.write(reinterpret_cast<const char *>(header), 6);
      // Num Airports
      write<std::uint16_t>(out, airports.size());
      // Airport
      for (const std::pair<const std::string,
                           std::pair<std::vector<const Gate>, std::vector<const Runway>>>
               &airport : airports) {
        std::string icao = airport.first;
        const std::vector<const Gate> gates = airport.second.first;
        const std::vector<const Runway> runways = airport.second.second;
        // ICAO
        writeString(out, icao);
        // Gates
        write<std::uint16_t>(out, gates.size());
        for (const Gate &gate : gates) {
          gate.toFile(out);
        }
        // Runways
        write<std::uint8_t>(out, runways.size());
        for (const Runway &runway : runways) {
          runway.toFile(out);
        }
      }
      out.close();
    }
  } // namespace simdata
} // namespace file
} // namespace germanairlinesva