// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 Martino Ferrari

#include "layout_store.hpp"

#include <algorithm>
#include <cstdint>
#include <cstdlib>
#include <cstdio>
#include <dirent.h>
#include <fstream>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>

namespace udpscope {

namespace {

/// Anything outside a safe filename set becomes '_': the host is a dotted quad
/// today, but the CLI takes any string and a '/' or ':' in it must not escape
/// the directory.
std::string sanitize(const std::string& host) {
  std::string out;
  out.reserve(host.size());
  for (char c : host) {
    const bool ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
                    (c >= '0' && c <= '9') || c == '.' || c == '_' || c == '-';
    out.push_back(ok ? c : '_');
  }
  return out.empty() ? "_" : out;
}

std::string config_dir() {
  const char* xdg = std::getenv("XDG_CONFIG_HOME");
  if (xdg != nullptr && xdg[0] != '\0') return std::string(xdg) + "/udpscope";
  const char* home = std::getenv("HOME");
  if (home == nullptr || home[0] == '\0') return "/tmp/udpscope-config";
  return std::string(home) + "/.config/udpscope";
}

void mkdirs(const std::string& path) {
  // **Every** component, the last one included. The condition used to be "the path has a trailing
  // slash", so the final directory was never created: `~/.config/udpscope` did not exist, the
  // first `save_layout()` failed silently, and the session appeared to persist only on a machine
  // where something else had already made the directory.
  std::string cur;
  for (std::size_t i = 0; i < path.size(); ++i) {
    cur.push_back(path[i]);
    if (path[i] != '/' && i + 1 != path.size()) continue;
    ::mkdir(cur.c_str(), 0755);
  }
}

std::string toml_escape(const std::string& s) {
  std::string out = "\"";
  for (char c : s) {
    if (c == '"' || c == '\\') out.push_back('\\');
    out.push_back(c);
  }
  return out + "\"";
}

bool unescape(std::string& s) {
  std::string out;
  for (std::size_t i = 0; i < s.size(); ++i) {
    if (s[i] != '\\') {
      out.push_back(s[i]);
      continue;
    }
    if (++i >= s.size()) return false;
    if (s[i] == '"' || s[i] == '\\') {
      out.push_back(s[i]);
    } else {
      return false;
    }
  }
  s = out;
  return true;
}

std::string trim(const std::string& s) {
  const auto a = s.find_first_not_of(" \t\r");
  if (a == std::string::npos) return {};
  const auto b = s.find_last_not_of(" \t\r");
  return s.substr(a, b - a + 1);
}

/// `"a", "b"` (with the brackets already stripped) -> ["a", "b"].
bool parse_string_array(const std::string& in, std::vector<std::string>& out) {
  out.clear();
  std::size_t i = 0;
  while (i < in.size()) {
    while (i < in.size() && (in[i] == ' ' || in[i] == ',' || in[i] == '\t')) ++i;
    if (i >= in.size()) break;
    if (in[i] != '"') return false;
    ++i;
    std::string tok;
    while (i < in.size() && in[i] != '"') {
      if (in[i] == '\\' && i + 1 < in.size()) {
        tok.push_back(in[i]);
        ++i;
      }
      tok.push_back(in[i]);
      ++i;
    }
    if (i >= in.size()) return false;
    ++i;  // closing quote
    if (!unescape(tok)) return false;
    out.push_back(tok);
  }
  return true;
}

}  // namespace

std::string layout_path(const std::string& host, std::uint16_t port) {
  const std::string dir = config_dir();
  mkdirs(dir);
  return dir + "/" + sanitize(host) + "_" + std::to_string(port) + ".toml";
}

std::vector<KnownSource> known_sources() {
  std::vector<KnownSource> out;
  const std::string dir = config_dir();
  DIR* d = ::opendir(dir.c_str());
  // No directory yet is an empty list, not an error: a first run has never saved anything.
  if (d == nullptr) return out;
  while (const dirent* e = ::readdir(d)) {
    const std::string name = e->d_name;
    if (name.size() <= 5 || name.compare(name.size() - 5, 5, ".toml") != 0) continue;
    const std::string stem = name.substr(0, name.size() - 5);
    // The *last* '_': `sanitize()` replaces anything unsafe in a host with one, so the host part
    // may hold them too and a first-match split would return a host cut in half.
    const std::size_t cut = stem.rfind('_');
    if (cut == std::string::npos || cut + 1 == stem.size()) continue;
    const long port = std::strtol(stem.c_str() + cut + 1, nullptr, 10);
    if (port <= 0 || port > 65535) continue;

    LayoutState st;
    const std::string path = dir + "/" + name;
    if (!load_layout(path, st)) continue;

    KnownSource s;
    s.host = stem.substr(0, cut);
    s.port = static_cast<std::uint16_t>(port);
    s.multicast = st.multicast;
    s.interface_addr = st.interface_addr;
    s.rows = static_cast<int>(st.rows.size());
    for (const LayoutState::Row& row : st.rows) {
      for (const std::string& sig : row.signals) {
        if (!sig.empty()) ++s.signals;
      }
    }
    if (s.signals == 0) continue;  // see the header: a session nobody configured

    struct stat sb {};
    s.mtime = (::stat(path.c_str(), &sb) == 0) ? static_cast<std::int64_t>(sb.st_mtime) : 0;
    out.push_back(std::move(s));
  }
  ::closedir(d);
  // Stable, so two files sharing an mtime keep the order the directory gave them rather than
  // swapping between runs.
  std::stable_sort(out.begin(), out.end(),
                   [](const KnownSource& a, const KnownSource& b) { return a.mtime > b.mtime; });
  return out;
}

bool forget_source(const KnownSource& src) {
  // Through `layout_path()` rather than by rebuilding the name here: one expression of the
  // scheme. `src.host` came back out of a filename, so it is already sanitized, and `sanitize()`
  // keeps alphanumerics, '.', '-' and '_' -- it is idempotent, so the round trip is exact.
  return std::remove(layout_path(src.host, src.port).c_str()) == 0;
}

std::string math_node_text(const MathNode& node) {
  // The op is written as its index through `math_op_at()`, not as the raw enum value: that accessor
  // is the contract the dialog, the engine and this file share, so the format is tied to it rather
  // than to the declaration order of an enum nobody else has to know about.
  int kind = 0;
  for (int i = 0; i < math_op_count(); ++i) {
    if (math_op_at(i) == node.op) kind = i;
  }
  std::ostringstream o;
  o << kind << '|' << node.source << '|' << node.in_a << '|' << node.in_b << '|' << node.gain << '|'
    << node.offset << '|' << node.fc << '|' << node.q << '|' << node.lo << '|' << node.hi << '|'
    << node.x << '|' << node.y;
  return o.str();
}

bool math_node_from_text(const std::string& text, MathNode& out) {
  std::vector<std::string> f;
  std::string cur;
  for (const char c : text) {
    if (c == '|') {
      f.push_back(cur);
      cur.clear();
    } else {
      cur.push_back(c);
    }
  }
  f.push_back(cur);
  if (f.size() != 12u) return false;
  const auto number = [&](std::size_t i, double& v) {
    try {
      v = std::stod(f[i]);
      return true;
    } catch (...) {
      return false;
    }
  };
  double kind = 0.0;
  double in_a = -1.0;
  double in_b = -1.0;
  if (!number(0, kind) || !number(2, in_a) || !number(3, in_b)) return false;
  const int k = static_cast<int>(kind);
  if (k < 0 || k >= math_op_count()) return false;
  out = MathNode{};
  out.op = math_op_at(k);
  out.source = f[1];
  out.in_a = static_cast<int>(in_a);
  out.in_b = static_cast<int>(in_b);
  return number(4, out.gain) && number(5, out.offset) && number(6, out.fc) && number(7, out.q) &&
         number(8, out.lo) && number(9, out.hi) && number(10, out.x) && number(11, out.y);
}

bool load_layout(const std::string& path, LayoutState& out) {
  std::ifstream in(path);
  if (!in) return false;

  LayoutState st;
  st.window_s = 0.0;
  st.rows.clear();
  st.calibration.clear();
  st.enabled.clear();
  st.math.clear();
  st.measures.clear();

  std::string line;
  // What the last `[[...]]` header opened, so keys land in the right record.
  enum class Section { Top, Plot, Calibration, Math, Measure } section = Section::Top;
  int plot_count = 0;
  bool plot_section_seen = false;
  while (std::getline(in, line)) {
    const std::string t = trim(line);
    if (t.empty() || t[0] == '#') continue;
    if (t[0] == '[') {
      if (t == "[[plot]]") {
        section = Section::Plot;
        plot_section_seen = true;
        st.rows.emplace_back();
      } else if (t == "[[calibration]]") {
        section = Section::Calibration;
        st.calibration.emplace_back();
      } else if (t == "[[math]]") {
        section = Section::Math;
        st.math.emplace_back();
      } else if (t == "[[measure]]") {
        section = Section::Measure;
        st.measures.emplace_back();
      } else {
        section = Section::Top;  // an unknown table: keep its keys out of ours
      }
      continue;
    }
    const auto eq = t.find('=');
    if (eq == std::string::npos) continue;
    const std::string key = trim(t.substr(0, eq));
    const std::string value = trim(t.substr(eq + 1));
    auto strip_quote = [](const std::string& v) {
      if (v.size() >= 2 && v.front() == '"' && v.back() == '"') {
        std::string s = v.substr(1, v.size() - 2);
        std::string out;
        for (std::size_t i = 0; i < s.size(); ++i) {
          if (s[i] == '\\' && i + 1 < s.size()) ++i;
          out.push_back(s[i]);
        }
        return out;
      }
      return v;
    };

    if (section == Section::Top) {
      if (key == "window_s") {
        try {
          st.window_s = std::stod(value);
        } catch (...) {
        }
      } else if (key == "enabled") {
        if (value.size() >= 2 && value.front() == '[' && value.back() == ']') {
          parse_string_array(value.substr(1, value.size() - 2), st.enabled);
        }
      } else if (key == "plots") {
        // Only a fallback for a file with no [[plot]] sections: the writer emits
        // both, and honouring both appended the sections onto the pre-created
        // rows (a 2-plot file loaded as 4).
        try {
          plot_count = std::max(0, std::stoi(value));
        } catch (...) {
        }
      } else if (key == "multicast") {
        st.multicast = strip_quote(value);
      } else if (key == "interface") {
        st.interface_addr = strip_quote(value);
      }
    } else if (section == Section::Plot && !st.rows.empty()) {
      if (key == "signals") {
        std::vector<std::string> names;
        if (value.size() >= 2 && value.front() == '[' && value.back() == ']') {
          parse_string_array(value.substr(1, value.size() - 2), names);
        }
        st.rows.back().signals = names;
      }
    } else if (section == Section::Math && !st.math.empty()) {
      MathChannel& m = st.math.back();
      if (key == "name") {
        m.name = strip_quote(value);
      } else if (key == "unit") {
        m.unit = strip_quote(value);
      } else if (key == "enabled") {
        m.enabled = value == "true";
      } else if (key == "output") {
        try {
          m.output = std::stoi(value);
        } catch (...) {
        }
      } else if (key == "nodes") {
        std::vector<std::string> texts;
        if (value.size() >= 2 && value.front() == '[' && value.back() == ']') {
          parse_string_array(value.substr(1, value.size() - 2), texts);
        }
        m.nodes.clear();
        for (const std::string& text : texts) {
          MathNode node;
          // A node this version cannot read is dropped rather than failing the whole file: a graph
          // with a hole in it is invalid and the editor says so, which beats losing the session.
          if (math_node_from_text(text, node)) m.nodes.push_back(node);
        }
      }
    } else if (section == Section::Measure && !st.measures.empty()) {
      Measure& m = st.measures.back();
      if (key == "signal") {
        m.signal = strip_quote(value);
      } else if (key == "type") {
        try {
          const int index = std::stoi(value);
          if (index >= 0 && index < measure_type_count()) m.type = measure_type_at(index);
        } catch (...) {
        }
      } else if (key == "threshold") {
        try {
          m.options.threshold_pct = std::stod(value);
        } catch (...) {
        }
      } else if (key == "above") {
        m.options.above = value == "true";
      } else if (key == "show") {
        m.options.show_on_plot = value == "true";
      }
    } else if (section == Section::Calibration && !st.calibration.empty()) {
      if (key == "name") {
        st.calibration.back().name = strip_quote(value);
      } else if (key == "gain") {
        try {
          st.calibration.back().gain = std::stod(value);
        } catch (...) {
        }
      } else if (key == "offset") {
        try {
          st.calibration.back().offset = std::stod(value);
        } catch (...) {
        }
      }
    }
  }
  if (!plot_section_seen && plot_count > 0) {
    st.rows.assign(static_cast<std::size_t>(plot_count), {});
  }
  out = std::move(st);
  return true;
}

bool save_layout(const std::string& path, const LayoutState& state) {
  std::ostringstream o;
  o << "# udpscope session layout (written by the app; safe to edit)\n";
  if (state.window_s > 0.0) o << "window_s = " << state.window_s << "\n";
  o << "plots = " << state.rows.size() << "\n";
  // Top level, before any table, for the same reason as `enabled` below.
  if (!state.multicast.empty()) o << "multicast = " << toml_escape(state.multicast) << "\n";
  if (!state.interface_addr.empty()) {
    o << "interface = " << toml_escape(state.interface_addr) << "\n";
  }
  // Top level, before any table. Emitted after the `[[calibration]]` tables it belonged to the last
  // of them -- a bare key after a header is that table's key in TOML -- so the parser, correctly,
  // never saw it and a session's enable state was silently lost.
  if (!state.enabled.empty()) {
    o << "enabled = [";
    for (std::size_t i = 0; i < state.enabled.size(); ++i) {
      if (i != 0) o << ", ";
      o << toml_escape(state.enabled[i]);
    }
    o << "]\n";
  }
  for (const auto& row : state.rows) {
    o << "\n[[plot]]\nsignals = [";
    for (std::size_t i = 0; i < row.signals.size(); ++i) {
      if (i != 0) o << ", ";
      o << toml_escape(row.signals[i]);
    }
    o << "]\n";
  }
  for (const auto& cal : state.calibration) {
    o << "\n[[calibration]]\nname = " << toml_escape(cal.name) << "\ngain = " << cal.gain
      << "\noffset = " << cal.offset << "\n";
  }
  for (const MathChannel& m : state.math) {
    o << "\n[[math]]\nname = " << toml_escape(m.name) << "\nunit = " << toml_escape(m.unit)
      << "\nenabled = " << (m.enabled ? "true" : "false") << "\noutput = " << m.output
      << "\nnodes = [";
    for (std::size_t i = 0; i < m.nodes.size(); ++i) {
      if (i != 0) o << ", ";
      o << toml_escape(math_node_text(m.nodes[i]));
    }
    o << "]\n";
  }
  for (const Measure& m : state.measures) {
    // The *accessor's* index, not the enum's value: `measure_type_at()` is the mapping the dialog
    // and this file share, and its order is the dropdown's -- which is not the declaration order of
    // the enum. Writing the raw value and reading it back through the accessor turned `top` into
    // whatever sat at that position (the same mistake the math nodes' op index was written to avoid).
    int kind = 0;
    for (int i = 0; i < measure_type_count(); ++i) {
      if (measure_type_at(i) == m.type) kind = i;
    }
    o << "\n[[measure]]\nsignal = " << toml_escape(m.signal) << "\ntype = " << kind
      << "\nthreshold = " << m.options.threshold_pct
      << "\nabove = " << (m.options.above ? "true" : "false") << "\nshow = "
      << (m.options.show_on_plot ? "true" : "false") << "\n";
  }

  // A sibling temp file + rename: a crash mid-write leaves the old layout, not a
  // truncated one that would fail to parse next start.
  const std::string tmp = path + ".tmp";
  {
    std::ofstream f(tmp, std::ios::trunc);
    if (!f) return false;
    f << o.str();
    if (!f.good()) {
      ::remove(tmp.c_str());
      return false;
    }
  }
  if (std::rename(tmp.c_str(), path.c_str()) != 0) {
    ::remove(tmp.c_str());
    return false;
  }
  return true;
}

}  // namespace udpscope