#!/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';
import { parse as parseVueSfc } from 'vue/compiler-sfc';

const CODE_FILE_PATTERN = /\.(?:cjs|js|mjs|ts|tsx|vue)$/u;
const HAN_CHARACTER_PATTERN = /\p{Script=Han}/u;
const JSDOC_PREFIX = '/**';

const LIFECYCLE_METHOD_NAMES = new Set([
  'activated',
  'beforeCreate',
  'beforeDestroy',
  'beforeMount',
  'beforeUnmount',
  'beforeUpdate',
  'componentDidCatch',
  'componentDidMount',
  'componentDidUpdate',
  'componentWillMount',
  'componentWillReceiveProps',
  'componentWillUnmount',
  'componentWillUpdate',
  'created',
  'deactivated',
  'destroyed',
  'errorCaptured',
  'getSnapshotBeforeUpdate',
  'mounted',
  'renderTracked',
  'renderTriggered',
  'serverPrefetch',
  'shouldComponentUpdate',
  'unmounted',
  'updated',
]);

function getIsolatedGitEnvironment() {
  return Object.fromEntries(
    Object.entries(process.env).filter(([name]) => !name.startsWith('GIT_')),
  );
}

function getLineStarts(source) {
  const starts = [0];

  for (let index = 0; index < source.length; index += 1) {
    const character = source.codePointAt(index);
    if (character === 13) {
      if (source.codePointAt(index + 1) === 10) {
        index += 1;
      }
      starts.push(index + 1);
    } else if (character === 10) {
      starts.push(index + 1);
    }
  }

  return starts;
}

function getLineAndColumn(lineStarts, position) {
  let low = 0;
  let high = lineStarts.length - 1;

  while (low <= high) {
    const middle = Math.floor((low + high) / 2);
    if (lineStarts[middle] <= position) {
      low = middle + 1;
    } else {
      high = middle - 1;
    }
  }

  const lineIndex = Math.max(0, high);
  return {
    column: position - lineStarts[lineIndex] + 1,
    line: lineIndex + 1,
  };
}

function getScriptKind(filePath, language) {
  const normalizedLanguage = language?.toLowerCase();

  if (normalizedLanguage === 'tsx' || filePath.endsWith('.tsx')) {
    return ts.ScriptKind.TSX;
  }
  if (normalizedLanguage === 'jsx') {
    return ts.ScriptKind.JSX;
  }
  if (
    normalizedLanguage === 'ts' ||
    filePath.endsWith('.ts') ||
    filePath.endsWith('.mts') ||
    filePath.endsWith('.cts')
  ) {
    return ts.ScriptKind.TS;
  }
  return ts.ScriptKind.JS;
}

function getVueScriptBlocks(filePath, source) {
  const { descriptor, errors } = parseVueSfc(source, {
    filename: filePath,
    sourceMap: false,
  });

  if (errors.length > 0) {
    const message = errors
      .map((error) => (error instanceof Error ? error.message : String(error)))
      .join('; ');
    throw new Error(`Vue SFC 解析失败：${message}`);
  }

  return [
    descriptor.script
      ? {
          content: descriptor.script.content,
          label: '<script>',
          language: descriptor.script.lang,
          offset: descriptor.script.loc.start.offset,
        }
      : null,
    descriptor.scriptSetup
      ? {
          content: descriptor.scriptSetup.content,
          label: '<script setup>',
          language: descriptor.scriptSetup.lang,
          offset: descriptor.scriptSetup.loc.start.offset,
        }
      : null,
  ]
    .filter(Boolean)
    .toSorted((left, right) => left.offset - right.offset);
}

function getScriptBlocks(filePath, source) {
  if (filePath.endsWith('.vue')) {
    return getVueScriptBlocks(filePath, source);
  }

  return [
    {
      content: source,
      label: null,
      language: path.extname(filePath).slice(1),
      offset: 0,
    },
  ];
}

function getNodeName(node, sourceFile) {
  if (!node.name) {
    return null;
  }
  if (
    ts.isIdentifier(node.name) ||
    ts.isPrivateIdentifier(node.name) ||
    ts.isStringLiteralLike(node.name) ||
    ts.isNumericLiteral(node.name)
  ) {
    return node.name.text;
  }
  return node.name.getText(sourceFile);
}

function isSetupFunctionExpression(node, sourceFile) {
  if (getNodeName(node, sourceFile) === 'setup') {
    return true;
  }

  const parent = node.parent;
  return (
    ts.isPropertyAssignment(parent) &&
    getNodeName(parent, sourceFile) === 'setup'
  );
}

function classifyTarget(node, sourceFile) {
  if (!node) {
    return { allowed: false, target: 'unattached' };
  }

  if (ts.isFunctionDeclaration(node)) {
    const name = getNodeName(node, sourceFile);
    if (!name) {
      return { allowed: false, target: 'anonymous-function-declaration' };
    }
    if (name === 'setup') {
      return { allowed: false, target: 'setup' };
    }
    return { allowed: true, target: 'named-function-declaration' };
  }

  if (ts.isFunctionExpression(node)) {
    const name = getNodeName(node, sourceFile);
    if (!name) {
      return { allowed: false, target: 'anonymous-function-expression' };
    }
    if (isSetupFunctionExpression(node, sourceFile)) {
      return { allowed: false, target: 'setup' };
    }
    return { allowed: true, target: 'named-function-expression' };
  }

  if (
    ts.isMethodDeclaration(node) ||
    ts.isGetAccessorDeclaration(node) ||
    ts.isSetAccessorDeclaration(node)
  ) {
    const name = getNodeName(node, sourceFile);
    if (name === 'setup') {
      return { allowed: false, target: 'setup' };
    }
    if (name && LIFECYCLE_METHOD_NAMES.has(name)) {
      return { allowed: false, target: 'lifecycle-entry' };
    }
    return {
      allowed: Boolean(name),
      target: ts.isMethodDeclaration(node) ? 'named-method' : 'accessor',
    };
  }

  if (ts.isConstructorDeclaration(node)) {
    return { allowed: false, target: 'constructor' };
  }
  if (ts.isArrowFunction(node)) {
    return { allowed: false, target: 'arrow-function' };
  }
  if (ts.isInterfaceDeclaration(node)) {
    return { allowed: false, target: 'interface' };
  }
  if (ts.isTypeAliasDeclaration(node)) {
    return { allowed: false, target: 'type' };
  }
  if (
    ts.isPropertyDeclaration(node) ||
    ts.isPropertySignature(node) ||
    ts.isPropertyAssignment(node) ||
    ts.isShorthandPropertyAssignment(node)
  ) {
    return { allowed: false, target: 'property' };
  }
  if (
    ts.isVariableDeclaration(node) ||
    ts.isVariableDeclarationList(node) ||
    ts.isVariableStatement(node)
  ) {
    return { allowed: false, target: 'variable' };
  }
  if (
    ts.isMethodSignature(node) ||
    ts.isCallSignatureDeclaration(node) ||
    ts.isConstructSignatureDeclaration(node) ||
    ts.isFunctionTypeNode(node)
  ) {
    return { allowed: false, target: 'type' };
  }

  return {
    allowed: false,
    target: ts.SyntaxKind[node.kind] ?? 'unknown',
  };
}

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.toSorted(
    (left, right) => left.getStart(sourceFile) - right.getStart(sourceFile),
  );
}

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

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

  for (
    let token = scanner.scan();
    token !== ts.SyntaxKind.EndOfFileToken;
    token = scanner.scan()
  ) {
    if (token !== ts.SyntaxKind.MultiLineCommentTrivia) {
      continue;
    }

    const commentStart = start + scanner.getTokenPos();
    const commentEnd = start + scanner.getTextPos();
    const text = content.slice(commentStart, commentEnd);
    if (!text.startsWith(JSDOC_PREFIX)) {
      continue;
    }

    comments.push({ end: commentEnd, start: commentStart, text });
  }

  return comments;
}

function collectRawJsdocComments(sourceFile) {
  const comments = [];
  let cursor = 0;

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

  return comments;
}

function collectJsdocOwners(sourceFile) {
  const owners = new Map();

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

  visit(sourceFile);
  return owners;
}

function inspectScriptBlock(filePath, block, fullSource, lineStarts) {
  const scriptKind = getScriptKind(filePath, block.language);
  const virtualFilePath = block.label
    ? `${filePath}${block.label.replaceAll(/[<> ]/gu, '-')}`
    : filePath;
  const sourceFile = ts.createSourceFile(
    virtualFilePath,
    block.content,
    ts.ScriptTarget.Latest,
    true,
    scriptKind,
  );
  const owners = collectJsdocOwners(sourceFile);
  const rawComments = collectRawJsdocComments(sourceFile);

  return rawComments.map((rawComment) => {
    const owner = owners.get(`${rawComment.start}:${rawComment.end}`);
    const classification = classifyTarget(owner, sourceFile);
    const start = block.offset + rawComment.start;
    const end = block.offset + rawComment.end;
    const location = getLineAndColumn(lineStarts, start);
    let rule = null;
    let message = null;

    if (!classification.allowed) {
      rule = 'invalid-target';
      message = `JSDoc 不允许用于 ${classification.target}`;
    } else if (!HAN_CHARACTER_PATTERN.test(rawComment.text)) {
      rule = 'non-chinese-description';
      message = 'JSDoc 自然语言描述必须使用中文';
    }

    return {
      block: block.label,
      column: location.column,
      end,
      filePath,
      line: location.line,
      message,
      ownerKind: owner ? ts.SyntaxKind[owner.kind] : null,
      rule,
      start,
      target: classification.target,
      text: fullSource.slice(start, end),
    };
  });
}

export function inspectFileSource(filePath, source) {
  const normalizedFilePath = filePath.replaceAll(path.sep, '/');
  const lineStarts = getLineStarts(source);
  const blocks = getScriptBlocks(normalizedFilePath, source);
  const comments = blocks.flatMap((block) =>
    inspectScriptBlock(normalizedFilePath, block, source, lineStarts),
  );

  return {
    comments,
    isVue: normalizedFilePath.endsWith('.vue'),
    scriptBlockCount: blocks.length,
    violations: comments.filter((comment) => comment.rule !== null),
  };
}

function collectSyntaxTokens(source, scriptKind, filePath) {
  const sourceFile = ts.createSourceFile(
    filePath,
    source,
    ts.ScriptTarget.Latest,
    true,
    scriptKind,
  );
  const tokens = [];

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

    const children = node.getChildren(sourceFile);
    if (children.length > 0) {
      for (const child of children) {
        visit(child);
      }
      return;
    }

    if (node.kind === ts.SyntaxKind.EndOfFileToken) {
      return;
    }
    const text = node.getText(sourceFile);
    if (text.length > 0) {
      tokens.push([node.kind, text]);
    }
  }

  visit(sourceFile);
  return tokens;
}

export function getCodeTokenSignature(filePath, source) {
  const normalizedFilePath = filePath.replaceAll(path.sep, '/');
  const blocks = getScriptBlocks(normalizedFilePath, source);
  const tokenGroups = blocks.map((block) => ({
    block: block.label,
    language: block.language ?? null,
    tokens: collectSyntaxTokens(
      block.content,
      getScriptKind(normalizedFilePath, block.language),
      normalizedFilePath,
    ),
  }));

  return JSON.stringify(tokenGroups);
}

function getRemovalEdit(source, start, end) {
  const lineStart = source.lastIndexOf('\n', start - 1) + 1;
  const nextLineBreak = source.indexOf('\n', end);
  const lineEnd = nextLineBreak === -1 ? source.length : nextLineBreak;
  const prefix = source.slice(lineStart, start);
  const suffix = source.slice(end, lineEnd);

  if (prefix.trim() === '' && suffix.trim() === '') {
    return {
      end: nextLineBreak === -1 ? source.length : nextLineBreak + 1,
      replacement: '',
      start: lineStart,
    };
  }

  if (suffix.trim() === '') {
    let expandedStart = start;
    while (
      expandedStart > lineStart &&
      (source[expandedStart - 1] === ' ' || source[expandedStart - 1] === '\t')
    ) {
      expandedStart -= 1;
    }
    return { end: lineEnd, replacement: '', start: expandedStart };
  }

  if (prefix.trim() === '') {
    let expandedEnd = end;
    while (
      expandedEnd < lineEnd &&
      (source[expandedEnd] === ' ' || source[expandedEnd] === '\t')
    ) {
      expandedEnd += 1;
    }
    return { end: expandedEnd, replacement: '', start: lineStart };
  }

  const newlines = source.slice(start, end).match(/\r\n|\r|\n/gu);
  return {
    end,
    replacement: newlines ? newlines.join('') : ' ',
    start,
  };
}

function applyEdits(source, edits) {
  const sortedEdits = edits.toSorted(
    (left, right) => right.start - left.start || right.end - left.end,
  );
  let result = source;
  let previousStart = source.length + 1;

  for (const edit of sortedEdits) {
    if (edit.end > previousStart) {
      throw new Error('JSDoc 清理范围发生重叠');
    }
    result =
      result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
    previousStart = edit.start;
  }

  return result;
}

export function applyJsdocPolicyFix(filePath, source) {
  const inspection = inspectFileSource(filePath, source);
  const uniqueViolations = [
    ...new Map(
      inspection.violations.map((violation) => [
        `${violation.start}:${violation.end}`,
        violation,
      ]),
    ).values(),
  ];
  const edits = uniqueViolations.map((violation) =>
    getRemovalEdit(source, violation.start, violation.end),
  );
  const beforeTokens = getCodeTokenSignature(filePath, source);
  const fixedSource = applyEdits(source, edits);
  const afterTokens = getCodeTokenSignature(filePath, fixedSource);

  if (beforeTokens !== afterTokens) {
    throw new Error(`${filePath}: 清理前后非注释 token 不一致`);
  }

  return {
    removedCount: uniqueViolations.length,
    source: fixedSource,
  };
}

export function getTrackedCodeFiles(rootDirectory = process.cwd()) {
  const output = execFileSync(
    'git',
    ['ls-files', '--cached', '--others', '--exclude-standard', '-z'],
    {
      cwd: rootDirectory,
      encoding: 'utf8',
      env: getIsolatedGitEnvironment(),
    },
  );

  return output
    .split('\0')
    .filter(Boolean)
    .filter((filePath) => CODE_FILE_PATTERN.test(filePath))
    .filter((filePath) => existsSync(path.join(rootDirectory, filePath)))
    .toSorted();
}

function summarizeInspections(inspections) {
  const summary = {
    'invalid-target': 0,
    'non-chinese-description': 0,
    fileCount: 0,
    jsdocCount: 0,
    scriptBlockCount: 0,
    violationCount: 0,
    vueFileCount: 0,
  };

  for (const inspection of inspections) {
    summary.fileCount += 1;
    summary.jsdocCount += inspection.result.comments.length;
    summary.scriptBlockCount += inspection.result.scriptBlockCount;
    summary.violationCount += inspection.result.violations.length;
    if (inspection.result.isVue) {
      summary.vueFileCount += 1;
    }
    for (const violation of inspection.result.violations) {
      summary[violation.rule] += 1;
    }
  }

  return summary;
}

function inspectTrackedFiles(rootDirectory) {
  return getTrackedCodeFiles(rootDirectory).map((filePath) => {
    const absolutePath = path.join(rootDirectory, filePath);
    const source = readFileSync(absolutePath, 'utf8');
    return {
      absolutePath,
      filePath,
      result: inspectFileSource(filePath, source),
      source,
    };
  });
}

function formatViolation(violation) {
  const blockSuffix = violation.block ? ` ${violation.block}` : '';
  return `${violation.filePath}:${violation.line}:${violation.column} [${violation.rule}]${blockSuffix} ${violation.message}`;
}

function printSummary(summary, prefix = 'JSDoc 检查') {
  process.stdout.write(
    `${prefix}：${summary.fileCount} 个受控代码文件，` +
      `${summary.vueFileCount} 个 Vue 文件，` +
      `${summary.scriptBlockCount} 个脚本区块，` +
      `${summary.jsdocCount} 个 JSDoc，` +
      `${summary.violationCount} 个违规` +
      `（非法位置 ${summary['invalid-target']}，纯英文 ${summary['non-chinese-description']}）\n`,
  );
}

function runCli() {
  const args = new Set(process.argv.slice(2));
  const fix = args.delete('--fix');
  if (args.size > 0) {
    console.error(`未知参数：${[...args].join(', ')}`);
    process.exitCode = 2;
    return;
  }

  const rootDirectory = process.cwd();
  const inspections = inspectTrackedFiles(rootDirectory);
  const initialSummary = summarizeInspections(inspections);

  if (!fix) {
    for (const inspection of inspections) {
      for (const violation of inspection.result.violations) {
        console.error(formatViolation(violation));
      }
    }
    printSummary(initialSummary);
    if (initialSummary.violationCount > 0) {
      process.exitCode = 1;
    }
    return;
  }

  let changedFileCount = 0;
  let removedCount = 0;
  for (const inspection of inspections) {
    if (inspection.result.violations.length === 0) {
      continue;
    }
    const fixed = applyJsdocPolicyFix(inspection.filePath, inspection.source);
    writeFileSync(inspection.absolutePath, fixed.source);
    changedFileCount += 1;
    removedCount += fixed.removedCount;
  }

  const finalInspections = inspectTrackedFiles(rootDirectory);
  const finalSummary = summarizeInspections(finalInspections);
  process.stdout.write(
    `JSDoc 清理：修改 ${changedFileCount} 个文件，删除 ${removedCount} 个违规块\n`,
  );
  printSummary(finalSummary, '清理后检查');
  if (finalSummary.violationCount > 0) {
    process.exitCode = 1;
  }
}

const invokedPath = process.argv[1]
  ? pathToFileURL(path.resolve(process.argv[1])).href
  : null;
if (invokedPath === import.meta.url) {
  try {
    runCli();
  } catch (error) {
    console.error(error instanceof Error ? error.message : String(error));
    process.exitCode = 1;
  }
}