#!/usr/bin/env node

import { execFileSync } from 'node:child_process';
import { existsSync, readFileSync, writeFileSync } from 'node:fs';
import path from 'node:path';
import { pathToFileURL } from 'node:url';

import ts from 'typescript';

const SOURCE_EXTENSIONS = new Set([
  '.cjs',
  '.js',
  '.mjs',
  '.ts',
  '.tsx',
  '.vue',
]);
const SOURCE_PATHSPECS = ['*.cjs', '*.js', '*.mjs', '*.ts', '*.tsx', '*.vue'];
const CHINESE_CHARACTER_PATTERN = /\p{Script=Han}/u;
const VUE_SCRIPT_PATTERN = /<script\b([^>]*)>([\s\S]*?)<\/script\s*>/giu;
const LIFECYCLE_ENTRY_NAMES = new Set([
  'activated',
  'afterInit',
  'afterInsert',
  'afterLoad',
  'afterQuery',
  'afterRecover',
  'afterRemove',
  'afterSoftRemove',
  'afterTransactionCommit',
  'afterTransactionRollback',
  'afterTransactionStart',
  'afterUpdate',
  'beforeApplicationShutdown',
  'beforeCreate',
  'beforeDestroy',
  'beforeInsert',
  'beforeMount',
  'beforeModuleDestroy',
  'beforeQuery',
  'beforeRecover',
  'beforeRemove',
  'beforeSoftRemove',
  'beforeTransactionCommit',
  'beforeTransactionRollback',
  'beforeTransactionStart',
  'beforeUnmount',
  'beforeUpdate',
  'componentDidCatch',
  'componentDidMount',
  'componentDidUpdate',
  'componentWillMount',
  'componentWillReceiveProps',
  'componentWillUnmount',
  'componentWillUpdate',
  'created',
  'deactivated',
  'destroyed',
  'errorCaptured',
  'getDerivedStateFromError',
  'getSnapshotBeforeUpdate',
  'handleConnection',
  'handleDisconnect',
  'mounted',
  'onApplicationBootstrap',
  'onApplicationShutdown',
  'onModuleDestroy',
  'onModuleInit',
  'renderTracked',
  'renderTriggered',
  'serverPrefetch',
  'shouldComponentUpdate',
  'unmounted',
  'updated',
]);

function getScriptKind(filePath, attributes = '') {
  const extension = path.extname(filePath).toLowerCase();

  if (extension === '.tsx') return ts.ScriptKind.TSX;
  if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
    return ts.ScriptKind.JS;
  }
  if (extension === '.vue') {
    if (/\blang\s*=\s*["']tsx["']/iu.test(attributes)) {
      return ts.ScriptKind.TSX;
    }
    if (/\blang\s*=\s*["'](?:js|jsx)["']/iu.test(attributes)) {
      return ts.ScriptKind.JS;
    }
  }

  return ts.ScriptKind.TS;
}

function getScriptBlocks(filePath, sourceText) {
  if (path.extname(filePath).toLowerCase() !== '.vue') {
    return [
      {
        contentOffset: 0,
        filePath,
        lineOffset: 0,
        scriptKind: getScriptKind(filePath),
        sourceText,
      },
    ];
  }

  const blocks = [];
  let match;

  VUE_SCRIPT_PATTERN.lastIndex = 0;
  while ((match = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) {
    const openingTagEnd = match[0].indexOf('>') + 1;
    const contentOffset = match.index + openingTagEnd;
    const lineOffset = (
      sourceText.slice(0, contentOffset).match(/\r\n|\r|\n/gu) || []
    ).length;
    const scriptKind = getScriptKind(filePath, match[1]);
    const extension =
      scriptKind === ts.ScriptKind.TSX
        ? 'tsx'
        : scriptKind === ts.ScriptKind.JS
          ? 'js'
          : 'ts';

    blocks.push({
      contentOffset,
      filePath: `${filePath}#script-${blocks.length + 1}.${extension}`,
      lineOffset,
      scriptKind,
      sourceText: match[2],
    });
  }

  return blocks;
}

function getNodeName(node, sourceFile) {
  if (!node.name) return undefined;

  if (
    ts.isIdentifier(node.name) ||
    ts.isPrivateIdentifier(node.name) ||
    ts.isStringLiteral(node.name) ||
    ts.isNumericLiteral(node.name)
  ) {
    return node.name.text;
  }

  return node.name.getText(sourceFile);
}

function classifyOwner(node, sourceFile) {
  if (!node) {
    return {
      code: 'invalid-target',
      ownerKind: 'UnattachedJSDoc',
      reason: 'JSDoc 未归属于允许的具名函数或方法',
    };
  }

  const isNamedFunction =
    (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) &&
    Boolean(node.name);
  const isNamedMethod =
    ts.isMethodDeclaration(node) ||
    ts.isGetAccessorDeclaration(node) ||
    ts.isSetAccessorDeclaration(node);

  if (!isNamedFunction && !isNamedMethod) {
    return {
      code: 'invalid-target',
      ownerKind: ts.SyntaxKind[node.kind],
      reason: 'JSDoc 只能用于具名函数声明、显式具名函数表达式或具名方法',
    };
  }

  const ownerName = getNodeName(node, sourceFile);
  if (ownerName === 'setup' || LIFECYCLE_ENTRY_NAMES.has(ownerName)) {
    return {
      code: 'forbidden-entry',
      ownerKind: ts.SyntaxKind[node.kind],
      ownerName,
      reason: `${ownerName} 是禁止使用 JSDoc 的 setup 或生命周期入口`,
    };
  }

  return {
    ownerKind: ts.SyntaxKind[node.kind],
    ownerName,
  };
}

function collectOwnedJsDocs(sourceFile) {
  const ownedDocs = new Map();

  function visit(node) {
    for (const jsDoc of node.jsDoc || []) {
      ownedDocs.set(`${jsDoc.getStart(sourceFile)}:${jsDoc.end}`, {
        jsDoc,
        owner: node,
      });
    }
    ts.forEachChild(node, visit);
  }

  visit(sourceFile);
  return ownedDocs;
}

function getLeafTokens(sourceFile) {
  const tokens = [];

  function visit(node) {
    if (
      node.kind >= ts.SyntaxKind.FirstJSDocNode &&
      node.kind <= ts.SyntaxKind.LastJSDocNode
    ) {
      return;
    }

    if (
      node.kind >= ts.SyntaxKind.FirstToken &&
      node.kind <= ts.SyntaxKind.LastToken
    ) {
      tokens.push(node);
      return;
    }

    for (const child of node.getChildren(sourceFile)) {
      visit(child);
    }
  }

  visit(sourceFile);
  return tokens.sort(
    (left, right) => left.getStart(sourceFile) - right.getStart(sourceFile),
  );
}

function scanTriviaGap(sourceText, start, end) {
  if (start >= end) return [];

  const scanner = ts.createScanner(
    ts.ScriptTarget.Latest,
    false,
    ts.LanguageVariant.Standard,
    sourceText.slice(start, end),
  );
  const comments = [];
  let token;

  do {
    token = scanner.scan();
    if (
      token === ts.SyntaxKind.MultiLineCommentTrivia &&
      scanner.getTokenText().startsWith('/**')
    ) {
      comments.push({
        end: start + scanner.getTextPos(),
        start: start + scanner.getTokenPos(),
      });
    }
  } while (token !== ts.SyntaxKind.EndOfFileToken);

  return comments;
}

function collectRawJsDocs(sourceFile) {
  const sourceText = sourceFile.text;
  const comments = [];
  let cursor = 0;

  for (const token of getLeafTokens(sourceFile)) {
    const tokenStart = token.getStart(sourceFile);
    comments.push(...scanTriviaGap(sourceText, cursor, tokenStart));
    cursor = Math.max(cursor, token.end);
  }
  comments.push(...scanTriviaGap(sourceText, cursor, sourceText.length));

  return comments;
}

function analyzeScriptBlock(block) {
  const sourceFile = ts.createSourceFile(
    block.filePath,
    block.sourceText,
    ts.ScriptTarget.Latest,
    true,
    block.scriptKind,
  );
  const ownedDocs = collectOwnedJsDocs(sourceFile);
  const rawDocs = collectRawJsDocs(sourceFile);
  const issues = [];
  const removals = [];
  let retainedCount = 0;

  for (const rawDoc of rawDocs) {
    const start = rawDoc.start;
    const end = rawDoc.end;
    const text = block.sourceText.slice(start, end);
    const owner = ownedDocs.get(`${start}:${end}`)?.owner;
    const classification = classifyOwner(owner, sourceFile);
    const position = sourceFile.getLineAndCharacterOfPosition(start);
    const common = {
      column: position.character + 1,
      end: block.contentOffset + end,
      filePath: block.filePath.replace(/#script-\d+\.(?:js|ts|tsx)$/u, ''),
      line: block.lineOffset + position.line + 1,
      ownerKind: classification.ownerKind,
      ownerName: classification.ownerName,
      start: block.contentOffset + start,
    };

    if (classification.code) {
      issues.push({
        ...common,
        code: classification.code,
        reason: classification.reason,
      });
      removals.push({
        end: common.end,
        start: common.start,
      });
      continue;
    }

    if (!CHINESE_CHARACTER_PATTERN.test(text)) {
      issues.push({
        ...common,
        code: 'missing-chinese-description',
        reason: 'JSDoc 描述必须整体以中文为主，不能是纯英文或仅标签',
      });
      removals.push({
        end: common.end,
        start: common.start,
      });
      continue;
    }

    retainedCount += 1;
  }

  return {
    issues,
    removals,
    retainedCount,
    totalCount: rawDocs.length,
  };
}

function analyzeSourceText(filePath, sourceText) {
  const results = getScriptBlocks(filePath, sourceText).map(analyzeScriptBlock);
  const issues = results.flatMap((result) => result.issues);

  return {
    issues,
    removals: results.flatMap((result) => result.removals),
    stats: {
      forbiddenEntryCount: issues.filter(
        (issue) => issue.code === 'forbidden-entry',
      ).length,
      invalidTargetCount: issues.filter(
        (issue) => issue.code === 'invalid-target',
      ).length,
      missingChineseCount: issues.filter(
        (issue) => issue.code === 'missing-chinese-description',
      ).length,
      retainedCount: results.reduce(
        (sum, result) => sum + result.retainedCount,
        0,
      ),
      totalCount: results.reduce((sum, result) => sum + result.totalCount, 0),
    },
  };
}

export function validateSourceText(filePath, sourceText) {
  const analysis = analyzeSourceText(filePath, sourceText);
  return {
    issues: analysis.issues,
    stats: analysis.stats,
  };
}

function expandStandaloneRemoval(sourceText, removal) {
  const lineStart = sourceText.lastIndexOf('\n', removal.start - 1) + 1;
  const nextLineBreak = sourceText.indexOf('\n', removal.end);
  const lineEnd = nextLineBreak === -1 ? sourceText.length : nextLineBreak + 1;
  const before = sourceText.slice(lineStart, removal.start);
  const after = sourceText.slice(
    removal.end,
    nextLineBreak === -1 ? sourceText.length : nextLineBreak,
  );

  if (before.trim() === '' && after.trim() === '') {
    return {
      end: lineEnd,
      start: lineStart,
    };
  }

  const horizontalWhitespace = before.match(/[^\S\r\n]+$/u)?.[0];
  if (horizontalWhitespace) {
    return {
      end: removal.end,
      start: removal.start - horizontalWhitespace.length,
    };
  }

  return removal;
}

function mergeRemovals(removals) {
  const sorted = [...removals].sort((left, right) => left.start - right.start);
  const merged = [];

  for (const removal of sorted) {
    const previous = merged.at(-1);
    if (previous && removal.start <= previous.end) {
      previous.end = Math.max(previous.end, removal.end);
    } else {
      merged.push({ ...removal });
    }
  }

  return merged;
}

export function fixSourceText(filePath, sourceText) {
  const analysis = analyzeSourceText(filePath, sourceText);
  const removals = mergeRemovals(
    analysis.removals.map((removal) =>
      expandStandaloneRemoval(sourceText, removal),
    ),
  );
  let fixedSourceText = sourceText;

  for (const removal of removals.toReversed()) {
    fixedSourceText =
      fixedSourceText.slice(0, removal.start) +
      fixedSourceText.slice(removal.end);
  }

  return {
    removedCount: analysis.removals.length,
    sourceText: fixedSourceText,
    stats: analysis.stats,
  };
}

function tokenizeScript(filePath, sourceText, scriptKind) {
  const sourceFile = ts.createSourceFile(
    filePath,
    sourceText,
    ts.ScriptTarget.Latest,
    true,
    scriptKind,
  );
  return getLeafTokens(sourceFile)
    .filter((node) => node.kind !== ts.SyntaxKind.EndOfFileToken)
    .map((node) => `${node.kind}:${node.getText(sourceFile)}`);
}

export function getTokenSignature(filePath, sourceText) {
  return getScriptBlocks(filePath, sourceText).flatMap((block, index) => [
    `script-block:${index}:${block.scriptKind}`,
    ...tokenizeScript(block.filePath, block.sourceText, block.scriptKind),
  ]);
}

function getRepositoryRoot(cwd) {
  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
    cwd,
    encoding: 'utf8',
  }).trim();
}

function isSupportedSourceFile(filePath) {
  return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
}

function splitNullDelimited(output) {
  return output.toString('utf8').split('\0').filter(Boolean);
}

function listCurrentSourceFiles(repoRoot) {
  const output = execFileSync(
    'git',
    [
      'ls-files',
      '--cached',
      '--others',
      '--exclude-standard',
      '-z',
      '--',
      ...SOURCE_PATHSPECS,
    ],
    {
      cwd: repoRoot,
      encoding: 'buffer',
    },
  );

  return splitNullDelimited(output).filter(isSupportedSourceFile).sort();
}

function listRefSourceFiles(repoRoot, ref) {
  const output = execFileSync(
    'git',
    ['ls-tree', '-r', '--name-only', '-z', ref],
    {
      cwd: repoRoot,
      encoding: 'buffer',
    },
  );

  return splitNullDelimited(output).filter(isSupportedSourceFile).sort();
}

function findFirstTokenDifference(beforeTokens, afterTokens) {
  const length = Math.max(beforeTokens.length, afterTokens.length);

  for (let index = 0; index < length; index += 1) {
    if (beforeTokens[index] !== afterTokens[index]) {
      return {
        after: afterTokens[index],
        before: beforeTokens[index],
        index,
      };
    }
  }

  return undefined;
}

function compareRepositoryTokens(
  repoRoot,
  ref,
  currentFiles,
  allowedTokenChanges,
) {
  const currentFileSet = new Set(currentFiles);
  const refFiles = listRefSourceFiles(repoRoot, ref);
  const refFileSet = new Set(refFiles);
  const allowedMismatches = [];
  const mismatches = [];
  let comparedFiles = 0;
  let comparedTokens = 0;

  for (const filePath of refFiles) {
    const absolutePath = path.resolve(repoRoot, filePath);
    if (!currentFileSet.has(filePath) || !existsSync(absolutePath)) {
      mismatches.push({
        filePath,
        reason: '基线文件在当前工作树中缺失',
      });
      continue;
    }

    const beforeSource = execFileSync('git', ['show', `${ref}:${filePath}`], {
      cwd: repoRoot,
      encoding: 'utf8',
      maxBuffer: 64 * 1024 * 1024,
    });
    const afterSource = readFileSync(absolutePath, 'utf8');
    const beforeTokens = getTokenSignature(filePath, beforeSource);
    const afterTokens = getTokenSignature(filePath, afterSource);
    const difference = findFirstTokenDifference(beforeTokens, afterTokens);

    if (difference) {
      const mismatch = {
        difference,
        filePath,
        reason: '非注释 token 与基线不一致',
      };
      if (allowedTokenChanges.has(filePath)) {
        allowedMismatches.push(mismatch);
      } else {
        mismatches.push(mismatch);
      }
      continue;
    }

    comparedFiles += 1;
    comparedTokens += beforeTokens.length;
  }

  return {
    allowedMismatches,
    comparedFiles,
    comparedTokens,
    mismatches,
    newFilesSkipped: currentFiles.filter(
      (filePath) => !refFileSet.has(filePath),
    ),
    ref,
  };
}

function addStats(target, stats) {
  for (const [key, value] of Object.entries(stats)) {
    target[key] += value;
  }
}

function parseOption(args, name) {
  const inline = args.find((arg) => arg.startsWith(`${name}=`));
  if (inline) return inline.slice(name.length + 1);

  const index = args.indexOf(name);
  return index >= 0 ? args[index + 1] : undefined;
}

function parseOptionList(args, name) {
  const values = [];

  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    if (arg.startsWith(`${name}=`)) {
      values.push(arg.slice(name.length + 1));
    } else if (arg === name && args[index + 1]) {
      values.push(args[index + 1]);
    }
  }

  return new Set(
    values
      .flatMap((value) => value.split(','))
      .map((value) => value.trim().replaceAll('\\', '/'))
      .filter(Boolean),
  );
}

function printIssues(issues) {
  for (const issue of issues) {
    const owner = issue.ownerName
      ? `${issue.ownerKind} ${issue.ownerName}`
      : issue.ownerKind;
    console.error(
      `${issue.filePath}:${issue.line}:${issue.column} ${issue.code} ${owner}: ${issue.reason}`,
    );
  }
}

function runRepositoryCheck({
  allowedTokenChanges,
  compareRef,
  fix,
  repoRoot,
}) {
  const files = listCurrentSourceFiles(repoRoot);
  const issues = [];
  const totals = {
    forbiddenEntryCount: 0,
    invalidTargetCount: 0,
    missingChineseCount: 0,
    retainedCount: 0,
    totalCount: 0,
  };
  let changedFiles = 0;
  let removedCount = 0;

  for (const filePath of files) {
    const absolutePath = path.resolve(repoRoot, filePath);
    const sourceText = readFileSync(absolutePath, 'utf8');

    if (fix) {
      const result = fixSourceText(filePath, sourceText);
      addStats(totals, result.stats);
      removedCount += result.removedCount;
      if (result.sourceText !== sourceText) {
        writeFileSync(absolutePath, result.sourceText);
        changedFiles += 1;
      }
      continue;
    }

    const result = validateSourceText(filePath, sourceText);
    addStats(totals, result.stats);
    issues.push(...result.issues);
  }

  const comparison = compareRef
    ? compareRepositoryTokens(repoRoot, compareRef, files, allowedTokenChanges)
    : undefined;
  const summary = {
    changedFiles,
    comparison,
    filesScanned: files.length,
    issues: issues.length,
    mode: fix ? 'fix' : 'check',
    removedCount,
    ...totals,
  };

  if (issues.length > 0) {
    printIssues(issues);
  }
  if (comparison?.mismatches.length) {
    for (const mismatch of comparison.mismatches) {
      console.error(`${mismatch.filePath}: ${mismatch.reason}`);
    }
  }

  console.log(JSON.stringify(summary, null, 2));

  if (issues.length > 0 || comparison?.mismatches.length) {
    process.exitCode = 1;
  }
}

function main() {
  const args = process.argv.slice(2);
  const repoRoot = getRepositoryRoot(
    path.resolve(parseOption(args, '--repo-root') || process.cwd()),
  );

  runRepositoryCheck({
    allowedTokenChanges: parseOptionList(args, '--allow-token-change'),
    compareRef: parseOption(args, '--compare-ref'),
    fix: args.includes('--fix'),
    repoRoot,
  });
}

const invokedUrl = process.argv[1]
  ? pathToFileURL(path.resolve(process.argv[1])).href
  : undefined;

if (invokedUrl === import.meta.url) {
  try {
    main();
  } catch (error) {
    console.error(error instanceof Error ? error.message : error);
    process.exitCode = 1;
  }
}