// Port of tai.py:9302-9985: PlexerController family, plexer_show spec validation, PlexerFlow.
#include "mplex_plexer_flow.h"

#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/un.h>
#include <unistd.h>

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <sstream>
#include <string_view>

#include "mplex_common.h"
#include "mplex_py.h"

namespace detz::mplex_flow {

namespace py = detz::mplex::py;
using detz::mplex::to_ustr;
using detz::mplex::UStr;

const std::vector<std::string> PLEXER_FLOW_TYPES = {"choice", "text", "info"};
const std::vector<std::string> PLEXER_FLOW_KINDS = {"message", "choice", "text"};

namespace {

// ---- Python value helpers ---------------------------------------------------------------

std::string repr_json(const Json& v) {
  switch (v.kind()) {
    case Json::Kind::Null: return "None";
    case Json::Kind::Bool: return v.as_bool() ? "True" : "False";
    case Json::Kind::Int: return std::to_string(v.as_int());
    case Json::Kind::Float: return py::format_float(v.as_float());
    case Json::Kind::String: return py::repr(v.as_string());
    case Json::Kind::Array: {
      std::string out = "[";
      bool first = true;
      for (const auto& item : v.as_array()) {
        if (!first) out += ", ";
        first = false;
        out += repr_json(item);
      }
      return out + "]";
    }
    case Json::Kind::Object: {
      std::string out = "{";
      bool first = true;
      for (const auto& item : v.as_object()) {
        if (!first) out += ", ";
        first = false;
        out += py::repr(item.first) + ": " + repr_json(item.second);
      }
      return out + "}";
    }
  }
  return "None";
}

// str(value)
std::string str_json(const Json& v) { return v.is_string() ? v.as_string() : repr_json(v); }

// "%d" in error texts
std::string d(long long n) { return std::to_string(n); }

bool is_scalar(const Json& v) { return v.is_string() || v.is_number() || v.is_bool() || v.is_null(); }

// int(value) with Python's TypeError/ValueError turned into nullopt.
std::optional<long long> py_int(const Json& v) {
  switch (v.kind()) {
    case Json::Kind::Bool: return v.as_bool() ? 1 : 0;
    case Json::Kind::Int: return v.as_int();
    case Json::Kind::Float: {
      double f = v.as_float();
      if (f != f || f > 9e18 || f < -9e18) return std::nullopt;
      return static_cast<long long>(f);
    }
    case Json::Kind::String:
      try {
        return py::to_int(v.as_string());
      } catch (const std::exception&) {
        return std::nullopt;
      }
    default: return std::nullopt;
  }
}

const Json null_json;

const Json& jget(const Json& obj, std::string_view key) {
  const Json* hit = obj.get(std::string(key));
  return hit ? *hit : null_json;
}

Json jget_or(const Json& obj, const std::string& key, const Json& fallback) {
  const Json* hit = obj.get(key);
  return hit ? *hit : fallback;
}

bool in_list(const std::vector<std::string>& list, const std::string& value) {
  return std::find(list.begin(), list.end(), value) != list.end();
}

std::string errno_text(int err) {
  return "[Errno " + std::to_string(err) + "] " + std::strerror(err);
}

std::string cap300(const std::string& text) { return py::slice(text, 0, 300); }

std::string universal_newlines(const std::string& raw) {
  std::string out;
  out.reserve(raw.size());
  for (size_t i = 0; i < raw.size(); ++i) {
    if (raw[i] == '\r') {
      out.push_back('\n');
      if (i + 1 < raw.size() && raw[i + 1] == '\n') ++i;
    } else {
      out.push_back(raw[i]);
    }
  }
  return out;
}

std::string decode_replace(const std::string& raw) { return detz::mplex::to_utf8(to_ustr(raw)); }

// "text" % shlex-quoted arg, for the reader fragments: handles %% and a single %s.
std::string format_s(const std::string& fmt, const std::string& arg) {
  std::string out;
  for (size_t i = 0; i < fmt.size(); ++i) {
    if (fmt[i] == '%' && i + 1 < fmt.size()) {
      if (fmt[i + 1] == '%') {
        out.push_back('%');
        ++i;
        continue;
      }
      if (fmt[i + 1] == 's') {
        out += arg;
        ++i;
        continue;
      }
    }
    out.push_back(fmt[i]);
  }
  return out;
}

std::string temp_dir() {
  for (const char* name : {"TMPDIR", "TEMP", "TMP"}) {
    const char* v = std::getenv(name);
    if (v && *v) return v;
  }
  return "/tmp";
}

// tempfile.mkstemp(prefix="tai-flow-", suffix=...): returns (fd, path); fd -1 on failure.
std::pair<int, std::string> make_temp(const std::string& suffix) {
  std::string pattern = temp_dir() + "/tai-flow-XXXXXX" + suffix;
  std::vector<char> buf(pattern.begin(), pattern.end());
  buf.push_back('\0');
  int fd = ::mkstemps(buf.data(), static_cast<int>(suffix.size()));
  return {fd, std::string(buf.data())};
}

}  // namespace

std::string plexer_dir(const std::string& home) {
  std::string path = home + "/" + PLEXER_DIR_NAME;
  std::string partial;
  size_t pos = 0;
  while (pos <= path.size()) {
    size_t next = path.find('/', pos);
    if (next == std::string::npos) next = path.size();
    partial = path.substr(0, next);
    if (!partial.empty()) ::mkdir(partial.c_str(), 0777);
    pos = next + 1;
  }
  ::chmod(path.c_str(), 0700);
  return path;
}

// ---- PlexerController ---------------------------------------------------------------------

void PlexerController::type_text(const std::string& text, double delay, bool enter) {
  UStr chars = to_ustr(text);
  for (wchar_t ch : chars) {
    send_keys(detz::mplex::to_utf8(ch));
    ::usleep(static_cast<useconds_t>(delay * 1e6));
  }
  if (enter) send_keys("", true);
}

// ---- NativePlexerController -----------------------------------------------------------------

NativePlexerController::NativePlexerController(const std::string& socket_path_in, const std::optional<std::string>& pane_in)
    : socket_path(socket_path_in), pane(pane_in) {
  kind = "native";
}

Json NativePlexerController::call(const Json& payload_in) {
  Json payload = payload_in;
  if (pane && !pane->empty()) payload.set("pane", Json::string(*pane));
  int sock = ::socket(AF_UNIX, SOCK_STREAM, 0);
  struct timeval tv {10, 0};
  if (sock >= 0) {
    ::setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
    ::setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);
  }
  struct sockaddr_un addr {};
  addr.sun_family = AF_UNIX;
  int err = 0;
  if (sock < 0) {
    err = errno;
  } else if (socket_path.size() >= sizeof(addr.sun_path)) {
    err = ENAMETOOLONG;
  } else {
    std::memcpy(addr.sun_path, socket_path.c_str(), socket_path.size() + 1);
    if (::connect(sock, reinterpret_cast<sockaddr*>(&addr), sizeof addr) != 0) err = errno;
  }
  if (err) {
    if (sock >= 0) ::close(sock);
    throw PlexerError("cannot reach native plexer backend: " + cap300(err == EAGAIN ? "timed out" : errno_text(err)));
  }
  std::string chunks;
  try {
    std::string line = payload.dumps() + "\n";
    size_t done = 0;
    while (done < line.size()) {
      ssize_t n = ::send(sock, line.data() + done, line.size() - done, MSG_NOSIGNAL);
      if (n < 0) {
        if (errno == EINTR) continue;
        int e = errno;
        throw PlexerError("native plexer backend read/write failed: " +
                          cap300(e == EAGAIN ? "timed out" : errno_text(e)));
      }
      done += static_cast<size_t>(n);
    }
    for (;;) {
      char chunk[65536];
      ssize_t n = ::recv(sock, chunk, sizeof chunk, 0);
      if (n < 0) {
        if (errno == EINTR) continue;
        int e = errno;
        throw PlexerError("native plexer backend read/write failed: " +
                          cap300(e == EAGAIN ? "timed out" : errno_text(e)));
      }
      if (n == 0) break;
      chunks.append(chunk, static_cast<size_t>(n));
      if (chunk[n - 1] == '\n') break;
    }
  } catch (...) {
    ::close(sock);
    throw;
  }
  ::close(sock);
  std::string raw = py::strip(decode_replace(chunks));
  Json reply = Json::object();
  if (!raw.empty()) {
    try {
      reply = Json::loads(raw);
    } catch (const std::exception&) {
      throw PlexerError("native plexer backend sent an unparseable reply");
    }
  }
  if (!reply.is_object()) throw PlexerError("native plexer backend refused the command");
  const Json* ok = reply.get("ok");
  if (!(ok && ok->truthy())) {
    const Json* error = reply.get("error");
    if (error && error->truthy()) throw PlexerError(str_json(*error));
    throw PlexerError("native plexer backend refused the command");
  }
  return jget(reply, "data");
}

Json NativePlexerController::send_keys(const std::string& text, bool enter) {
  Json p = Json::object();
  p.set("cmd", Json::string("send"));
  p.set("text", Json::string(text));
  p.set("enter", Json::boolean(enter));
  return call(p);
}

Json NativePlexerController::read_pane(int lines) {
  Json p = Json::object();
  p.set("cmd", Json::string("read"));
  p.set("lines", Json::integer(lines));
  return call(p);
}

Json NativePlexerController::status() {
  Json p = Json::object();
  p.set("cmd", Json::string("status"));
  return call(p);
}

Json NativePlexerController::ask(const Json& screen, double timeout) {
  Json show = Json::object();
  show.set("cmd", Json::string("show"));
  show.set("screen", screen);
  show.set("timeout", Json::number(timeout));
  Json handle = call(show);
  if (!handle.is_object() || !handle.has("id")) throw PlexerError("native plexer backend sent no flow id");
  Json flow_id = jget(handle, "id");
  double deadline = py::monotonic() + std::max(1.0, timeout);
  for (;;) {
    Json q = Json::object();
    q.set("cmd", Json::string("result"));
    q.set("id", flow_id);
    Json reply = call(q);
    const Json* done = reply.is_object() ? reply.get("done") : nullptr;
    if (done && done->truthy()) {
      const Json* status = reply.get("status");
      std::string st = (status && status->is_string()) ? status->as_string() : "";
      if (st == "ok") {
        Json out = Json::object();
        out.set("status", Json::string("ok"));
        out.set("value", jget(reply, "value"));
        return out;
      }
      if (st == "cancelled" || st == "timeout") {
        Json out = Json::object();
        out.set("status", Json::string(st));
        return out;
      }
      std::string shown = (status && status->truthy()) ? str_json(*status) : "unknown";
      throw PlexerError("flow " + str_json(flow_id) + " ended: " + shown);
    }
    if (py::monotonic() >= deadline) {
      try {
        Json c = Json::object();
        c.set("cmd", Json::string("cancel"));
        c.set("id", flow_id);
        call(c);
      } catch (const PlexerError&) {
      }
      Json out = Json::object();
      out.set("status", Json::string("timeout"));
      return out;
    }
    ::usleep(static_cast<useconds_t>(PLEXER_FLOW_POLL * 1e6));
  }
}

// ---- TmuxPlexerController ---------------------------------------------------------------------

TmuxPlexerController::TmuxPlexerController(const std::string& pane_in) : pane(pane_in) { kind = "tmux"; }

std::string TmuxPlexerController::tmux(const std::vector<std::string>& args) {
  std::vector<std::string> argv = {"tmux"};
  argv.insert(argv.end(), args.begin(), args.end());
  py::RunResult done;
  try {
    done = py::run_argv(argv, true, true, 15);
  } catch (const std::exception& exc) {
    throw PlexerError("tmux call failed: " + cap300(exc.what()));
  }
  if (done.timed_out) {
    std::string cmd = "[";
    for (size_t i = 0; i < argv.size(); ++i) cmd += (i ? ", " : "") + py::repr(argv[i]);
    cmd += "]";
    throw PlexerError("tmux call failed: " + cap300("Command '" + cmd + "' timed out after 15 seconds"));
  }
  if (done.returncode != 0)
    throw PlexerError("tmux error: " + py::slice(py::strip(universal_newlines(decode_replace(done.err))), 0, 300));
  return universal_newlines(decode_replace(done.out));
}

Json TmuxPlexerController::send_keys(const std::string& text, bool enter) {
  if (!text.empty()) tmux({"send-keys", "-t", pane, "-l", text});
  if (enter) tmux({"send-keys", "-t", pane, "Enter"});
  return Json::boolean(true);
}

Json TmuxPlexerController::read_pane(int lines) {
  return Json::string(tmux({"capture-pane", "-p", "-t", pane, "-S", "-" + std::to_string(std::max(1, lines))}));
}

Json TmuxPlexerController::status() {
  std::string info = tmux({"list-panes", "-t", pane, "-F", "#{session_name}:#{window_index}.#{pane_index} #{pane_current_command}"});
  Json out = Json::object();
  out.set("backend", Json::string("tmux"));
  out.set("pane", Json::string(pane));
  out.set("info", Json::string(py::strip(info)));
  return out;
}

Json TmuxPlexerController::ask(const Json& screen, double timeout) {
  const Json& kind_json = jget(screen, "kind");
  std::string k = kind_json.is_string() ? kind_json.as_string() : "";
  if (kind_json.is_string()) {
    if (k == "choice") return ask_choice(screen, timeout);
    if (k == "text") return ask_text(screen, timeout);
    if (k == "message") return ask_message(screen, timeout);
  }
  throw PlexerError("unknown screen kind " + repr_json(kind_json));
}

std::string TmuxPlexerController::ask_result_path() {
  auto made = make_temp(".answer");
  if (made.first >= 0) ::close(made.first);
  ::unlink(made.second.c_str());
  return made.second;
}

std::optional<std::string> TmuxPlexerController::await_answer(const std::string& path, double budget) {
  double deadline = py::monotonic() + std::max(0.0, budget);
  for (;;) {
    std::ifstream in(path, std::ios::binary);
    if (in) {
      std::stringstream ss;
      ss << in.rdbuf();
      return decode_replace(ss.str());
    }
    if (py::monotonic() >= deadline) return std::nullopt;
    ::usleep(50000);
  }
}

void TmuxPlexerController::ask_dismiss() {
  try {
    py::run_argv({"tmux", "display-popup", "-C"}, true, true, 5);
  } catch (const std::exception&) {
  }
}

TmuxPlexerController::RunOutcome TmuxPlexerController::ask_run(const std::vector<std::string>& argv, const std::string& path,
                                                              double timeout) {
  std::vector<std::string> full = {"tmux"};
  full.insert(full.end(), argv.begin(), argv.end());
  py::RunResult done;
  try {
    done = py::run_argv(full, true, true, std::max(1.0, timeout));
  } catch (const std::exception& exc) {
    throw PlexerError("tmux call failed: " + cap300(exc.what()));
  }
  RunOutcome out;
  if (done.timed_out) {
    ask_dismiss();
    out.timed_out = true;
    out.content = "timeout";
    return out;
  }
  std::string err = py::strip(universal_newlines(decode_replace(done.err)));
  if (done.returncode != 0 && !err.empty())
    throw PlexerError("tmux " + argv[0] + " failed: " + py::slice(err, 0, 300));
  if (done.returncode != 0) return out;
  out.content = await_answer(path);
  return out;
}

Json TmuxPlexerController::ask_choice(const Json& screen, double timeout) {
  const Json& opts_json = jget(screen, "options");
  std::vector<std::string> options;
  if (opts_json.truthy() && opts_json.is_array())
    for (const auto& o : opts_json.as_array()) options.push_back(str_json(o));
  std::string path = ask_result_path();
  RunOutcome raw;
  try {
    const Json& title = jget(screen, "title");
    std::vector<std::string> argv = {"display-menu", "-T", title.truthy() ? str_json(title) : "tai"};
    static const std::string keys = "123456789abcdefghijklmnopqrstuvwxyz";
    for (size_t index = 0; index < options.size(); ++index) {
      if (index >= keys.size()) throw PlexerError("string index out of range");
      argv.push_back(options[index]);
      argv.push_back(std::string(1, keys[index]));
      argv.push_back("run-shell \"printf '%s' '" + std::to_string(index) + "' > " + py::shlex_quote(path) + "\"");
    }
    raw = ask_run(argv, path, timeout);
  } catch (...) {
    ::unlink(path.c_str());
    throw;
  }
  ::unlink(path.c_str());
  Json out = Json::object();
  if (raw.content && *raw.content == "timeout") {
    out.set("status", Json::string("timeout"));
    return out;
  }
  std::string stripped = raw.content ? py::strip(*raw.content) : "";
  if (!raw.content || !py::all_digits(to_ustr(stripped))) {
    out.set("status", Json::string("cancelled"));
    return out;
  }
  long long index = py::to_int(stripped);
  if (index >= 0 && index < static_cast<long long>(options.size())) {
    out.set("status", Json::string("ok"));
    out.set("value", Json::integer(index));
    return out;
  }
  out.set("status", Json::string("cancelled"));
  return out;
}

TmuxPlexerController::RunOutcome TmuxPlexerController::ask_popup(const std::string& title, const std::string& body,
                                                                const std::string& reader, double timeout) {
  auto made = make_temp(".prompt");
  if (made.first < 0) throw PlexerError("cannot stage prompt text: " + errno_text(errno));
  std::string prompt_path = made.second;
  {
    size_t done = 0;
    while (done < body.size()) {
      ssize_t n = ::write(made.first, body.data() + done, body.size() - done);
      if (n < 0) {
        if (errno == EINTR) continue;
        std::string text = errno_text(errno);
        ::close(made.first);
        throw PlexerError("cannot stage prompt text: " + cap300(text));
      }
      done += static_cast<size_t>(n);
    }
    ::close(made.first);
  }
  std::string path = ask_result_path();
  RunOutcome raw;
  try {
    std::string command = "cat " + py::shlex_quote(prompt_path) + "; " + format_s(reader, py::shlex_quote(path));
    raw = ask_run({"display-popup", "-w", "62", "-h", "10", "-T", title.empty() ? "tai" : title, "-E", command}, path, timeout);
  } catch (...) {
    ::unlink(prompt_path.c_str());
    ::unlink(path.c_str());
    throw;
  }
  ::unlink(prompt_path.c_str());
  ::unlink(path.c_str());
  return raw;
}

Json TmuxPlexerController::ask_text(const Json& screen, double timeout) {
  const Json& text = jget(screen, "text");
  std::string body = (text.truthy() ? str_json(text) : std::string()) + "\n\n> ";
  const Json& title = jget(screen, "title");
  RunOutcome raw = ask_popup(title.truthy() ? str_json(title) : "", body, "read -r TAI_V && printf '%%s' \"$TAI_V\" > %s", timeout);
  Json out = Json::object();
  if (raw.content && *raw.content == "timeout") {
    out.set("status", Json::string("timeout"));
    return out;
  }
  if (!raw.content) {
    out.set("status", Json::string("cancelled"));
    return out;
  }
  out.set("status", Json::string("ok"));
  out.set("value", Json::string(py::slice(*raw.content, 0, PLEXER_FLOW_ANSWER_MAX)));
  return out;
}

Json TmuxPlexerController::ask_message(const Json& screen, double timeout) {
  const Json& text = jget(screen, "text");
  std::string body = (text.truthy() ? str_json(text) : std::string()) + "\n\n[Enter] ";
  const Json& title = jget(screen, "title");
  RunOutcome raw = ask_popup(title.truthy() ? str_json(title) : "", body, "read -r _ && printf ok > %s", timeout);
  Json out = Json::object();
  if (raw.content && *raw.content == "timeout") {
    out.set("status", Json::string("timeout"));
    return out;
  }
  if (!raw.content) {
    out.set("status", Json::string("cancelled"));
    return out;
  }
  out.set("status", Json::string("ok"));
  out.set("value", Json::boolean(true));
  return out;
}

std::unique_ptr<PlexerController> PlexerControllerFactory::detect() {
  const char* socket_path = std::getenv(PLEXER_SOCKET_ENV);
  if (socket_path && *socket_path) {
    const char* pane = std::getenv(PLEXER_PANE_ENV);
    return std::make_unique<NativePlexerController>(socket_path, pane ? std::optional<std::string>(pane) : std::nullopt);
  }
  const char* pane = std::getenv("TMUX_PANE");
  if (pane && *pane) return std::make_unique<TmuxPlexerController>(pane);
  return nullptr;
}

// ---- validation --------------------------------------------------------------------------------

std::pair<std::string, std::string> validate_flow_id(const Json& raw, const std::string& what) {
  std::string text = py::strip(raw.truthy() ? str_json(raw) : std::string());
  if (text.empty()) return {"", what + " id must be a non-empty string"};
  if (py::len(text) > static_cast<size_t>(PLEXER_FLOW_ID_MAX))
    return {"", what + " id " + py::repr(py::slice(text, 0, 72)) + " is longer than " + d(PLEXER_FLOW_ID_MAX) + " chars"};
  for (wchar_t ch : to_ustr(text))
    if (py::isspace(ch)) return {"", what + " id " + py::repr(text) + " must not contain whitespace"};
  return {text, ""};
}

std::pair<std::string, std::string> validate_flow_text(const Json& raw, const std::string& what, size_t limit) {
  if (!raw.is_string()) return {"", what + " must be a string"};
  if (py::len(raw.as_string()) > limit) return {"", what + " is longer than " + d(static_cast<long long>(limit)) + " chars"};
  return {raw.as_string(), ""};
}

std::pair<Json, std::string> validate_flow_options(const Json& raw, const std::string& what) {
  if (!raw.is_array() || raw.as_array().empty())
    return {Json::array(), what + " needs 1 to " + d(PLEXER_FLOW_OPTIONS_MAX) + " options"};
  if (raw.as_array().size() > static_cast<size_t>(PLEXER_FLOW_OPTIONS_MAX))
    return {Json::array(), what + " has " + d(static_cast<long long>(raw.as_array().size())) + " options, at most " +
                               d(PLEXER_FLOW_OPTIONS_MAX)};
  Json options = Json::array();
  long long pos = 0;
  for (const auto& item : raw.as_array()) {
    Json label, value;
    if (item.is_string()) {
      label = item;
      value = item;
    } else if (item.is_object()) {
      label = jget(item, "label");
      value = jget_or(item, "value", jget(item, "label"));
    } else {
      return {Json::array(), what + " option " + d(pos + 1) + " must be a string or {label, value}"};
    }
    if (!label.is_string() || py::strip(label.as_string()).empty())
      return {Json::array(), what + " option " + d(pos + 1) + " needs a non-empty label"};
    if (py::len(label.as_string()) > static_cast<size_t>(PLEXER_FLOW_LABEL_MAX))
      return {Json::array(), what + " option " + d(pos + 1) + " label is longer than " + d(PLEXER_FLOW_LABEL_MAX) + " chars"};
    if (!is_scalar(value)) return {Json::array(), what + " option " + d(pos + 1) + " value must be a JSON scalar"};
    Json entry = Json::object();
    entry.set("label", label);
    entry.set("value", value);
    options.push(entry);
    ++pos;
  }
  return {options, ""};
}

std::pair<Json, std::string> validate_flow_condition(const Json& raw, const std::string& what,
                                                     const std::vector<std::string>& known) {
  if (raw.is_null()) return {Json::object(), ""};
  if (!raw.is_object() || raw.as_object().empty())
    return {Json::object(), what + " show_if must be a non-empty {field id: expected} object"};
  Json clauses = Json::object();
  for (const auto& entry : raw.as_object()) {
    const std::string& key = entry.first;
    const Json& expected = entry.second;
    if (!in_list(known, key)) return {Json::object(), what + " show_if refers to unknown field " + py::repr(key)};
    Json accepted = expected.is_array() ? expected : Json::array({expected});
    if (accepted.as_array().empty())
      return {Json::object(), what + " show_if for " + py::repr(key) + " needs at least one expected value"};
    for (const auto& value : accepted.as_array())
      if (!is_scalar(value)) return {Json::object(), what + " show_if for " + py::repr(key) + " must hold JSON scalars"};
    clauses.set(key, accepted);
  }
  return {clauses, ""};
}

namespace {

using Fail = std::pair<Json, std::string>;

Fail fail(const std::string& reason) { return {Json(), reason}; }

}  // namespace

std::pair<Json, std::string> validate_flow_spec(const Json& spec) {
  if (!spec.is_object()) return fail("spec must be a JSON object");
  Json version = jget_or(spec, "v", Json::integer(PLEXER_FLOW_VERSION));
  if (!version.equals(Json::integer(PLEXER_FLOW_VERSION)))
    return fail("spec v must be " + d(PLEXER_FLOW_VERSION) + ", got " + repr_json(version));
  auto [title, error] = validate_flow_text(jget_or(spec, "title", Json::string("")), "title", PLEXER_FLOW_TITLE_MAX);
  if (!error.empty()) return fail(error);
  auto timeout_opt = py_int(jget_or(spec, "timeout", Json::integer(PLEXER_FLOW_TIMEOUT_DEFAULT)));
  if (!timeout_opt) return fail("timeout must be an integer number of seconds");
  long long timeout = *timeout_opt;
  if (!(PLEXER_FLOW_TIMEOUT_MIN <= timeout && timeout <= PLEXER_FLOW_TIMEOUT_MAX))
    return fail("timeout must be " + d(PLEXER_FLOW_TIMEOUT_MIN) + " to " + d(PLEXER_FLOW_TIMEOUT_MAX) + " seconds");
  const Json& raw_screens = jget(spec, "screens");
  if (!raw_screens.is_array() || raw_screens.as_array().empty()) return fail("screens must be a non-empty list");
  if (raw_screens.as_array().size() > static_cast<size_t>(PLEXER_FLOW_SCREENS_MAX))
    return fail(d(static_cast<long long>(raw_screens.as_array().size())) + " screens, at most " + d(PLEXER_FLOW_SCREENS_MAX));
  Json screens = Json::array();
  std::vector<std::string> screen_ids, field_ids;
  long long pos = 0;
  for (const auto& item : raw_screens.as_array()) {
    std::string what = "screen " + d(pos + 1);
    ++pos;
    if (!item.is_object()) return fail(what + " must be an object");
    auto [ident, e1] = validate_flow_id(jget(item, "id"), what);
    if (!e1.empty()) return fail(e1);
    if (in_list(screen_ids, ident)) return fail("duplicate screen id " + py::repr(ident));
    screen_ids.push_back(ident);
    auto [title_s, e2] = validate_flow_text(jget_or(item, "title", Json::string("")), ident + " title", PLEXER_FLOW_TITLE_MAX);
    if (!e2.empty()) return fail(e2);
    auto [body, e3] = validate_flow_text(jget_or(item, "body", Json::string("")), ident + " body", PLEXER_FLOW_TEXT_MAX);
    if (!e3.empty()) return fail(e3);
    Json raw_fields = jget_or(item, "fields", Json::array());
    if (!raw_fields.is_array()) return fail(ident + " fields must be a list");
    if (raw_fields.as_array().size() > static_cast<size_t>(PLEXER_FLOW_FIELDS_MAX))
      return fail(ident + " has " + d(static_cast<long long>(raw_fields.as_array().size())) + " fields, at most " +
                  d(PLEXER_FLOW_FIELDS_MAX));
    Json fields = Json::array();
    long long fpos = 0;
    for (const auto& field : raw_fields.as_array()) {
      std::string fwhat = ident + " field " + d(fpos + 1);
      ++fpos;
      if (!field.is_object()) return fail(fwhat + " must be an object");
      Json kind = jget(field, "type");
      if (!(kind.is_string() && in_list(PLEXER_FLOW_TYPES, kind.as_string()))) {
        std::string listed;
        for (size_t i = 0; i < PLEXER_FLOW_TYPES.size(); ++i) listed += (i ? "/" : "") + PLEXER_FLOW_TYPES[i];
        return fail(fwhat + " type must be one of " + listed + ", got " + repr_json(kind));
      }
      auto [fid, e4] = validate_flow_id(jget(field, "id"), fwhat);
      if (!e4.empty()) return fail(e4);
      if (in_list(field_ids, fid)) return fail("duplicate field id " + py::repr(fid));
      field_ids.push_back(fid);
      auto [label, e5] = validate_flow_text(jget_or(field, "label", Json::string("")), fid + " label", PLEXER_FLOW_LABEL_MAX);
      if (!e5.empty()) return fail(e5);
      Json entry = Json::object();
      entry.set("id", Json::string(fid));
      entry.set("type", kind);
      entry.set("label", Json::string(label));
      entry.set("show_if", jget(field, "show_if"));
      if (kind.as_string() == "choice") {
        auto [options, e6] = validate_flow_options(jget(field, "options"), fid);
        if (!e6.empty()) return fail(e6);
        entry.set("options", options);
        auto def = py_int(jget_or(field, "default", Json::integer(0)));
        if (!def) return fail(fid + " default must be an option index");
        long long count = static_cast<long long>(options.as_array().size());
        if (!(0 <= *def && *def < count))
          return fail(fid + " default " + d(*def) + " is outside its " + d(count) + " options");
        entry.set("default", Json::integer(*def));
      } else if (kind.as_string() == "text") {
        auto [initial, e7] = validate_flow_text(jget_or(field, "initial", Json::string("")), fid + " initial", PLEXER_FLOW_ANSWER_MAX);
        if (!e7.empty()) return fail(e7);
        entry.set("initial", Json::string(initial));
      } else {
        auto [text, e8] = validate_flow_text(jget_or(field, "text", Json::string("")), fid + " text", PLEXER_FLOW_TEXT_MAX);
        if (!e8.empty()) return fail(e8);
        entry.set("text", Json::string(text));
      }
      fields.push(entry);
    }
    Json raw_actions = jget_or(item, "actions", Json::array());
    if (!raw_actions.is_array()) return fail(ident + " actions must be a list");
    if (raw_actions.as_array().size() > static_cast<size_t>(PLEXER_FLOW_ACTIONS_MAX))
      return fail(ident + " has " + d(static_cast<long long>(raw_actions.as_array().size())) + " actions, at most " +
                  d(PLEXER_FLOW_ACTIONS_MAX));
    Json actions = Json::array();
    std::vector<std::string> action_ids;
    long long apos = 0;
    for (const auto& action : raw_actions.as_array()) {
      std::string awhat = ident + " action " + d(apos + 1);
      ++apos;
      if (!action.is_object()) return fail(awhat + " must be an object");
      auto [aid, e9] = validate_flow_id(jget(action, "id"), awhat);
      if (!e9.empty()) return fail(e9);
      if (in_list(action_ids, aid)) return fail(ident + " has a duplicate action id " + py::repr(aid));
      action_ids.push_back(aid);
      auto [label, e10] = validate_flow_text(jget_or(action, "label", Json::string("")), aid + " label", PLEXER_FLOW_LABEL_MAX);
      if (!e10.empty()) return fail(e10);
      if (py::strip(label).empty()) return fail(aid + " needs a non-empty label");
      Json entry = Json::object();
      entry.set("id", Json::string(aid));
      entry.set("label", Json::string(label));
      actions.push(entry);
    }
    if (py::strip(body).empty() && fields.as_array().empty() && actions.as_array().empty())
      return fail(ident + " has nothing to show (no body, fields or actions)");
    Json screen = Json::object();
    screen.set("id", Json::string(ident));
    screen.set("title", Json::string(title_s));
    screen.set("body", Json::string(body));
    screen.set("fields", fields);
    screen.set("actions", actions);
    screen.set("next", jget(item, "next"));
    screen.set("show_if", jget(item, "show_if"));
    screens.push(screen);
  }
  std::vector<std::string> known_fields;
  for (const auto& screen : screens.as_array())
    for (const auto& field : jget(screen, "fields").as_array()) {
      const std::string& t = jget(field, "type").as_string();
      if (t == "choice" || t == "text") known_fields.push_back(jget(field, "id").as_string());
    }
  for (auto& screen : screens.as_array()) {
    for (auto& field : screen.get("fields")->as_array()) {
      auto [clauses, err] = validate_flow_condition(jget(field, "show_if"), jget(field, "id").as_string(), known_fields);
      if (!err.empty()) return fail(err);
      field.set("show_if", clauses);
    }
    const std::string sid = jget(screen, "id").as_string();
    {
      auto [clauses, err] = validate_flow_condition(jget(screen, "show_if"), sid, known_fields);
      if (!err.empty()) return fail(err);
      screen.set("show_if", clauses);
    }
    Json target = jget(screen, "next");
    auto known_target = [&](const Json& dest) {
      return dest.is_string() && (dest.as_string() == "$done" || dest.as_string() == "$cancel" || in_list(screen_ids, dest.as_string()));
    };
    if (target.is_null()) {
      screen.set("next", Json());
    } else if (target.is_string()) {
      if (!known_target(target)) return fail(sid + " next refers to unknown screen " + repr_json(target));
      screen.set("next", target);
    } else if (target.is_object()) {
      if (jget(screen, "actions").as_array().empty()) return fail(sid + " next is a map but the screen has no actions");
      for (const auto& entry : target.as_object()) {
        bool found = false;
        for (const auto& action : jget(screen, "actions").as_array())
          if (jget(action, "id").as_string() == entry.first) found = true;
        if (!found) return fail(sid + " next maps unknown action " + py::repr(entry.first));
        if (!known_target(entry.second))
          return fail(sid + " next for " + py::repr(entry.first) + " refers to unknown screen " + repr_json(entry.second));
      }
      screen.set("next", target);
    } else {
      return fail(sid + " next must be a screen id or an {action: screen} map");
    }
  }
  Json start = jget_or(spec, "start", jget(screens.as_array()[0], "id"));
  if (!(start.is_string() && in_list(screen_ids, start.as_string())))
    return fail("start refers to unknown screen " + repr_json(start));
  Json app = Json::object();
  app.set("title", Json::string(title));
  app.set("timeout", Json::integer(timeout));
  app.set("start", start);
  app.set("screens", screens);
  return {app, ""};
}

// ---- PlexerFlow -----------------------------------------------------------------------------------

PlexerFlow::PlexerFlow(const Json& app_in) : app(app_in) {
  for (const auto& screen : app.get("screens")->as_array()) {
    by_id[jget(screen, "id").as_string()] = screen;
    order.push_back(jget(screen, "id").as_string());
  }
}

bool PlexerFlow::condition_holds(const Json& clauses, const Json& answers) {
  if (!clauses.is_object()) return true;
  for (const auto& entry : clauses.as_object()) {
    const Json* have = answers.get(entry.first);
    if (!have) return false;
    bool hit = false;
    for (const auto& accepted : entry.second.as_array())
      if (have->equals(accepted)) hit = true;
    if (!hit) return false;
  }
  return true;
}

std::string PlexerFlow::follow_up(const Json& screen) {
  const Json& target = jget(screen, "next");
  if (target.is_string()) return target.as_string();
  size_t pos = 0;
  const std::string& id = jget(screen, "id").as_string();
  for (size_t i = 0; i < order.size(); ++i)
    if (order[i] == id) pos = i;
  if (pos + 1 < order.size()) return order[pos + 1];
  return "$done";
}

const Json* PlexerFlow::first_askable(const Json& screen) {
  for (const auto& field : jget(screen, "fields").as_array()) {
    const std::string& t = jget(field, "type").as_string();
    if ((t == "choice" || t == "text") && condition_holds(jget(field, "show_if"), answers)) return &field;
  }
  return nullptr;
}

std::string PlexerFlow::screen_text(const Json& screen, const Json* field) {
  auto or_title = [&](const Json& first) {
    const std::string& s = first.as_string();
    return s.empty() ? jget(app, "title").as_string() : s;
  };
  if (field != nullptr && field != first_askable(screen)) {
    const std::string& label = jget(*field, "label").as_string();
    if (!label.empty()) return label;
    return or_title(jget(screen, "title"));
  }
  std::vector<std::string> parts = {or_title(jget(screen, "title")), jget(screen, "body").as_string()};
  for (const auto& item : jget(screen, "fields").as_array())
    if (jget(item, "type").as_string() == "info" && condition_holds(jget(item, "show_if"), answers))
      parts.push_back(jget(item, "text").as_string());
  if (field != nullptr && !jget(*field, "label").as_string().empty()) parts.push_back(jget(*field, "label").as_string());
  std::string out;
  bool first = true;
  for (const auto& part : parts) {
    if (part.empty() || py::strip(part).empty()) continue;
    if (!first) out += "\n\n";
    first = false;
    out += part;
  }
  return out;
}

double PlexerFlow::remaining() const { return deadline - py::monotonic(); }

namespace {

Json outcome_for(const std::string& status, const std::string& at, const Json& answers, const std::string& field = "") {
  Json out = Json::object();
  out.set("status", Json::string(status));
  out.set("at", Json::string(at));
  if (!field.empty()) out.set("field", Json::string(field));
  out.set("answers", answers);
  return out;
}

}  // namespace

Json PlexerFlow::run(PlexerController& controller) {
  deadline = py::monotonic() + static_cast<double>(jget(app, "timeout").as_int());
  std::string current = jget(app, "start").as_string();
  for (;;) {
    ++visits;
    if (visits > PLEXER_FLOW_VISITS_MAX) {
      Json out = Json::object();
      out.set("status", Json::string("error"));
      out.set("error", Json::string("flow passed " + d(PLEXER_FLOW_VISITS_MAX) + " screens (loop?), aborting"));
      out.set("at", Json::string(current));
      out.set("answers", answers);
      return out;
    }
    const Json& screen = by_id.at(current);
    std::string target;
    if (condition_holds(jget(screen, "show_if"), answers)) {
      ScreenResult result = run_screen(controller, screen);
      if (result.kind == ScreenResult::Kind::Outcome) return result.outcome;
      target = result.kind == ScreenResult::Kind::Jump ? result.target : follow_up(screen);
    } else {
      target = follow_up(screen);
    }
    if (target == "$done") {
      Json out = Json::object();
      out.set("status", Json::string("done"));
      out.set("answers", answers);
      out.set("action", action);
      return out;
    }
    if (target == "$cancel") return outcome_for("cancelled", current, answers);
    current = target;
  }
}

PlexerFlow::ScreenResult PlexerFlow::run_screen(PlexerController& controller, const Json& screen) {
  auto outcome = [](Json value) {
    ScreenResult r;
    r.kind = ScreenResult::Kind::Outcome;
    r.outcome = std::move(value);
    return r;
  };
  const std::string sid = jget(screen, "id").as_string();
  const std::string screen_title = [&] {
    const std::string& t = jget(screen, "title").as_string();
    return t.empty() ? jget(app, "title").as_string() : t;
  }();
  bool asked = false;
  for (const auto& field : jget(screen, "fields").as_array()) {
    const std::string& type = jget(field, "type").as_string();
    if (type == "info" || !condition_holds(jget(field, "show_if"), answers)) continue;
    if (remaining() <= 0) return outcome(outcome_for("timeout", sid, answers));
    const std::string fid = jget(field, "id").as_string();
    if (type == "choice") {
      Json ask = Json::object();
      ask.set("title", Json::string(screen_title));
      ask.set("text", Json::string(screen_text(screen, &field)));
      ask.set("kind", Json::string("choice"));
      Json labels = Json::array();
      for (const auto& opt : jget(field, "options").as_array()) labels.push(jget(opt, "label"));
      ask.set("options", labels);
      ask.set("default", jget(field, "default"));
      Json reply = controller.ask(ask, remaining());
      if (jget(reply, "status").as_string() != "ok")
        return outcome(outcome_for(jget(reply, "status").as_string(), sid, answers, fid));
      const Json& opts = jget(field, "options");
      long long idx = jget(reply, "value").is_number() ? jget(reply, "value").as_int() : -1;
      if (idx < 0 || idx >= static_cast<long long>(opts.as_array().size())) throw PlexerError("list index out of range");
      answers.set(fid, jget(opts.as_array()[static_cast<size_t>(idx)], "value"));
    } else {
      Json ask = Json::object();
      ask.set("title", Json::string(screen_title));
      ask.set("text", Json::string(screen_text(screen, &field)));
      ask.set("kind", Json::string("text"));
      ask.set("initial", jget(field, "initial"));
      Json reply = controller.ask(ask, remaining());
      if (jget(reply, "status").as_string() != "ok")
        return outcome(outcome_for(jget(reply, "status").as_string(), sid, answers, fid));
      answers.set(fid, jget(reply, "value"));
    }
    asked = true;
  }
  const Json& actions = jget(screen, "actions");
  if (actions.as_array().empty()) {
    if (!asked) {
      if (remaining() <= 0) return outcome(outcome_for("timeout", sid, answers));
      Json ask = Json::object();
      ask.set("title", Json::string(screen_title));
      ask.set("text", Json::string(screen_text(screen)));
      ask.set("kind", Json::string("message"));
      Json reply = controller.ask(ask, remaining());
      if (jget(reply, "status").as_string() != "ok")
        return outcome(outcome_for(jget(reply, "status").as_string(), sid, answers));
    }
    return ScreenResult{};
  }
  if (remaining() <= 0) return outcome(outcome_for("timeout", sid, answers));
  std::string text;
  if (first_askable(screen) == nullptr && py::strip(jget(screen, "body").as_string()).empty())
    text = screen_title;
  else if (first_askable(screen) == nullptr)
    text = screen_text(screen);
  else
    text = screen_title;
  Json ask = Json::object();
  ask.set("title", Json::string(screen_title));
  ask.set("text", Json::string(text));
  ask.set("kind", Json::string("choice"));
  Json labels = Json::array();
  for (const auto& a : actions.as_array()) labels.push(jget(a, "label"));
  ask.set("options", labels);
  ask.set("default", Json::integer(0));
  Json reply = controller.ask(ask, remaining());
  if (jget(reply, "status").as_string() != "ok")
    return outcome(outcome_for(jget(reply, "status").as_string(), sid, answers));
  long long idx = jget(reply, "value").is_number() ? jget(reply, "value").as_int() : -1;
  if (idx < 0 || idx >= static_cast<long long>(actions.as_array().size())) throw PlexerError("list index out of range");
  action = jget(actions.as_array()[static_cast<size_t>(idx)], "id");
  const Json& target = jget(screen, "next");
  if (target.is_object()) {
    const Json* dest = target.get(action.as_string());
    if (dest == nullptr || dest->is_null()) return ScreenResult{};
    if (dest->as_string() == "$done") {
      Json out = Json::object();
      out.set("status", Json::string("done"));
      out.set("answers", answers);
      out.set("action", action);
      return outcome(out);
    }
    if (dest->as_string() == "$cancel") return outcome(outcome_for("cancelled", sid, answers));
    ScreenResult r;
    r.kind = ScreenResult::Kind::Jump;
    r.target = dest->as_string();
    return r;
  }
  return ScreenResult{};
}

}  // namespace detz::mplex_flow