#pragma once

#include <chrono>
#include <cstdint>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <system_error>
#include <utility>
#include <variant>
#include <vector>

#include "secsgem/gem/substrate_state.hpp"

namespace secsgem::gem {

// One entry in a substrate's per-axis transition log.  Holds the
// post-transition state on one axis (the other stays at NoState),
// the triggering event encoded back into the SubstrateEvent or
// SubstrateProcessingEvent enum (held discriminated by `is_processing`),
// the location string at the moment, and a steady_clock timestamp.
struct SubstrateHistoryEntry {
  std::chrono::steady_clock::time_point at;
  SubstrateState           location_to{SubstrateState::NoState};
  SubstrateProcessingState processing_to{SubstrateProcessingState::NoState};
  std::variant<SubstrateEvent, SubstrateProcessingEvent> event;
  std::string location_label;  // free-form location at the time of the event
};

struct Substrate {
  std::string substid;        // SUBSTID — E90 wafer identifier
  std::string carrierid;      // CARRIERID where this wafer originated
  uint8_t     slot = 0;       // 1-based slot in the source carrier
  std::string location;       // free-form: equipment-defined module name
  std::vector<SubstrateHistoryEntry> history;
  std::unique_ptr<SubstrateStateMachine> fsm;
  std::filesystem::path journal_path;  // empty when persistence disabled
};

class SubstrateStore {
 public:
  using LocationChangeHandler =
      std::function<void(const std::string& substid, SubstrateState from,
                         SubstrateState to, SubstrateEvent)>;
  using ProcessingChangeHandler =
      std::function<void(const std::string& substid,
                         SubstrateProcessingState from,
                         SubstrateProcessingState to,
                         SubstrateProcessingEvent)>;

  SubstrateStore() = default;
  SubstrateStore(const SubstrateStore&) = delete;
  SubstrateStore& operator=(const SubstrateStore&) = delete;
  SubstrateStore(SubstrateStore&&) = delete;
  SubstrateStore& operator=(SubstrateStore&&) = delete;

  void set_location_handler(LocationChangeHandler h)     { on_loc_ = std::move(h); }
  void set_processing_handler(ProcessingChangeHandler h) { on_proc_ = std::move(h); }

  enum class CreateResult { Created, Denied_AlreadyExists };

  // Cap per-substrate history retention to keep memory bounded.  0 ==
  // unlimited.  Default cap is 256 entries which comfortably covers a
  // typical wafer's lifecycle.
  void set_history_limit(std::size_t n) { history_limit_ = n; }
  std::size_t history_limit() const { return history_limit_; }

  CreateResult create(std::string substid, std::string carrierid = "",
                      uint8_t slot = 0) {
    if (subs_.count(substid)) return CreateResult::Denied_AlreadyExists;
    install_(substid, carrierid, slot, "", std::nullopt, std::nullopt,
             std::nullopt);
    if (persistent_) write_record_(substid);
    return CreateResult::Created;
  }

  bool has(const std::string& id) const { return subs_.count(id) > 0; }
  const Substrate* get(const std::string& id) const {
    auto it = subs_.find(id);
    return it == subs_.end() ? nullptr : &it->second;
  }
  Substrate* get(const std::string& id) {
    auto it = subs_.find(id);
    return it == subs_.end() ? nullptr : &it->second;
  }

  bool fire_location_event(const std::string& id, SubstrateEvent e,
                           std::string new_location = "") {
    auto* s = get(id);
    if (!s) return false;
    if (!new_location.empty()) s->location = std::move(new_location);
    bool ok = s->fsm->on_location_event(e);
    if (persistent_) write_record_(id);
    return ok;
  }
  bool fire_processing_event(const std::string& id, SubstrateProcessingEvent e) {
    auto* s = get(id);
    if (!(s && s->fsm->on_processing_event(e))) return false;
    if (persistent_) write_record_(id);
    return true;
  }

  bool remove(const std::string& id) {
    auto it = subs_.find(id);
    if (it == subs_.end()) return false;
    if (persistent_ && !it->second.journal_path.empty()) {
      std::error_code ec;
      std::filesystem::remove(it->second.journal_path, ec);
    }
    subs_.erase(it);
    return true;
  }
  std::size_t size() const { return subs_.size(); }
  std::vector<std::string> ids() const {
    std::vector<std::string> out;
    out.reserve(subs_.size());
    for (const auto& kv : subs_) out.push_back(kv.first);
    return out;
  }

  const std::vector<SubstrateHistoryEntry>* history(const std::string& id) const {
    const auto* s = get(id);
    return s ? &s->history : nullptr;
  }

  // ---- Persistence ----------------------------------------------------
  // Records *current state* per substrate.  History is not journaled —
  // it's a transient in-memory ring buffer and rebuilding it from
  // replayed state would be misleading.
  void enable_persistence(std::filesystem::path dir) {
    namespace fs = std::filesystem;
    journal_dir_ = std::move(dir);
    persistent_ = true;
    std::error_code ec;
    fs::create_directories(journal_dir_, ec);

    std::vector<std::pair<uint64_t, fs::path>> existing;
    for (auto& entry : fs::directory_iterator(journal_dir_, ec)) {
      if (!entry.is_regular_file()) continue;
      const auto& p = entry.path();
      if (p.extension() != ".sub") continue;
      uint64_t seq = 0;
      try { seq = std::stoull(p.stem().string()); }
      catch (...) { continue; }
      existing.emplace_back(seq, p);
    }
    std::sort(existing.begin(), existing.end(),
              [](const auto& a, const auto& b) { return a.first < b.first; });

    for (auto& [seq, path] : existing) {
      auto rec = load_record_(path);
      if (!rec) { fs::remove(path, ec); continue; }
      install_(rec->substid, rec->carrierid, rec->slot, rec->location,
               rec->loc_state, rec->proc_state, rec->id_state);
      auto* s = get(rec->substid);
      if (s) s->journal_path = path;
      if (seq >= next_seq_) next_seq_ = seq + 1;
    }
  }

  bool persistence_enabled() const { return persistent_; }
  std::filesystem::path journal_dir() const { return journal_dir_; }

 private:
  struct Record {
    std::string substid;
    std::string carrierid;
    uint8_t slot;
    std::string location;
    SubstrateState           loc_state;
    SubstrateProcessingState proc_state;
    SubstrateIDStatus        id_state;
  };

  // Substrate record:
  //   [u8 magic = 0xC6][u8 version = 1]
  //   [u8 loc_state][u8 proc_state][u8 id_state][u8 slot]
  //   [u16 substid_len][substid_len × u8]
  //   [u16 carrierid_len][carrierid_len × u8]
  //   [u16 location_len][location_len × u8]
  static constexpr uint8_t kMagic   = 0xC6;
  static constexpr uint8_t kVersion = 0x01;

  void install_(const std::string& substid, const std::string& carrierid,
                uint8_t slot, const std::string& location,
                std::optional<SubstrateState> loc,
                std::optional<SubstrateProcessingState> proc,
                std::optional<SubstrateIDStatus> id) {
    auto fsm = std::make_unique<SubstrateStateMachine>();
    if (loc || proc || id) {
      fsm->restore_state(loc.value_or(SubstrateState::AtSource),
                         proc.value_or(SubstrateProcessingState::NeedsProcessing),
                         id.value_or(SubstrateIDStatus::NotConfirmed));
    }
    const std::string keyed = substid;
    fsm->set_location_handler(
        [this, keyed](SubstrateState f, SubstrateState t, SubstrateEvent e) {
          record_history(keyed, t, SubstrateProcessingState::NoState, e);
          if (on_loc_) on_loc_(keyed, f, t, e);
        });
    fsm->set_processing_handler(
        [this, keyed](SubstrateProcessingState f, SubstrateProcessingState t,
                      SubstrateProcessingEvent e) {
          record_history(keyed, SubstrateState::NoState, t, e);
          if (on_proc_) on_proc_(keyed, f, t, e);
        });
    subs_.emplace(substid,
                  Substrate{substid, carrierid, slot, location, {},
                            std::move(fsm), {}});
  }

  void write_record_(const std::string& substid) {
    namespace fs = std::filesystem;
    auto* s = get(substid);
    if (!s) return;
    if (s->journal_path.empty()) {
      char namebuf[32];
      std::snprintf(namebuf, sizeof(namebuf), "%010llu.sub",
                    static_cast<unsigned long long>(next_seq_++));
      s->journal_path = journal_dir_ / namebuf;
    }
    fs::path tmp = s->journal_path;
    tmp += ".tmp";
    std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
    if (!out) return;
    uint8_t header[6] = {
        kMagic, kVersion,
        static_cast<uint8_t>(s->fsm->location_state()),
        static_cast<uint8_t>(s->fsm->processing_state()),
        static_cast<uint8_t>(s->fsm->id_state()),
        s->slot};
    out.write(reinterpret_cast<const char*>(header), sizeof(header));
    auto write_str = [&](const std::string& str) {
      uint16_t n = static_cast<uint16_t>(str.size());
      uint8_t lb[2] = {static_cast<uint8_t>(n >> 8), static_cast<uint8_t>(n)};
      out.write(reinterpret_cast<const char*>(lb), 2);
      out.write(str.data(), static_cast<std::streamsize>(n));
    };
    write_str(s->substid);
    write_str(s->carrierid);
    write_str(s->location);
    out.flush();
    out.close();
    std::error_code ec;
    fs::rename(tmp, s->journal_path, ec);
    if (ec) fs::remove(tmp, ec);
  }

  static std::optional<Record> load_record_(const std::filesystem::path& p) {
    std::ifstream in(p, std::ios::binary);
    if (!in) return std::nullopt;
    uint8_t header[6];
    in.read(reinterpret_cast<char*>(header), sizeof(header));
    if (!in || header[0] != kMagic || header[1] != kVersion) return std::nullopt;
    Record r;
    r.loc_state  = static_cast<SubstrateState>(header[2]);
    r.proc_state = static_cast<SubstrateProcessingState>(header[3]);
    r.id_state   = static_cast<SubstrateIDStatus>(header[4]);
    r.slot       = header[5];
    auto read_str = [&](std::string& out) {
      uint8_t lb[2];
      in.read(reinterpret_cast<char*>(lb), 2);
      if (!in) return false;
      uint16_t n = static_cast<uint16_t>((uint16_t(lb[0]) << 8) | lb[1]);
      out.resize(n);
      in.read(out.data(), n);
      return static_cast<bool>(in) || n == 0;
    };
    if (!read_str(r.substid))   return std::nullopt;
    if (!read_str(r.carrierid)) return std::nullopt;
    if (!read_str(r.location))  return std::nullopt;
    return r;
  }

  template <typename Event>
  void record_history(const std::string& id, SubstrateState loc_to,
                      SubstrateProcessingState proc_to, Event ev) {
    auto* s = get(id);
    if (!s) return;
    SubstrateHistoryEntry entry;
    entry.at             = std::chrono::steady_clock::now();
    entry.location_to    = loc_to;
    entry.processing_to  = proc_to;
    entry.event          = ev;
    entry.location_label = s->location;
    s->history.push_back(std::move(entry));
    if (history_limit_ != 0 && s->history.size() > history_limit_) {
      // Drop the oldest entry; vector shift is fine for the small caps
      // we expect (default 256, typically a few dozen per substrate).
      s->history.erase(s->history.begin());
    }
  }

  std::map<std::string, Substrate> subs_;
  LocationChangeHandler   on_loc_;
  ProcessingChangeHandler on_proc_;
  std::size_t history_limit_ = 256;
  bool persistent_ = false;
  std::filesystem::path journal_dir_;
  uint64_t next_seq_ = 0;
};

}  // namespace secsgem::gem