#!/usr/bin/env node
import { access, mkdir, readFile, writeFile } from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";

const MUTATING_TYPES = new Set(["click", "fill", "input", "type", "select", "check", "uncheck", "submit", "press"]);
const WRITE_RISKS = new Set(["write", "dangerous", "destructive", "submit", "payment", "approval"]);

export function generateSgRobotArtifacts(trace, options = {}) {
  const normalized = normalizeTrace(trace, options);
  const files = new Map();
  const skillRoot = `.sgclaw-workspace/skills/${normalized.skillName}`;

  files.set(`plan_templates/${normalized.planId}/PlanTemplate.toml`, renderPlanTemplate(normalized));
  files.set(`${skillRoot}/SKILL.toml`, renderSkillToml(normalized));
  files.set(`${skillRoot}/scripts/execute_trace.js`, renderRuntimeScript(normalized));
  files.set(`${skillRoot}/trace.semantic.json`, `${JSON.stringify(trace, null, 2)}\n`);

  return {
    summary: {
      planId: normalized.planId,
      skillName: normalized.skillName,
      expectedDomain: normalized.expectedDomain,
      defaultMode: normalized.defaultMode,
      requiresApproval: normalized.requiresApproval,
      actionCount: normalized.actions.length,
    },
    files,
  };
}

export async function writeArtifacts(root, files, options = {}) {
  const rootPath = path.resolve(root);
  const written = [];

  for (const [relativePath, content] of files.entries()) {
    if (path.isAbsolute(relativePath) || relativePath.includes("..")) {
      throw new Error(`Refusing unsafe generated path: ${relativePath}`);
    }

    const targetPath = path.resolve(rootPath, relativePath);
    if (!targetPath.startsWith(`${rootPath}${path.sep}`)) {
      throw new Error(`Refusing path outside output root: ${relativePath}`);
    }

    if (!options.force) {
      try {
        await access(targetPath);
        throw new Error(`Refusing to overwrite existing file without --force: ${relativePath}`);
      } catch (error) {
        if (error && error.code !== "ENOENT") {
          throw error;
        }
      }
    }

    await mkdir(path.dirname(targetPath), { recursive: true });
    await writeFile(targetPath, content, "utf8");
    written.push(targetPath);
  }

  return written;
}

function normalizeTrace(trace, options) {
  if (!trace || typeof trace !== "object" || Array.isArray(trace)) {
    throw new Error("Trace must be a JSON object.");
  }

  const id = requireString(trace.id, "trace.id");
  const name = requireString(trace.name, "trace.name");
  const startUrl = requireString(trace.startUrl || trace.start_url, "trace.startUrl");
  const start = parseHttpUrl(startUrl, "trace.startUrl");
  const actions = Array.isArray(trace.steps) ? trace.steps : trace.actions;

  if (!Array.isArray(actions) || actions.length === 0) {
    throw new Error("Trace must include a non-empty steps array.");
  }

  const baseId = toKebabId(id);
  const planId = cleanId(trace.planId || trace.plan_id || `rrweb-${baseId}`, "plan id");
  const skillName = cleanId(trace.skillName || trace.skill_name || `${planId}-execute`, "skill name");
  const expectedDomain = String(trace.expectedDomain || trace.expected_domain || start.hostname).trim();
  const defaultMode = normalizeMode(options.defaultMode || options.default_mode || trace.defaultMode || trace.default_mode || "dry-run");
  const normalizedActions = actions.map((action, index) => normalizeAction(action, index));
  const hasMutatingAction = normalizedActions.some(isMutatingAction);
  const requiresApproval =
    trace.requiresApproval === true ||
    trace.requires_approval === true ||
    (defaultMode === "execute" && hasMutatingAction);

  return {
    id,
    name,
    description: String(trace.description || `${name} generated from rrweb semantic trace.`),
    startUrl: start.href,
    planId,
    skillName,
    expectedDomain,
    defaultMode,
    requiresApproval,
    actions: normalizedActions,
  };
}

function normalizeAction(action, index) {
  if (!action || typeof action !== "object" || Array.isArray(action)) {
    throw new Error(`Trace step ${index + 1} must be an object.`);
  }

  const type = requireString(action.type || action.action, `trace.steps[${index}].type`);
  const normalized = {
    ...action,
    type,
    label: String(action.label || action.name || `${type} #${index + 1}`),
  };

  if (needsTarget(type) && !action.selector && !Array.isArray(action.selectors) && !action.text) {
    throw new Error(`Trace step ${index + 1} (${type}) needs selector, selectors, or text.`);
  }

  if (needsValue(type) && action.value === undefined) {
    throw new Error(`Trace step ${index + 1} (${type}) needs value.`);
  }

  return normalized;
}

function renderPlanTemplate(trace) {
  const approvalLine = trace.requiresApproval ? "\nrequires_approval = true" : "";

  return `[plan]
id = ${tomlString(trace.planId)}
name = ${tomlString(trace.name)}
description = ${tomlString(trace.description)}
version = "1.0.0"

[plan.trigger]
kind = "manual"

[[plan.steps]]
id = "open-target-page"
title = "Open target page"
description = ${tomlString(`Call browser.open_url to open ${trace.startUrl}.`)}
skills = ["browser.open_url"]
depends_on = []

[[plan.steps]]
id = "run-recorded-flow"
title = "Run recorded browser flow"
description = ${tomlString(`Execute the generated rrweb semantic trace through sgBrowser on ${trace.expectedDomain}. Default mode: ${trace.defaultMode}.`)}
skills = [${tomlString(trace.skillName)}]
depends_on = ["open-target-page"]${approvalLine}

[[plan.steps]]
id = "save-result"
title = "Save structured result"
description = "Save the generated flow result as a structured JSON artifact."
skills = ["json.save_result"]
depends_on = ["run-recorded-flow"]
`;
}

function renderSkillToml(trace) {
  return `[skill]
name = ${tomlString(trace.skillName)}
description = ${tomlString(`Run the generated rrweb semantic trace for ${trace.name} through sgBrowser.`)}
version = "0.1.0"
author = "rrweb-skill"
tags = ["rrweb", "semantic-trace", "sgbrowser-action", "generated"]

prompts = [
  ${tomlString(`Use ${trace.skillName} only for the generated ${trace.name} browser flow.`)},
  "Run it after browser.open_url has opened the target page.",
  "Return the structured JSON evidence emitted by the tool; do not use Playwright, CDP, or generic browser_action for this step."
]

[[tools]]
name = "execute_trace"
description = ${tomlString(`Replay or dry-run the generated ${trace.name} semantic trace in sgBrowser.`)}
kind = "sgbrowser_action"
command = "sgBrowserExcuteJsCodeByDomain"
expected_domain = ${tomlString(trace.expectedDomain)}

[tools.args]
script_path = "scripts/execute_trace.js"
mode = ${tomlString(`Baked default mode is ${trace.defaultMode}. Runtime may pass mode=execute or mode=dry-run if supported.`)}
`;
}

function renderRuntimeScript(trace) {
  const runtimeTrace = {
    id: trace.id,
    name: trace.name,
    start_url: trace.startUrl,
    expected_domain: trace.expectedDomain,
    default_mode: trace.defaultMode,
    actions: trace.actions,
  };

  return `const TRACE = ${JSON.stringify(runtimeTrace, null, 2)};
const input =
  (typeof args === "object" && args) ||
  (typeof tool_args === "object" && tool_args) ||
  (typeof sgclaw_args === "object" && sgclaw_args) ||
  {};

function normalizeMode(value) {
  const raw = String(value || TRACE.default_mode || "dry-run").trim().toLowerCase();
  return raw === "execute" ? "execute" : "dry-run";
}

function normalizeType(value) {
  return String(value || "").replace(/[\\s_-]+/g, "").toLowerCase();
}

function cleanText(value) {
  return String(value || "").replace(/\\s+/g, " ").trim();
}

function selectorList(action) {
  const selectors = [];
  if (action.selector) {
    selectors.push(action.selector);
  }
  if (Array.isArray(action.selectors)) {
    for (const selector of action.selectors) {
      if (selector) {
        selectors.push(selector);
      }
    }
  }
  return selectors;
}

function findByXPath(xpath) {
  try {
    return document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
  } catch (_) {
    return null;
  }
}

function findByText(text) {
  const needle = cleanText(text);
  if (!needle) {
    return null;
  }
  const candidates = Array.from(document.querySelectorAll("button,a,input,textarea,select,[role='button'],[role='link'],label"));
  return candidates.find((node) => cleanText(node.innerText || node.value || node.getAttribute("aria-label") || node.textContent).includes(needle)) || null;
}

function findElement(action) {
  for (const rawSelector of selectorList(action)) {
    const selector = String(rawSelector).trim();
    if (!selector) {
      continue;
    }
    if (selector.startsWith("xpath=")) {
      const node = findByXPath(selector.slice("xpath=".length));
      if (node) {
        return node;
      }
      continue;
    }
    if (selector.startsWith("//") || selector.startsWith("(//")) {
      const node = findByXPath(selector);
      if (node) {
        return node;
      }
      continue;
    }
    try {
      const node = document.querySelector(selector);
      if (node) {
        return node;
      }
    } catch (_) {
      continue;
    }
  }
  return findByText(action.text || action.label);
}

function describeElement(node) {
  if (!node) {
    return null;
  }
  return {
    tag: String(node.tagName || "").toLowerCase(),
    id: node.id || "",
    name: node.getAttribute ? node.getAttribute("name") || "" : "",
    text: cleanText(node.innerText || node.value || node.textContent).slice(0, 120),
  };
}

function dispatchFieldEvents(node) {
  node.dispatchEvent(new Event("input", { bubbles: true }));
  node.dispatchEvent(new Event("change", { bubbles: true }));
}

function runAction(action, index, shouldExecute) {
  const type = normalizeType(action.type);
  const result = {
    index,
    type: action.type,
    label: action.label || "",
    mode: shouldExecute ? "execute" : "dry-run",
    ok: true,
  };

  if (type === "asserttext" || type === "waitfortext") {
    const needle = cleanText(action.text || action.value);
    const haystack = cleanText(document.body ? document.body.innerText : document.documentElement.textContent);
    result.ok = needle ? haystack.includes(needle) : false;
    result.expected_text = needle;
    return result;
  }

  if (type === "extracttext") {
    const target = findElement(action) || document.body || document.documentElement;
    result.text = cleanText(target.innerText || target.textContent).slice(0, Number(action.max_chars || 2000));
    result.element = describeElement(target);
    return result;
  }

  const element = findElement(action);
  result.element = describeElement(element);
  if (!element) {
    result.ok = false;
    result.error = "target element not found";
    return result;
  }

  if (type === "click" || type === "submit") {
    if (shouldExecute) {
      element.scrollIntoView({ block: "center", inline: "center" });
      if (typeof element.focus === "function") {
        element.focus();
      }
      if (type === "submit" && element.form) {
        element.form.requestSubmit ? element.form.requestSubmit() : element.form.submit();
      } else {
        element.click();
      }
    }
    return result;
  }

  if (type === "fill" || type === "input" || type === "type") {
    result.value = action.value;
    if (shouldExecute) {
      element.focus && element.focus();
      element.value = String(action.value);
      dispatchFieldEvents(element);
    }
    return result;
  }

  if (type === "select") {
    result.value = action.value;
    if (shouldExecute) {
      element.value = String(action.value);
      dispatchFieldEvents(element);
    }
    return result;
  }

  if (type === "check" || type === "uncheck") {
    result.checked = type === "check";
    if (shouldExecute) {
      element.checked = type === "check";
      dispatchFieldEvents(element);
    }
    return result;
  }

  result.ok = false;
  result.error = "unsupported action type";
  return result;
}

const mode = normalizeMode(input.mode || input.execution_mode || input.executionMode);
const shouldExecute = mode === "execute";
const actionResults = [];
let ok = true;

for (let index = 0; index < TRACE.actions.length; index += 1) {
  const actionResult = runAction(TRACE.actions[index], index, shouldExecute);
  actionResults.push(actionResult);
  if (!actionResult.ok) {
    ok = false;
    break;
  }
}

return JSON.stringify({
  ok,
  trace_id: TRACE.id,
  trace_name: TRACE.name,
  mode,
  executed: shouldExecute,
  expected_domain: TRACE.expected_domain,
  url: window.location.href,
  title: document.title || "",
  action_count: TRACE.actions.length,
  action_results: actionResults,
  finished_at: new Date().toISOString(),
});
`;
}

function isMutatingAction(action) {
  const type = String(action.type || "").trim().toLowerCase();
  const risk = String(action.risk || "").trim().toLowerCase();
  return MUTATING_TYPES.has(type) || WRITE_RISKS.has(risk);
}

function needsTarget(type) {
  const normalized = String(type || "").replace(/[\s_-]+/g, "").toLowerCase();
  return !["asserttext", "waitfortext"].includes(normalized);
}

function needsValue(type) {
  const normalized = String(type || "").replace(/[\s_-]+/g, "").toLowerCase();
  return ["fill", "input", "type", "select"].includes(normalized);
}

function normalizeMode(value) {
  const mode = String(value || "").trim().toLowerCase();
  if (mode === "dry-run" || mode === "dryrun" || mode === "dry_run") {
    return "dry-run";
  }
  if (mode === "execute") {
    return "execute";
  }
  throw new Error(`Unsupported default mode: ${value}`);
}

function cleanId(value, label) {
  const cleaned = toKebabId(value);
  if (!cleaned) {
    throw new Error(`Invalid ${label}: ${value}`);
  }
  return cleaned;
}

function toKebabId(value) {
  return String(value || "")
    .trim()
    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
    .toLowerCase()
    .replace(/[^a-z0-9._-]+/g, "-")
    .replace(/-+/g, "-")
    .replace(/^-|-$/g, "");
}

function requireString(value, label) {
  if (typeof value !== "string" || !value.trim()) {
    throw new Error(`${label} must be a non-empty string.`);
  }
  return value.trim();
}

function parseHttpUrl(value, label) {
  try {
    const url = new URL(value);
    if (!["http:", "https:"].includes(url.protocol)) {
      throw new Error("Only http/https URLs are supported.");
    }
    return url;
  } catch (error) {
    throw new Error(`${label} must be a valid http/https URL. ${error.message}`);
  }
}

function tomlString(value) {
  return JSON.stringify(String(value));
}

function parseCliArgs(argv) {
  const args = {
    defaultMode: "dry-run",
    force: false,
  };

  for (let index = 0; index < argv.length; index += 1) {
    const token = argv[index];
    if (token === "--trace") {
      args.trace = argv[++index];
    } else if (token === "--out") {
      args.out = argv[++index];
    } else if (token === "--default-mode" || token === "--mode") {
      args.defaultMode = argv[++index];
    } else if (token === "--force") {
      args.force = true;
    } else if (token === "--help" || token === "-h") {
      args.help = true;
    } else {
      throw new Error(`Unknown argument: ${token}`);
    }
  }

  return args;
}

function usage() {
  return `Usage:
  node scripts/generate_sgrobot_flow.mjs --trace <semantic-trace.json> --out <sgrobot-root> [--default-mode dry-run|execute] [--force]
`;
}

async function main() {
  const cli = parseCliArgs(process.argv.slice(2));
  if (cli.help) {
    console.log(usage());
    return;
  }
  if (!cli.trace || !cli.out) {
    throw new Error(`${usage()}Both --trace and --out are required.`);
  }

  const trace = JSON.parse(await readFile(cli.trace, "utf8"));
  const result = generateSgRobotArtifacts(trace, { defaultMode: cli.defaultMode });
  const written = await writeArtifacts(cli.out, result.files, { force: cli.force });

  console.log(JSON.stringify({ ...result.summary, written }, null, 2));
}

const isCli = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
if (isCli) {
  main().catch((error) => {
    console.error(error.message);
    process.exitCode = 1;
  });
}