import type { FlowDefinition, FlowNode, RunError } from "../../shared/types";
import { evaluate, evaluateCondition, interpolate, toNumber } from "./expression";
import { getHandler } from "./registry";
import {
  asRuntimeError,
  BreakSignal,
  ContinueSignal,
  RuntimeError,
  StopSignal,
  type NodeState,
  type RunContext,
  type RunResult
} from "./types";

const MAX_LOOP = 10000;

function sleep(ms: number, signal?: AbortSignal): Promise<void> {
  if (ms <= 0) return Promise.resolve();
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      signal?.removeEventListener("abort", onAbort);
      resolve();
    }, ms);
    const onAbort = () => {
      clearTimeout(timer);
      reject(new RuntimeError("cancelled", "运行已取消"));
    };
    if (signal?.aborted) return onAbort();
    signal?.addEventListener("abort", onAbort, { once: true });
  });
}

function withTimeout<T>(promise: Promise<T>, timeoutMs: number, signal: AbortSignal, label: string): Promise<T> {
  return new Promise<T>((resolve, reject) => {
    let settled = false;
    const finish = (fn: () => void) => {
      if (settled) return;
      settled = true;
      clearTimeout(timer);
      signal.removeEventListener("abort", onAbort);
      fn();
    };
    const timer = setTimeout(() => {
      finish(() => reject(new RuntimeError("timeout", `${label} 执行超时（${timeoutMs}ms）`, {
        recommendation: "检查目标是否可达，或调大该节点的超时时间"
      })));
    }, timeoutMs > 0 ? timeoutMs : 30000);
    const onAbort = () => finish(() => reject(new RuntimeError("cancelled", "运行已取消")));
    if (signal.aborted) return onAbort();
    signal.addEventListener("abort", onAbort, { once: true });
    promise.then(
      (value) => finish(() => resolve(value)),
      (error) => finish(() => reject(error))
    );
  });
}

function isRetryable(code: string): boolean {
  return !["validation_error", "capability_not_implemented", "blocked_url", "cancelled", "expression_error"].includes(code);
}

function resolveArgs(node: FlowNode, component: { fields: Array<{ key: string; defaultValue: string }> }, vars: Record<string, unknown>): Record<string, unknown> {
  const args: Record<string, unknown> = {};
  for (const field of component.fields) {
    const raw = Object.prototype.hasOwnProperty.call(node.values, field.key) ? node.values[field.key] : field.defaultValue;
    try {
      args[field.key] = interpolate(raw, vars);
    } catch (error) {
      throw new RuntimeError("expression_error", `参数 ${field.key} 求值失败：${(error as Error).message}`, {
        arg: field.key,
        recommendation: "检查 ${...} 中的变量名与表达式语法"
      });
    }
  }
  for (const [key, value] of Object.entries(node.values || {})) {
    if (key in args) continue;
    try {
      args[key] = interpolate(value, vars);
    } catch (error) {
      throw new RuntimeError("expression_error", `参数 ${key} 求值失败：${(error as Error).message}`, { arg: key });
    }
  }
  return args;
}

function childChain(flow: FlowDefinition, parentId: string, slot: string): FlowNode[] {
  return flow.nodes.filter((node) => node.parentId === parentId && node.slot === slot);
}

function asArray(value: unknown): unknown[] {
  if (Array.isArray(value)) return value;
  if (value == null || value === "") return [];
  if (typeof value === "string") {
    try {
      const parsed = JSON.parse(value);
      return Array.isArray(parsed) ? parsed : [parsed];
    } catch {
      return value.split(/[,，\n]/).map((item) => item.trim()).filter(Boolean);
    }
  }
  if (typeof value === "object") return Object.values(value as Record<string, unknown>);
  return [value];
}

export async function runFlow(
  flow: FlowDefinition,
  options: {
    runId: string;
    evidenceDir: string;
    signal: AbortSignal;
    emit: RunContext["emit"];
    log: RunContext["log"];
    componentOf: RunContext["componentOf"];
    browser?: RunContext["browser"];
    variables?: Record<string, unknown>;
  }
): Promise<RunResult> {
  const startedAt = new Date().toISOString();
  const startMs = Date.now();
  const vars: Record<string, unknown> = { ...(options.variables || {}) };
  const ctx: RunContext = {
    runId: options.runId,
    flowId: flow.id,
    flow,
    vars,
    secrets: {},
    signal: options.signal,
    evidenceDir: options.evidenceDir,
    browser: options.browser,
    emit: options.emit,
    log: options.log,
    componentOf: options.componentOf
  };
  const states = new Map<string, NodeState>();
  let status: RunResult["status"] = "succeeded";
  let failure: RunError | undefined;

  options.emit({ type: "run.started", startedAt });

  try {
    await executeTopLevelGraph(flow, ctx, states);
  } catch (error) {
    if (error instanceof StopSignal) {
      options.log("流程被「退出流程」节点终止", "warn");
      status = "succeeded";
    } else if (error instanceof BreakSignal || error instanceof ContinueSignal) {
      failure = { code: "validation_error", reason: "跳出/继续语句不在循环体内" };
      status = "failed";
    } else {
      const runtimeError = asRuntimeError(error);
      failure = runtimeError;
      status = runtimeError.code === "cancelled" ? "cancelled" : "failed";
    }
  }

  const finishedAt = new Date().toISOString();
  const durationMs = Date.now() - startMs;
  options.emit({
    type: "run.finished",
    status,
    durationMs,
    error: failure,
    startedAt
  });

  return {
    runId: options.runId,
    status,
    startedAt,
    finishedAt,
    durationMs,
    nodes: [...states.values()],
    variables: vars,
    error: failure
  };
}

async function executeTopLevelGraph(flow: FlowDefinition, ctx: RunContext, states: Map<string, NodeState>): Promise<void> {
  const top = flow.nodes.filter((node) => !node.parentId);
  if (!top.length) return;
  if (!flow.edges.length) {
    for (const node of [...top].sort((a, b) => a.position.y - b.position.y || a.position.x - b.position.x)) {
      if (ctx.signal.aborted) throw new RuntimeError("cancelled", "运行已取消");
      await executeNode(node, ctx, states);
    }
    return;
  }
  const topIds = new Set(top.map((node) => node.id));
  const topById = new Map(top.map((node) => [node.id, node]));
  const edges = flow.edges.filter((edge) => topIds.has(edge.source) && topIds.has(edge.target));
  const incoming = new Set(edges.map((edge) => edge.target));
  const start =
    top.find((node) => !incoming.has(node.id) && node.componentId.startsWith("Trigger.")) ||
    top.find((node) => !incoming.has(node.id)) ||
    top[0];
  const visited = new Set<string>();

  const walk = async (node: FlowNode): Promise<void> => {
    if (visited.has(node.id)) return;
    if (ctx.signal.aborted) throw new RuntimeError("cancelled", "运行已取消");
    visited.add(node.id);
    try {
      await executeNode(node, ctx, states);
    } catch (error) {
      const errorEdge = edges.find((edge) => edge.source === node.id && edge.sourceHandle === "error");
      const target = errorEdge ? topById.get(errorEdge.target) : undefined;
      if (!target) throw error;
      ctx.vars.error = asRuntimeError(error, node, node.componentId);
      ctx.log(`节点失败，转入异常分支：${target.label || target.componentId}`, "warn", node.id);
      await walk(target);
      return;
    }
    const normalEdge = edges.find((edge) => edge.source === node.id && edge.sourceHandle !== "error");
    const target = normalEdge ? topById.get(normalEdge.target) : undefined;
    if (target) await walk(target);
  };

  await walk(start);
}

async function executeNode(node: FlowNode, ctx: RunContext, states: Map<string, NodeState>): Promise<unknown> {
  const component = ctx.componentOf(node);
  const state: NodeState = {
    nodeId: node.id,
    componentId: node.componentId,
    status: "running",
    startedAt: new Date().toISOString(),
    evidence: [],
    attempt: 1
  };
  states.set(node.id, state);
  ctx.emit({ type: "node.started", nodeId: node.id, attempt: 1 });

  if (!component) {
    const error = new RuntimeError("validation_error", `组件 ${node.componentId} 不在目录中`, {
      nodeId: node.id,
      componentId: node.componentId,
      recommendation: "重新添加该节点"
    });
    state.status = "failed";
    state.error = error.toRunError();
    state.finishedAt = new Date().toISOString();
    ctx.emit({ type: "node.finished", nodeId: node.id, status: "failed", error: state.error, durationMs: 0, evidence: [] });
    throw error;
  }

  if (node.enabled === false) {
    state.status = "skipped";
    state.finishedAt = new Date().toISOString();
    ctx.emit({ type: "node.finished", nodeId: node.id, status: "skipped", durationMs: 0, evidence: [] });
    return undefined;
  }

  const startMs = Date.now();
  try {
    let result: unknown;
    if (component.slots.length > 0) {
      result = await executeContainer(node, component.id, ctx, states);
    } else {
      const handler = getHandler(node.componentId) || getHandler(component.functionName);
      if (!handler) {
        throw new RuntimeError(
          "capability_not_implemented",
          `组件「${component.name}」当前版本未接入执行器`,
          {
            nodeId: node.id,
            componentId: node.componentId,
            recommendation: "请检查组件配置或重新添加节点"
          }
        );
      }
      const args = resolveArgs(node, component, ctx.vars);
      const delayBefore = Math.max(0, Number(node.options?.delayBeforeMs || 0));
      const delayAfter = Math.max(0, Number(node.options?.delayAfterMs || 0));
      const timeoutMs = Math.max(0, Number(node.options?.timeoutMs || 30000));
      const retries = Math.max(0, Math.min(100, Number(node.options?.retryCount || 0)));
      const interval = Math.max(1000, Number(node.options?.retryIntervalMs || 1000));

      await sleep(delayBefore, ctx.signal);
      for (let attempt = 1; attempt <= retries + 1; attempt += 1) {
        state.attempt = attempt;
        try {
          result = await withTimeout(
            Promise.resolve(handler(ctx, node, args, component)),
            timeoutMs,
            ctx.signal,
            component.name
          );
          break;
        } catch (error) {
          if (error instanceof BreakSignal || error instanceof ContinueSignal || error instanceof StopSignal) throw error;
          const runtimeError = asRuntimeError(error, node, component.id);
          if (attempt > retries || !isRetryable(runtimeError.code)) {
            throw new RuntimeError(runtimeError.code, runtimeError.reason, {
              recommendation: runtimeError.recommendation,
              nodeId: node.id,
              componentId: component.id,
              detail: runtimeError.detail
            });
          }
          ctx.log(
            `第 ${attempt} 次执行失败：${runtimeError.reason}，${Math.round(interval / 1000)} 秒后重试`,
            "warn",
            node.id
          );
          await sleep(interval, ctx.signal);
        }
      }
      if (node.options?.outputVar) ctx.vars[node.options.outputVar] = result;
      await sleep(delayAfter, ctx.signal);
    }

    state.status = "succeeded";
    state.output = result;
    state.finishedAt = new Date().toISOString();
    state.durationMs = Date.now() - startMs;
    ctx.emit({
      type: "node.finished",
      nodeId: node.id,
      status: "succeeded",
      output: result,
      durationMs: state.durationMs,
      evidence: state.evidence
    });
    return result;
  } catch (error) {
    if (error instanceof BreakSignal || error instanceof ContinueSignal || error instanceof StopSignal) {
      state.status = "skipped";
      state.finishedAt = new Date().toISOString();
      state.durationMs = Date.now() - startMs;
      ctx.emit({ type: "node.finished", nodeId: node.id, status: "skipped", durationMs: state.durationMs, evidence: [] });
      throw error;
    }
    const runtimeError = asRuntimeError(error, node, component.id);
    state.error = runtimeError;
    state.finishedAt = new Date().toISOString();
    state.durationMs = Date.now() - startMs;
    const skip = Boolean(node.options?.skipOnError);
    state.status = skip ? "skipped" : "failed";
    ctx.log(`${component.name} ${skip ? "失败但已跳过" : "失败"}：${runtimeError.reason}`, "error", node.id);
    if (node.options?.logException && runtimeError.detail) ctx.log(runtimeError.detail, "error", node.id);
    ctx.emit({
      type: "node.finished",
      nodeId: node.id,
      status: state.status,
      error: runtimeError,
      durationMs: state.durationMs,
      evidence: []
    });
    if (skip) return undefined;
    throw error;
  }
}

async function executeContainer(
  node: FlowNode,
  componentId: string,
  ctx: RunContext,
  states: Map<string, NodeState>
): Promise<unknown> {
  const runSlot = async (slot: string) => {
    for (const child of childChain(ctx.flow, node.id, slot)) {
      if (ctx.signal.aborted) throw new RuntimeError("cancelled", "运行已取消");
      await executeNode(child, ctx, states);
    }
  };

  switch (componentId) {
    case "logic_control_if_else": {
      const condition = evaluateCondition(node.values?.condition, ctx.vars);
      ctx.log(`条件 ${condition ? "成立" : "不成立"}：${String(node.values?.condition ?? "")}`, "info", node.id);
      await runSlot(condition ? "statement_if" : "statement_else");
      return condition;
    }
    case "logic_control_count_for": {
      const start = toNumber(interpolate(node.values?.count_start_value, ctx.vars), 1);
      const end = toNumber(interpolate(node.values?.count_end_value, ctx.vars), 1);
      const step = toNumber(interpolate(node.values?.count_step, ctx.vars), 1) || 1;
      const indexName = String(interpolate(node.values?.count_index, ctx.vars) || "index");
      let iterations = 0;
      for (let value = start; step > 0 ? value <= end : value >= end; value += step) {
        if (iterations++ > MAX_LOOP) throw new RuntimeError("validation_error", "循环次数超过上限 10000");
        ctx.vars[indexName] = value;
        try {
          await runSlot("count_for_fn");
        } catch (error) {
          if (error instanceof BreakSignal) break;
          if (error instanceof ContinueSignal) continue;
          throw error;
        }
      }
      return iterations;
    }
    case "logic_control_array_for_v3":
    case "logic_control_dictionary_for_v1": {
      const raw = node.values?.array_name;
      let value = interpolate(raw, ctx.vars);
      if (typeof value === "string") {
        const name = value.trim();
        if (name in ctx.vars) value = ctx.vars[name];
        else {
          try {
            value = JSON.parse(name);
          } catch {
            value = asArray(name);
          }
        }
      }
      const list = asArray(value);
      const reverse = String(node.values?.reverse ?? "") === "true" || String(node.values?.reverse ?? "") === "1";
      const start = Math.max(0, toNumber(node.values?.start_index, 0));
      const requestedEnd = node.values?.end_index === "" || node.values?.end_index == null ? list.length : toNumber(node.values?.end_index, list.length);
      const end = requestedEnd < 0 ? Math.max(start, list.length + requestedEnd + 1) : requestedEnd;
      const slice = (reverse ? [...list].reverse() : list).slice(start, end);
      let iterations = 0;
      for (let index = 0; index < slice.length; index += 1) {
        if (iterations++ > MAX_LOOP) throw new RuntimeError("validation_error", "循环次数超过上限 10000");
        ctx.vars.item = slice[index];
        ctx.vars.index = index;
        ctx.vars.value = slice[index];
        try {
          await runSlot("array_for_fn");
        } catch (error) {
          if (error instanceof BreakSignal) break;
          if (error instanceof ContinueSignal) continue;
          throw error;
        }
      }
      return iterations;
    }
    case "logic_control_while": {
      let iterations = 0;
      while (evaluateCondition(node.values?.if_for_condition, ctx.vars)) {
        if (iterations++ > MAX_LOOP) throw new RuntimeError("validation_error", "循环次数超过上限 10000");
        try {
          await runSlot("if_for_fn");
        } catch (error) {
          if (error instanceof BreakSignal) break;
          if (error instanceof ContinueSignal) continue;
          throw error;
        }
      }
      return iterations;
    }
    case "infinite_loop": {
      for (let iterations = 0; ; iterations += 1) {
        if (iterations > MAX_LOOP) throw new RuntimeError("validation_error", "循环次数超过上限 10000");
        try {
          await runSlot("loop_body");
        } catch (error) {
          if (error instanceof BreakSignal) break;
          if (error instanceof ContinueSignal) continue;
          throw error;
        }
      }
      return undefined;
    }
    case "logic_control_try_catch": {
      try {
        await runSlot("try_fn");
        await runSlot("else_fn");
        return "else";
      } catch (error) {
        if (error instanceof BreakSignal || error instanceof ContinueSignal || error instanceof StopSignal) throw error;
        ctx.vars.error = asRuntimeError(error, node, componentId);
        await runSlot("except_fn");
        return "catch";
      }
    }
    default: {
      const slot = componentId === "Element_exception_monitor_v2" ? "exception_monitor_params" : "body";
      await runSlot(slot);
      return undefined;
    }
  }
}

export { evaluate, evaluateCondition, interpolate };