import { promises as fs } from "node:fs";
import path from "node:path";
import { register } from "../engine/registry";
import { RuntimeError } from "../engine/types";

const str = (value: unknown): string => (value == null ? "" : String(value));
const num = (value: unknown, fallback = 0): number => {
  const parsed = Number(value);
  return Number.isFinite(parsed) ? parsed : fallback;
};
const bool = (value: unknown): boolean =>
  value === true || value === "true" || value === "1" || value === "True" || value === "是" || value === "开启";

function first(args: Record<string, unknown>, keys: string[]): unknown {
  for (const key of keys) {
    if (Object.prototype.hasOwnProperty.call(args, key)) return args[key];
  }
  return undefined;
}

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);
    }
  }
  return [value];
}

function asObject(value: unknown): Record<string, unknown> {
  if (value && typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
  if (typeof value === "string" && value.trim()) {
    try {
      const parsed = JSON.parse(value);
      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
    } catch {
      // ignore
    }
  }
  return {};
}

function toDate(value: unknown): Date {
  if (value instanceof Date) return value;
  if (typeof value === "number") return new Date(value < 1e12 ? value * 1000 : value);
  const text = str(value).trim();
  if (!text) return new Date();
  if (/^\d+$/.test(text)) {
    const numeric = Number(text);
    return new Date(numeric < 1e12 ? numeric * 1000 : numeric);
  }
  const normalized = text.replace(/\//g, "-").replace(" ", "T");
  const date = new Date(normalized);
  return Number.isNaN(date.getTime()) ? new Date(text) : date;
}

function formatDate(value: unknown, pattern = "YYYY-MM-DD HH:mm:ss"): string {
  const date = toDate(value);
  if (Number.isNaN(date.getTime())) return "";
  const pad = (input: number) => String(input).padStart(2, "0");
  const fmt = pattern
    .replace(/yyyy/g, "YYYY")
    .replace(/yy/g, "YY")
    .replace(/dd/g, "DD");
  return fmt
    .replace(/YYYY/g, String(date.getFullYear()))
    .replace(/YY/g, String(date.getFullYear()).slice(-2))
    .replace(/MM/g, pad(date.getMonth() + 1))
    .replace(/DD/g, pad(date.getDate()))
    .replace(/HH/g, pad(date.getHours()))
    .replace(/mm/g, pad(date.getMinutes()))
    .replace(/ss/g, pad(date.getSeconds()));
}

function cutText(text: string, args: Record<string, unknown>): string {
  const startType = str(first(args, ["start_cut_type"]));
  const endType = str(first(args, ["end_cut_type"]));
  let start = 0;
  if (startType.includes("文本")) {
    const token = str(first(args, ["start_cut_str", "start_cut_pos"]));
    const index = text.indexOf(token);
    start = index >= 0 ? index + token.length : 0;
  } else {
    start = Math.max(0, num(first(args, ["start_cut_pos", "start"]), 0));
  }
  if (endType.includes("长度")) {
    const length = Math.max(0, num(first(args, ["end_cut_length", "length"]), text.length));
    return text.slice(start, start + length);
  }
  if (endType.includes("文本")) {
    const token = str(first(args, ["end_cut_txt", "end_cut_str"]));
    const index = text.indexOf(token, start);
    return text.slice(start, index >= 0 ? index : text.length);
  }
  const end = num(first(args, ["end_cut_pos", "end"]), text.length);
  return text.slice(start, end);
}

/* ---------------- StrUtil ---------------- */
register("StrUtil_Len", (_ctx, _node, args) => str(first(args, ["string"])).length);
register("StrUtil_InStr", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const search = str(first(args, ["search"]));
  const start = Math.max(0, num(first(args, ["startIndex"]), 0));
  return text.indexOf(search, start);
});
register("StrUtil_Replace", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const search = str(first(args, ["search", "Config"]));
  const replacement = str(first(args, ["replace"]));
  return text.split(search).join(replacement);
});
register(["StrUtil_LowerCase"], (_ctx, _node, args) => str(first(args, ["string"])).toLowerCase());
register(["StrUtil_UpperCase"], (_ctx, _node, args) => str(first(args, ["string"])).toUpperCase());
register("StrUtil_CaseChange", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const mode = str(first(args, ["case"]));
  if (mode.includes("小写")) return text.toLowerCase();
  if (mode.includes("大写")) return text.toUpperCase();
  if (mode.includes("首")) return text ? text[0].toUpperCase() + text.slice(1) : "";
  return text;
});
register("StrUtil_Trim", (_ctx, _node, args) => str(first(args, ["string"])).trim());
register("StrUtil_Ltrim", (_ctx, _node, args) => str(first(args, ["string"])).replace(/^\s+/, ""));
register("StrUtil_Rtrim", (_ctx, _node, args) => str(first(args, ["string"])).replace(/\s+$/, ""));
register("StrUtil_DelTrim", (_ctx, _node, args) => str(first(args, ["string"])).trim());
register("StrUtil_Left", (_ctx, _node, args) => str(first(args, ["string"])).slice(0, Math.max(0, num(first(args, ["length"]), 0))));
register("StrUtil_Right", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const length = Math.max(0, num(first(args, ["length"]), 0));
  return length ? text.slice(-length) : "";
});
register("StrUtil_Mid", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const start = Math.max(0, num(first(args, ["start"]), 0));
  const length = Math.max(0, num(first(args, ["length"]), text.length));
  return text.slice(start, start + length);
});
register(["StrUtil_CutOutStr", "StrUtil_CutOutStrV1"], (_ctx, _node, args) => cutText(str(first(args, ["string"])), args));
register("StrUtil_Split", (_ctx, _node, args) =>
  str(first(args, ["string"])).split(str(first(args, ["spliter"])))
);
register(["StrUtil_SplitStr"], (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const custom = str(first(args, ["diy_symbol"]));
  const symbol = custom || str(first(args, ["split_symbol"])) || ",";
  const regex = bool(first(args, ["is_re"]));
  let parts: string[];
  if (regex) {
    try {
      parts = text.split(new RegExp(symbol));
    } catch {
      parts = text.split(symbol);
    }
  } else {
    parts = text.split(symbol);
  }
  const trim = args.del_trim === undefined ? true : bool(args.del_trim);
  if (trim) parts = parts.map((item) => item.trim());
  return parts.filter((item) => item !== "" || !trim);
});
register("StrUtil_AddToStr", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const addition = str(first(args, ["add_str"]));
  const type = str(first(args, ["add_type"]));
  const symbol = str(first(args, ["symbol"]));
  if (type.includes("前")) return addition + symbol + text;
  return text + symbol + addition;
});
register("StrUtil_ReverseStr", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  return bool(first(args, ["letter_reverse"])) ? [...text].reverse().join("") : text.split(/\s+/).reverse().join(" ");
});
register("StrUtil_ListToString", (_ctx, _node, args) => {
  const list = asArray(first(args, ["str_list"]));
  const connector = str(first(args, ["connectors_custom", "standard"])) || ",";
  return list.map(str).join(connector);
});
register("StrUtil_CompleteStr", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const total = Math.max(0, num(first(args, ["sum_length"]), text.length));
  const pad = str(first(args, ["com_string"])) || " ";
  const mode = str(first(args, ["com_type"]));
  const fill = pad.repeat(Math.max(0, total - text.length)).slice(0, Math.max(0, total - text.length));
  return mode.includes("右") ? text + fill : fill + text;
});
register("StrUtil_CharCode", (_ctx, _node, args) => String.fromCharCode(num(first(args, ["code"]), 0)));
register("StrUtil_CharAsc", (_ctx, _node, args) => str(first(args, ["char"])).charCodeAt(0));
register("StrUtil_CreateRandomStr", (_ctx, _node, args) => {
  const length = Math.max(0, num(first(args, ["string_length"]), 8));
  const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  return Array.from({ length }, () => alphabet[Math.floor(Math.random() * alphabet.length)]).join("");
});
register("StrUtil_LookUpStr", (_ctx, _node, args) => {
  const text = str(first(args, ["string"]));
  const search = str(first(args, ["search"]));
  const start = Math.max(0, num(first(args, ["startIndex"]), 0));
  return text.indexOf(search, start);
});

/* ---------------- Time ---------------- */
register("Time_Now", () => formatDate(new Date()));
register(["Time_GetDate", "Time_GetDateV1", "Time_GetDateV2"], (_ctx, _node, args) => {
  let date = toDate(first(args, ["date_start", "time_data"]));
  const offset = num(first(args, ["offset_unit_num"]), 0);
  const mode = str(first(args, ["offset_status"]));
  if (offset) date = new Date(date.getTime() + (mode.includes("减") ? -offset : offset) * 86400000);
  const type = str(first(args, ["get_type"]));
  if (type.includes("时间戳")) return Math.floor(date.getTime() / 1000);
  if (type.includes("日期") && !type.includes("时间")) return formatDate(date, "YYYY-MM-DD");
  return formatDate(date, type || "YYYY-MM-DD HH:mm:ss");
});
register("Time_Date", () => formatDate(new Date(), "YYYY-MM-DD"));
register("Time_Time", () => formatDate(new Date(), "HH:mm:ss"));
register("Time_TimeStamp", () => Math.floor(Date.now() / 1000));
register(["Time_Format", "Time_FormatNew"], (_ctx, _node, args) =>
  formatDate(first(args, ["timestamp", "date_input"]), str(first(args, ["format"])) || "YYYY-MM-DD HH:mm:ss")
);
register("Time_DatetimeToTimestamp", (_ctx, _node, args) => Math.floor(toDate(first(args, ["datetime"])).getTime() / 1000));
register("Time_DateToTimestamp", (_ctx, _node, args) => Math.floor(toDate(first(args, ["datetime"])).getTime() / 1000));
register(["Time_DateOffset", "Time_DateOffset_V1"], (_ctx, _node, args) => {
  const date = toDate(first(args, ["date_input"]));
  const amount = num(first(args, ["offset_unit_num"]), 0);
  const mode = str(first(args, ["offset_status"]));
  const delta = mode.includes("减") ? -amount : amount;
  const pattern = str(first(args, ["get_type"])) || str(first(args, ["is_fmt"])) || "YYYY-MM-DD HH:mm:ss";
  return formatDate(new Date(date.getTime() + delta * 86400000), pattern.includes("YYYY") ? pattern : "YYYY-MM-DD HH:mm:ss");
});
for (const [id, getter] of [
  ["Time_Year", (date: Date) => date.getFullYear()],
  ["Time_Month", (date: Date) => date.getMonth() + 1],
  ["Time_Day", (date: Date) => date.getDate()],
  ["Time_Hour", (date: Date) => date.getHours()],
  ["Time_Minute", (date: Date) => date.getMinutes()],
  ["Time_Second", (date: Date) => date.getSeconds()],
  ["Time_WeekDay", (date: Date) => date.getDay()]
] as Array<[string, (date: Date) => number]>) {
  register(id, (_ctx, _node, args) => getter(toDate(first(args, ["timestamp", "datetime"]))));
}
register("Time_CalDate", (_ctx, _node, args) => {
  const start = toDate(first(args, ["date_start"]));
  const end = toDate(first(args, ["date_end"]));
  const unit = str(first(args, ["time_type"]));
  const ms = end.getTime() - start.getTime();
  if (unit.includes("时")) return ms / 3600000;
  if (unit.includes("分")) return ms / 60000;
  if (unit.includes("秒")) return ms / 1000;
  return ms / 86400000;
});
register("Time_TimeTypeConversion", (_ctx, _node, args) =>
  formatDate(first(args, ["datetime"]), str(first(args, ["format"])) || "YYYY-MM-DD HH:mm:ss")
);

/* ---------------- List ---------------- */
register("List_CreateList", (_ctx, _node, args) => asArray(first(args, ["data"])));
register("List_ListLength", (_ctx, _node, args) => asArray(first(args, ["arrayRet"])).length);
register("List_InsertList", (_ctx, _node, args) => {
  const list = asArray(first(args, ["arrayRet"]));
  const item = first(args, ["data"]);
  const type = str(first(args, ["insertType"]));
  if (type.includes("位置") || type.includes("指定")) {
    const position = Math.max(0, Math.min(list.length, num(first(args, ["position"]), 0)));
    return [...list.slice(0, position), item, ...list.slice(position)];
  }
  return [...list, item];
});
register("List_DeleteList", (_ctx, _node, args) => {
  const list = asArray(first(args, ["arrayRet"]));
  const type = str(first(args, ["deleteType"]));
  if (type.includes("位置")) {
    const position = Math.max(0, num(first(args, ["position"]), 0));
    return list.filter((_, index) => index !== position);
  }
  const target = first(args, ["data"]);
  return list.filter((item) => item !== target);
});
register("List_GetListItem", (_ctx, _node, args) => asArray(first(args, ["arrayRet"]))[num(first(args, ["position"]), 0)]);
register("List_SetListItem", (_ctx, _node, args) => {
  const list = [...asArray(first(args, ["arrayRet"]))];
  const position = Math.max(0, num(first(args, ["position"]), 0));
  list[position] = first(args, ["data"]);
  return list;
});
register("List_GetIndex", (_ctx, _node, args) => asArray(first(args, ["arrayRet"])).indexOf(first(args, ["data"])));
register("List_ListMerge", (_ctx, _node, args) => [
  ...asArray(first(args, ["arrayRet1"])),
  ...asArray(first(args, ["arrayRet2"]))
]);
register("List_ListDuplication", (_ctx, _node, args) => [...new Set(asArray(first(args, ["arrayRet"])))]);
register("List_ListSorted", (_ctx, _node, args) => {
  const list = [...asArray(first(args, ["arrayRet"]))];
  const mode = str(first(args, ["sortedType"]));
  return list.sort((a, b) => {
    const result = String(a).localeCompare(String(b), "zh-CN", { numeric: true });
    return mode.includes("降") ? -result : result;
  });
});
register("List_ListIntersection", (_ctx, _node, args) => {
  const second = new Set(asArray(first(args, ["arrayRet2"])));
  return asArray(first(args, ["arrayRet1"])).filter((item) => second.has(item));
});
register("List_ClearList", () => []);

/* ---------------- Dict ---------------- */
register("Dict_Create", (_ctx, _node, args) => asObject(first(args, ["value"])));
register("Dict_GetItem", (_ctx, _node, args) => {
  const object = asObject(first(args, ["dictObj"]));
  const key = str(first(args, ["key"]));
  if (key in object) return object[key];
  return first(args, ["default_value"]);
});
register("Dict_SetItem", (_ctx, _node, args) => {
  const object = asObject(first(args, ["dictObj"]));
  const value = first(args, ["value"]);
  if (value && typeof value === "object") {
    const record = value as Record<string, unknown>;
    if ("key" in record) return { ...object, [str(record.key)]: record.value };
    return { ...object, ...record };
  }
  return { ...object, [str(first(args, ["key"]))]: value };
});
register("Dict_Keys", (_ctx, _node, args) => Object.keys(asObject(first(args, ["dictObj"]))));
register("Dict_Values", (_ctx, _node, args) => Object.values(asObject(first(args, ["dictObj"]))));
register("Dict_Items", (_ctx, _node, args) => Object.entries(asObject(first(args, ["dictObj"]))));
register("Dict_Delete", (_ctx, _node, args) => {
  const object = { ...asObject(first(args, ["dictObj"])) };
  delete object[str(first(args, ["key"]))];
  return object;
});
register("Dict_Clear", () => ({}));
register("Dict_Update", (_ctx, _node, args) => ({
  ...asObject(first(args, ["dictObj"])),
  ...asObject(first(args, ["targetDict"]))
}));

/* ---------------- Regex ---------------- */
register(["Regex_Test", "Regex_TestNew"], (_ctx, _node, args) => {
  try {
    return new RegExp(str(first(args, ["pattern", "Config"]))).test(str(first(args, ["text"])));
  } catch {
    return false;
  }
});
register(["Regex_FindAll", "Regex_FindAllNew"], (_ctx, _node, args) => {
  try {
    const regex = new RegExp(str(first(args, ["pattern", "Config"])), "g");
    return [...str(first(args, ["text"])).matchAll(regex)].map((match) => match[0]);
  } catch {
    return [];
  }
});
register(["Regex_Find", "Regex_FindNew", "Regex_FindStr", "Regex_FindStrV1", "Regex_FindNew_1"], (_ctx, _node, args) => {
  try {
    const pattern = str(first(args, ["pattern", "Config", "expression"]));
    const regex = new RegExp(pattern);
    const match = regex.exec(str(first(args, ["text", "string"])));
    if (!match) return "";
    const index = Math.max(0, num(first(args, ["index", "extract_pos"]), 0));
    return match[index] ?? match[0];
  } catch {
    return "";
  }
});

/* ---------------- Math ---------------- */
register("Math_Round", (_ctx, _node, args) => {
  const digit = num(first(args, ["digit"]), 0);
  const factor = 10 ** digit;
  return Math.round(num(first(args, ["data"])) * factor) / factor;
});
register("Math_Abs", (_ctx, _node, args) => Math.abs(num(first(args, ["data"]))));
register("Math_Int", (_ctx, _node, args) => {
  const value = num(first(args, ["data"]));
  const position = str(first(args, ["position"]));
  return position.includes("上") ? Math.ceil(value) : Math.floor(value);
});
register("Math_Sqrt", (_ctx, _node, args) => Math.sqrt(num(first(args, ["data"]))));
register("Math_Pow", (_ctx, _node, args) => Math.pow(num(first(args, ["x"])), num(first(args, ["y"]))));
register("Math_Exp", (_ctx, _node, args) => Math.exp(num(first(args, ["data"]))));
register("Math_Sgn", (_ctx, _node, args) => Math.sign(num(first(args, ["data"]))));
register("Math_Hex", (_ctx, _node, args) => num(first(args, ["num"])).toString(16).toUpperCase());
register("Math_Oct", (_ctx, _node, args) => num(first(args, ["num"])).toString(8));
register("Math_Scale", (_ctx, _node, args) => {
  const source = str(first(args, ["sourceNum"]));
  const from = num(first(args, ["sourceNumScale"]), 10);
  const to = num(first(args, ["targetNumScale"]), 10);
  return parseInt(source, from).toString(to).toUpperCase();
});
for (const [id, fn] of [
  ["Math_Sin", (value: number, angle: boolean) => Math.sin(angle ? (value * Math.PI) / 180 : value)],
  ["Math_Cos", (value: number, angle: boolean) => Math.cos(angle ? (value * Math.PI) / 180 : value)],
  ["Math_Tan", (value: number, angle: boolean) => Math.tan(angle ? (value * Math.PI) / 180 : value)]
] as Array<[string, (value: number, angle: boolean) => number]>) {
  register(id, (_ctx, _node, args) => {
    const unit = str(first(args, ["unit"]));
    return fn(num(first(args, ["data"])), unit.includes("角度"));
  });
}

/* ---------------- JSON / CSV ---------------- */
register("JSON_Stringify", (_ctx, _node, args) => JSON.stringify(first(args, ["string"])));
register("JSON_Parse", (_ctx, _node, args) => {
  try {
    return JSON.parse(str(first(args, ["string"])));
  } catch {
    return null;
  }
});

function parseCsv(text: string): string[][] {
  const rows: string[][] = [];
  let row: string[] = [];
  let cell = "";
  let quoted = false;
  for (let i = 0; i < text.length; i += 1) {
    const char = text[i];
    if (quoted) {
      if (char === '"' && text[i + 1] === '"') {
        cell += '"';
        i += 1;
      } else if (char === '"') {
        quoted = false;
      } else {
        cell += char;
      }
    } else if (char === '"') {
      quoted = true;
    } else if (char === ",") {
      row.push(cell);
      cell = "";
    } else if (char === "\n") {
      row.push(cell);
      rows.push(row);
      row = [];
      cell = "";
    } else if (char !== "\r") {
      cell += char;
    }
  }
  if (cell || row.length) {
    row.push(cell);
    rows.push(row);
  }
  return rows;
}

function toCsv(rows: unknown[][]): string {
  return rows
    .map((row) =>
      row
        .map((cell) => {
          const text = str(cell);
          return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
        })
        .join(",")
    )
    .join("\r\n");
}

register(["CSV_Read", "CSV_ReadNew"], async (_ctx, node, args) => {
  const filePath = path.resolve(str(first(args, ["path"])));
  if (!filePath) throw new RuntimeError("validation_error", "CSV 路径为空", { nodeId: node.id, componentId: node.componentId });
  const text = await fs.readFile(filePath, "utf8");
  return parseCsv(text);
});
register(["CSV_Write", "CSV_WriteNew"], async (_ctx, node, args) => {
  const filePath = path.resolve(str(first(args, ["path"])));
  if (!filePath) throw new RuntimeError("validation_error", "CSV 路径为空", { nodeId: node.id, componentId: node.componentId });
  const table = asArray(first(args, ["table"])).map((row) => asArray(row));
  await fs.mkdir(path.dirname(filePath), { recursive: true });
  await fs.writeFile(filePath, toCsv(table), "utf8");
  return filePath;
});

/* ---------------- Basic ---------------- */
register(["Basic_ConvertNumber", "Basic_StringToNum"], (_ctx, _node, args) => num(first(args, ["val"])));
register("Basic_ConvertString", (_ctx, _node, args) => str(first(args, ["val"])));
register("Basic_ConvertInt", (_ctx, _node, args) => Math.trunc(num(first(args, ["val"]))));
register("Basic_ConvertBool", (_ctx, _node, args) => bool(first(args, ["val"])));
register("Basic_IsNull", (_ctx, _node, args) => {
  const value = first(args, ["val"]);
  return value === null || value === undefined || value === "";
});
register("Basic_IsArray", (_ctx, _node, args) => Array.isArray(first(args, ["val"])));
register("Basic_IsDictionary", (_ctx, _node, args) => {
  const value = first(args, ["val"]);
  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
});
register("Basic_IsNumber", (_ctx, _node, args) => Number.isFinite(Number(first(args, ["val"]))));
register("Basic_Type", (_ctx, _node, args) => {
  const value = first(args, ["val"]);
  if (value === null) return "null";
  if (Array.isArray(value)) return "list";
  return typeof value;
});
register("Basic_JudgeDataType", (_ctx, _node, args) => {
  const value = first(args, ["val"]);
  if (value === null || value === undefined) return "null";
  if (Array.isArray(value)) return "list";
  if (typeof value === "object") return "dict";
  return typeof value;
});
register("Basic_Clone", (_ctx, _node, args) => structuredClone(first(args, ["val"])));
register("Basic_RandomInt", (_ctx, _node, args) => {
  const min = num(first(args, ["min", "start"]), 0);
  const max = num(first(args, ["max", "end"]), 100);
  return Math.floor(min + Math.random() * (max - min + 1));
});
register("Basic_Rnd", () => Math.random());
register("Basic_DataTypeConversion", (_ctx, _node, args) => first(args, ["val"]));