"use strict";

/**
 * 文案与 ASR 时间轴对齐（对齐 Electron ZimuShengcheng / Levenshtein）
 */

const PUNCTUATION_RE =
  /[，。！？、；：\u201C\u201D"「」『』（）【】《》,.!?;:'"]/;

const DEFAULT_CHAR_DURATION_MS = 150;
const TIME_GAP_SPLIT_THRESHOLD_MS = 500;

function levenshteinDistance(a, b) {
  const n = a.length;
  const m = b.length;
  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
  for (let i = 0; i <= n; i++) dp[i][0] = i;
  for (let j = 0; j <= m; j++) dp[0][j] = j;
  for (let i = 1; i <= n; i++) {
    for (let j = 1; j <= m; j++) {
      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
    }
  }
  return dp[n][m];
}

function findBestMatch(userText, asrText) {
  const n = userText.length;
  const m = asrText.length;
  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
  const bt = Array.from({ length: n + 1 }, () => Array(m + 1).fill(""));
  for (let i = 0; i <= n; i++) {
    dp[i][0] = i;
    bt[i][0] = "delete";
  }
  for (let j = 0; j <= m; j++) {
    dp[0][j] = j;
    bt[0][j] = "insert";
  }
  for (let i = 1; i <= n; i++) {
    for (let j = 1; j <= m; j++) {
      const cost = userText[i - 1] === asrText[j - 1] ? 0 : 1;
      const del = dp[i - 1][j] + 1;
      const ins = dp[i][j - 1] + 1;
      const sub = dp[i - 1][j - 1] + cost;
      const best = Math.min(del, ins, sub);
      dp[i][j] = best;
      if (best === del) bt[i][j] = "delete";
      else if (best === ins) bt[i][j] = "insert";
      else if (cost === 0) bt[i][j] = "match";
      else bt[i][j] = "replace";
    }
  }
  const alignments = [];
  let i = n;
  let j = m;
  while (i > 0 || j > 0) {
    const op = bt[i][j];
    if (op === "match") {
      alignments.unshift({
        userChar: userText[i - 1],
        asrChar: asrText[j - 1],
        operation: "match",
        asrIndex: j - 1,
      });
      i -= 1;
      j -= 1;
    } else if (op === "replace") {
      alignments.unshift({
        userChar: userText[i - 1],
        asrChar: asrText[j - 1],
        operation: "replace",
        asrIndex: j - 1,
      });
      i -= 1;
      j -= 1;
    } else if (op === "delete") {
      alignments.unshift({
        userChar: userText[i - 1],
        asrChar: "",
        operation: "delete",
        asrIndex: j,
      });
      i -= 1;
    } else {
      alignments.unshift({
        userChar: "",
        asrChar: asrText[j - 1],
        operation: "insert",
        asrIndex: j - 1,
      });
      j -= 1;
    }
  }
  const distance = dp[n][m];
  const similarity = 1 - distance / Math.max(n, m, 1);
  return { alignments, distance, similarity };
}

function buildSegmentCharTimings(segment) {
  const text = segment.text || "";
  const len = text.length;
  if (len === 0) return [];
  const step = (segment.end - segment.start) / Math.max(len, 1);
  const fallback = Array.from({ length: len }, (_, idx) => ({
    start: segment.start + idx * step,
    end: segment.start + (idx + 1) * step,
  }));
  const words = Array.isArray(segment.words) ? segment.words : [];
  if (words.length === 0) return fallback;

  const mapped = Array(len).fill(null);
  let searchFrom = 0;
  for (const w of words) {
    const word = String(w?.word ?? w?.text ?? "");
    const start = Number(w?.start ?? w?.beginTime ?? w?.begin_time);
    const end = Number(w?.end ?? w?.endTime ?? w?.end_time);
    if (!word || !Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
    const pos = text.indexOf(word, searchFrom);
    if (pos === -1) continue;
    const wordStep = (end - start) / Math.max(word.length, 1);
    for (let k = 0; k < word.length && pos + k < len; k++) {
      mapped[pos + k] = { start: start + k * wordStep, end: start + (k + 1) * wordStep };
    }
    searchFrom = pos + word.length;
  }
  return mapped.map((item, idx) => item || fallback[idx]);
}

function buildCharTimeMap(segments) {
  const map = new Map();
  let index = 0;
  for (const segment of segments) {
    for (const timing of buildSegmentCharTimings(segment)) {
      map.set(index, timing);
      index += 1;
    }
  }
  return map;
}

function mapToTimestamps(alignments, charMap) {
  const segments = [];
  let text = "";
  let start = 0;
  let end = 0;
  let corrected = false;
  let isFirstChar = true;

  for (let y = 0; y < alignments.length; y++) {
    const row = alignments[y];
    const timing =
      row.asrIndex != null && row.asrIndex >= 0 ? charMap.get(row.asrIndex) : null;
    const isPunct = row.userChar && PUNCTUATION_RE.test(row.userChar);

    if (row.operation === "match" || row.operation === "replace") {
      if (!isPunct) text += row.userChar;
      if (row.operation === "replace") corrected = true;
      if (timing) {
        if (isFirstChar) {
          start = timing.start;
          isFirstChar = false;
        }
        end = timing.end;
      }
    } else if (row.operation === "insert") {
      if (timing) {
        if (isFirstChar) {
          start = timing.start;
          isFirstChar = false;
        }
        end = timing.end;
      }
    } else if (row.operation === "delete") {
      if (!isPunct) {
        text += row.userChar;
        const t = isFirstChar ? start : end;
        if (isFirstChar) {
          start = t;
          isFirstChar = false;
        }
        if (!timing) end = t + DEFAULT_CHAR_DURATION_MS;
      }
      corrected = true;
    }

    const isLast = y === alignments.length - 1;
    const nextRow = alignments[y + 1];
    const nextTiming =
      nextRow && nextRow.asrIndex != null && nextRow.asrIndex >= 0
        ? charMap.get(nextRow.asrIndex)
        : null;
    const gapSplit =
      !isLast && timing && nextTiming && nextTiming.start - end > TIME_GAP_SPLIT_THRESHOLD_MS;

    if ((isLast || isPunct || gapSplit) && text.length > 0) {
      if (end <= start) end = start + text.length * DEFAULT_CHAR_DURATION_MS;
      segments.push({
        text,
        start,
        end,
        corrected,
      });
      start = end;
      text = "";
      corrected = false;
      isFirstChar = true;
    }
  }

  if (text.length > 0) {
    if (end <= start) end = start + text.length * DEFAULT_CHAR_DURATION_MS;
    segments.push({ text, start, end, corrected });
  }
  return segments;
}

/**
 * @param {string} userText
 * @param {Array<{ text: string, start: number, end: number, words?: unknown[] }>} asrSegments
 */
function correctTextWithLevenshtein(userText, asrSegments) {
  const user = String(userText || "").replace(/\s+/g, "");
  const list = Array.isArray(asrSegments) ? asrSegments : [];
  if (!user || list.length === 0) {
    return { segments: [], similarity: 0 };
  }

  const asrFullText = list.map((s) => s.text || "").join("");
  const match = findBestMatch(user, asrFullText);
  const charMap = buildCharTimeMap(list);
  const corrected = mapToTimestamps(match.alignments, charMap);

  const MIN_GAP_MS = 50;
  const out = corrected
    .map((seg) => ({
      text: String(seg.text || "").trim(),
      start: Math.round(seg.start),
      end: Math.round(seg.end),
    }))
    .filter((seg) => seg.text);

  for (let i = 0; i < out.length - 1; i++) {
    const cur = out[i];
    const next = out[i + 1];
    if (cur.end >= next.start) {
      cur.end = Math.max(cur.start + MIN_GAP_MS, next.start - MIN_GAP_MS);
    }
    if (cur.end <= cur.start) cur.end = cur.start + MIN_GAP_MS;
  }

  return { segments: out, similarity: match.similarity };
}

function similarity(a, b) {
  const max = Math.max(a.length, b.length);
  if (max === 0) return 1;
  return 1 - levenshteinDistance(a, b) / max;
}

module.exports = {
  correctTextWithLevenshtein,
  similarity,
};