// Active SECS/GEM host: connects to equipment and walks the full GEM core
// demo. After establishing communication and going online, the host configures
// dynamic event reporting (define report -> link CEID -> enable), triggers a
// host command that fires the linked CEID, exercises alarm enable + alarm
// triggering, fetches the recipe list and a single recipe body, sends a
// terminal display, and finally requests OFFLINE and separates.

#include <asio.hpp>
#include <chrono>
#include <cstdint>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <system_error>
#include <vector>

#include "secsgem/endpoint.hpp"
#include "secsgem/gem/messages.hpp"
#include "secsgem/secs2/codec.hpp"
#include "secsgem/secs2/message.hpp"

using namespace secsgem;
namespace s2 = secsgem::secs2;
namespace gem = secsgem::gem;

namespace {

std::string arg(int argc, char** argv, const std::string& key, const std::string& def) {
  for (int i = 1; i + 1 < argc; ++i)
    if (key == argv[i]) return argv[i + 1];
  return def;
}

constexpr const char* kHostMdln = "GEMHOST";
constexpr const char* kHostRev = "0.1.0";

// Demo report / event subscription ids the host will install.
constexpr uint32_t kDataIdReports = 7;
constexpr uint32_t kRptidStatus   = 1000;
constexpr uint32_t kCeidProcessStarted = 300;
constexpr uint32_t kCeidAlarmSetEvent  = 200;
constexpr uint32_t kCeidCJExecuting    = 400;
constexpr uint32_t kCeidCJCompleted    = 401;
constexpr uint32_t kAlarmChiller       = 1;

struct Sequence : std::enable_shared_from_this<Sequence> {
  using Step = std::function<void(std::function<void()>)>;
  std::vector<Step> steps;
  std::size_t i = 0;

  void run() {
    if (i >= steps.size()) return;
    auto self = shared_from_this();
    steps[i]([self] {
      ++self->i;
      self->run();
    });
  }
};

}  // namespace

int main(int argc, char** argv) {
  Client::Config cfg;
  cfg.host = arg(argc, argv, "--host", "127.0.0.1");
  cfg.port = static_cast<uint16_t>(std::stoi(arg(argc, argv, "--port", "5000")));
  cfg.device_id = static_cast<uint16_t>(std::stoi(arg(argc, argv, "--device", "0")));
  cfg.timers.linktest = std::chrono::milliseconds(0);

  asio::io_context io;
  Client client(io, cfg);

  auto logfn = [](const std::string& m) { std::cout << "[host]  " << m << std::endl; };
  client.on_log(logfn);

  client.on_connection([&io, logfn](std::shared_ptr<Connection> conn) {
    // Inbound primaries from the equipment.
    conn->set_message_handler(
        [logfn](const s2::Message& msg) -> std::optional<s2::Message> {
          // S10F3: terminal display from equipment.
          if (msg.stream == 10 && msg.function == 3) {
            auto td = gem::parse_s10f3(msg);
            if (td) logfn("TERMINAL[" + std::to_string(td->tid) + "] " + td->text);
            return gem::s10f4_terminal_display_ack(gem::TerminalAck::Accepted);
          }
          // S6F11: event report from equipment.
          if (msg.stream == 6 && msg.function == 11) {
            auto er = gem::parse_s6f11(msg);
            if (er) {
              logfn("EVENT CEID=" + std::to_string(er->ceid) + " (" +
                    std::to_string(er->reports.size()) + " reports)");
              for (const auto& r : er->reports) {
                std::string s = "  RPTID " + std::to_string(r.rptid) + ":";
                for (const auto& v : r.values) s += " " + s2::to_sml(v);
                logfn(s);
              }
            }
            return gem::s6f12_event_report_ack(gem::EventReportAck::Accept);
          }
          // S6F25: spool-data-ready notification (E30 §6.22).
          if (msg.stream == 6 && msg.function == 25) {
            auto n = gem::parse_s6f25(msg);
            logfn("SPOOL READY: " + std::to_string(n.value_or(0)) + " queued messages");
            return gem::s6f26_spool_data_ready_ack(gem::EventReportAck::Accept);
          }
          // S16F9: E40 PRJob alert (one-way, E->H).
          if (msg.stream == 16 && msg.function == 9) {
            auto a = gem::parse_s16f9(msg);
            if (a) {
              logfn("PJ ALERT " + a->prjobid + " state=" +
                    gem::process_job_state_name(a->prjobstate));
            }
            if (msg.reply_expected) return s2::Message(16, 0, false);
            return std::nullopt;
          }
          // S5F1: alarm send from equipment.
          if (msg.stream == 5 && msg.function == 1) {
            auto a = gem::parse_s5f1(msg);
            if (a) {
              logfn(std::string("ALARM ") + ((a->alcd & 0x80) ? "SET" : "CLR") +
                    " ALID=" + std::to_string(a->alid) +
                    " cat=" + std::to_string(a->alcd & 0x7F) + " \"" + a->altx + "\"");
            }
            return gem::s5f2_alarm_ack(gem::AlarmAck::Accept);
          }
          if (msg.reply_expected) return s2::Message(msg.stream, 0, false);
          return std::nullopt;
        });

    auto seq = std::make_shared<Sequence>();
    auto svids = std::make_shared<std::vector<uint32_t>>();
    auto pacing = std::make_shared<asio::steady_timer>(io);

    auto fail = [conn, logfn](const char* where, std::error_code ec) {
      logfn(std::string(where) + " failed: " + ec.message());
      conn->close(std::string(where) + " failed");
    };

    auto pause_then = [pacing](std::chrono::milliseconds dt, std::function<void()> cb) {
      pacing->expires_after(dt);
      pacing->async_wait([cb = std::move(cb)](std::error_code ec) {
        if (!ec) cb();
      });
    };

    // 1. Establish communications.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s1f13_establish_comms(kHostMdln, kHostRev),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F13", ec); return; }
                           logfn("S1F14 reply: " + reply.sml());
                           next();
                         });
    });

    // 2. Request ONLINE.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s1f17_request_online(),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F17", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S1F18 ONLACK=" + (a ? std::to_string(*a) : "?"));
                           next();
                         });
    });

    // 2a. Ask the equipment to self-report its GEM compliance.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s1f19_get_gem_compliance_request(),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F19", ec); return; }
                           auto parsed = gem::parse_s1f20(reply);
                           if (parsed) {
                             logfn("S1F20 SOFTREV=" + parsed->softrev +
                                   " TYPE=" + parsed->equipment_type +
                                   " (" + std::to_string(parsed->capabilities.size()) +
                                   " capabilities)");
                             for (const auto& c : parsed->capabilities) {
                               logfn("  CCODE " + std::to_string(c.ccode) + " " + c.cdesc);
                             }
                           }
                           next();
                         });
    });

    // 2b. Discover DVIDs.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s1f21_data_variable_namelist_request({}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F21", ec); return; }
                           auto parsed = gem::parse_s1f22(reply);
                           if (parsed) {
                             logfn("S1F22 (" + std::to_string(parsed->size()) + " DVIDs)");
                             for (const auto& dn : *parsed) {
                               logfn("  DVID " + std::to_string(dn.id) + " " + dn.name +
                                     (dn.units.empty() ? "" : " [" + dn.units + "]"));
                             }
                           }
                           next();
                         });
    });

    // 3. Discover SVIDs.
    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
      conn->send_request(gem::s1f11_status_namelist_request({}),
                         [logfn, fail, svids, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F11", ec); return; }
                           auto parsed = gem::parse_s1f12(reply);
                           if (parsed) {
                             for (const auto& sn : *parsed) {
                               svids->push_back(sn.id);
                               logfn("  SVID " + std::to_string(sn.id) + " " + sn.name);
                             }
                           }
                           next();
                         });
    });

    // 4. Read SVID values.
    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
      conn->send_request(gem::s1f3_selected_status_request(*svids),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F3", ec); return; }
                           logfn("S1F4 values: " + reply.sml());
                           next();
                         });
    });

    // 5. EC namelist.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s2f29_ec_namelist_request({}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F29", ec); return; }
                           logfn("S2F30 namelist: " + reply.sml());
                           next();
                         });
    });

    // 6. Define a report covering all SVIDs.
    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
      conn->send_request(gem::s2f33_define_report(kDataIdReports, {{kRptidStatus, *svids}}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F33", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S2F34 DRACK=" + (a ? std::to_string(*a) : "?"));
                           next();
                         });
    });

    // 7. Link CEIDs to the report.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(
          gem::s2f35_link_event_report(kDataIdReports,
                                       {{kCeidProcessStarted, {kRptidStatus}},
                                        {kCeidAlarmSetEvent, {kRptidStatus}},
                                        {kCeidCJExecuting,   {kRptidStatus}},
                                        {kCeidCJCompleted,   {kRptidStatus}}}),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S2F35", ec); return; }
            auto a = gem::ack_byte(reply);
            logfn("S2F36 LRACK=" + (a ? std::to_string(*a) : "?"));
            next();
          });
    });

    // 8. Enable the linked CEIDs.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(
          gem::s2f37_enable_event(true, {kCeidProcessStarted, kCeidAlarmSetEvent,
                                          kCeidCJExecuting, kCeidCJCompleted}),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S2F37", ec); return; }
            auto a = gem::ack_byte(reply);
            logfn("S2F38 ERACK=" + (a ? std::to_string(*a) : "?"));
            next();
          });
    });

    // 9. Host command START -> equipment fires CEID kCeidProcessStarted.
    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
      std::vector<gem::CommandParameter> params = {
          {"LOTID", s2::Item::ascii("LOT-42")},
          {"PPID",  s2::Item::ascii("RECIPE-A")},
      };
      conn->send_request(gem::s2f41_host_command("START", params),
                         [logfn, fail, pause_then, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F41/START", ec); return; }
                           auto r = gem::parse_s2f42(reply);
                           logfn("S2F42 HCACK=" +
                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
                           pause_then(std::chrono::milliseconds(300), next);
                         });
    });

    // 10. List alarm directory.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s5f5_list_alarms_request({}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S5F5", ec); return; }
                           logfn("S5F6 alarms: " + reply.sml());
                           next();
                         });
    });

    // 11. Enable alarm 1 (so the equipment is allowed to send S5F1 for it).
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s5f3_enable_alarm(gem::kAlarmEnableByte, kAlarmChiller),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S5F3", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S5F4 ACKC5=" + (a ? std::to_string(*a) : "?"));
                           next();
                         });
    });

    // 12. Host command FAULT -> equipment sets alarm 1 and emits S5F1 + S6F11.
    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
      conn->send_request(gem::s2f41_host_command("FAULT", {}),
                         [logfn, fail, pause_then, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F41/FAULT", ec); return; }
                           auto r = gem::parse_s2f42(reply);
                           logfn("S2F42 HCACK=" +
                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
                           pause_then(std::chrono::milliseconds(300), next);
                         });
    });

    // 13a. Force the equipment into spool mode (test-only RCMD; stands in
    //      for "the host link has gone down" in the real protocol).
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s2f41_host_command("SPOOL_ON", {}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F41/SPOOL_ON", ec); return; }
                           auto r = gem::parse_s2f42(reply);
                           logfn("S2F42 HCACK=" +
                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
                           next();
                         });
    });

    // 13b. Trigger a START while spooling — the CEID 300 emission should
    //      land in the equipment's spool, not arrive live.
    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
      conn->send_request(gem::s2f41_host_command("START", {}),
                         [logfn, fail, pause_then, next](std::error_code ec,
                                                         const s2::Message& reply) {
                           if (ec) { fail("S2F41/START(spool)", ec); return; }
                           auto r = gem::parse_s2f42(reply);
                           logfn("S2F42 HCACK=" +
                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?") +
                                 "   (CEID 300 should be spooled, not delivered live)");
                           pause_then(std::chrono::milliseconds(150), next);
                         });
    });

    // 13c. Drop the spool flag back to off.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s2f41_host_command("SPOOL_OFF", {}),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S2F41/SPOOL_OFF", ec); return; }
                           auto r = gem::parse_s2f42(reply);
                           logfn("S2F42 HCACK=" +
                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
                           next();
                         });
    });

    // 13d. Ask the equipment to transmit the spooled queue.
    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
      conn->send_request(gem::s6f23_request_spool_data(gem::SpoolRequestCode::Transmit),
                         [logfn, fail, pause_then, next](std::error_code ec,
                                                         const s2::Message& reply) {
                           if (ec) { fail("S6F23", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S6F24 RSDA=" + (a ? std::to_string(*a) : "?") +
                                 "   (expect spooled S6F11 to arrive next)");
                           pause_then(std::chrono::milliseconds(300), next);
                         });
    });

    // 14. List recipes.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s7f19_current_eppd_request(),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S7F19", ec); return; }
                           auto list = gem::parse_s7f20(reply);
                           if (list) {
                             logfn("S7F20: " + std::to_string(list->size()) + " recipes");
                             for (const auto& p : *list) logfn("  PPID " + p);
                           }
                           next();
                         });
    });

    // 14. Fetch a single recipe body.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s7f5_process_program_request("RECIPE-A"),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S7F5", ec); return; }
                           auto pp = gem::parse_s7f6(reply);
                           if (pp)
                             logfn("S7F6 PPID=" + pp->ppid + " body=" +
                                   std::to_string(pp->ppbody.size()) + " bytes");
                           next();
                         });
    });

    // ---- E40/E94: create a PJ, wrap it in a CJ, start the CJ ----------

    // 14a. S16F11 PRJobCreate PJ-1 with recipe RECIPE-A and 2 wafers.
    // Uses the full E40-0705 body (MF=Substrate, RecipeOnly, no extras).
    seq->steps.push_back([conn, logfn, fail](auto next) {
      gem::PRJobCreateRequest pj_req{
          "PJ-1", gem::MaterialFlag::Substrate,
          gem::ProcessRecipeMethod::RecipeOnly,
          gem::RecipeSpec{"RECIPE-A", {}},
          {"WFR-1", "WFR-2"}, {}};
      conn->send_request(
          gem::s16f11_pr_job_create(pj_req),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S16F11", ec); return; }
            auto a = gem::ack_byte(reply);
            logfn("S16F12 HCACK=" + (a ? std::to_string(*a) : "?"));
            next();
          });
    });
    // 14b. S14F9 CreateControlJob CJ-1 containing [PJ-1].
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(
          gem::s14f9_create_control_job("CJ-1", {"PJ-1"}),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S14F9", ec); return; }
            auto r = gem::parse_s14f10(reply);
            if (r)
              logfn("S14F10 CJ=" + r->ctljobid + " OBJACK=" +
                    std::to_string(static_cast<int>(r->ack)));
            next();
          });
    });
    // 14c. S16F27 CJSTART CJ-1 -> equipment cascades the PJ through every
    //      state, host sees a burst of S16F9 alerts + S6F11(CEID=400/401).
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(
          gem::s16f27_cj_command("CJ-1", "CJSTART"),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S16F27", ec); return; }
            auto a = gem::ack_byte(reply);
            logfn("S16F28 HCACK=" + (a ? std::to_string(*a) : "?"));
            next();
          });
    });
    // 14d. Pace 200ms so the asynchronous S16F9 / S6F11 alerts arrive
    //      before we move on to terminal display.
    seq->steps.push_back([pause_then](auto next) {
      pause_then(std::chrono::milliseconds(200), [next] { next(); });
    });
    // 14e. Tidy up: delete the CJ via S14F11. The contained PJs are now
    //      ProcessComplete; the equipment leaves them in the store until
    //      explicitly dequeued (which can be wired similarly via S16F13).
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(
          gem::s14f11_delete_control_job("CJ-1"),
          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
            if (ec) { fail("S14F11", ec); return; }
            auto a = gem::ack_byte(reply);
            logfn("S14F12 OBJACK=" + (a ? std::to_string(*a) : "?"));
            next();
          });
    });

    // 15. Send a terminal display to the equipment.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s10f1_terminal_display_single(0, "Hello equipment!"),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S10F1", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S10F2 ACKC10=" + (a ? std::to_string(*a) : "?"));
                           next();
                         });
    });

    // 16. Request OFFLINE.
    seq->steps.push_back([conn, logfn, fail](auto next) {
      conn->send_request(gem::s1f15_request_offline(),
                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
                           if (ec) { fail("S1F15", ec); return; }
                           auto a = gem::ack_byte(reply);
                           logfn("S1F16 OFLACK=" + (a ? std::to_string(*a) : "?"));
                           next();
                         });
    });

    // 17. Separate.
    seq->steps.push_back([conn, logfn](auto) {
      logfn("flow complete; separating");
      conn->separate();
    });

    conn->set_selected_handler([seq]() { seq->run(); });
  });

  client.start();
  io.run();
  std::cout << "[host]  exiting" << std::endl;
  return 0;
}