import * as vscode from 'vscode';
import type { LinterAdapter, LinterDiagnostic } from '../types';
import { getLinterForLanguage, isAdapterEnabled } from '../config';
import { ESLintAdapter } from '../adapters/eslint';
import { PmdAdapter } from '../adapters/pmd';
import { StylelintAdapter } from '../adapters/stylelint';
import { SqlFluffAdapter } from '../adapters/sqlfluff';
import { JspAdapter } from '../adapters/jsp';

export interface StaticAnalysisResult {
  diagnostics: LinterDiagnostic[];
  errors: string[];
  adapterIds: string[];
  duration: number;
}

export interface CachedAnalysis {
  diagnostics: LinterDiagnostic[];
  adapterId: string;
  workingDir: string;
}

export class Orchestrator {
  private adapters: LinterAdapter[];
  private analysisCache = new Map<string, CachedAnalysis>();

  constructor() {
    // 单语言单 linter 设计：按 linters.<language> 单选配置分派一个适配器；
    // 需多引擎的文件走组合适配器（如 JspAdapter = PMD + ESLint + Stylelint）。
    this.adapters = [
      new ESLintAdapter(),
      new PmdAdapter(),
      new StylelintAdapter(),
      new SqlFluffAdapter(),
      new JspAdapter(),
    ];
  }

  async runStaticAnalysis(
    document: vscode.TextDocument,
    workingDir: string
  ): Promise<StaticAnalysisResult> {
    const startTime = Date.now();
    const languageId = document.languageId;

    const selectedLinter = getLinterForLanguage(languageId);
    if (!selectedLinter) {
      return { diagnostics: [], errors: [], adapterIds: [], duration: 0 };
    }

    const adapter = this.adapters.find(a => a.id === selectedLinter);
    if (!adapter) {
      return {
        diagnostics: [],
        errors: [`未找到适配器: ${selectedLinter}`],
        adapterIds: [],
        duration: Date.now() - startTime,
      };
    }

    if (!isAdapterEnabled(adapter.id)) {
      return {
        diagnostics: [],
        errors: [],
        adapterIds: [],
        duration: Date.now() - startTime,
      };
    }

    const result = await adapter.check(document, workingDir);
    const errors: string[] = [];
    if (result.status !== 'ok') {
      errors.push(`[${adapter.id}] ${result.errorMessage ?? result.status}`);
    }

    this.analysisCache.set(document.uri.toString(), {
      diagnostics: result.diagnostics,
      adapterId: adapter.id,
      workingDir,
    });

    return {
      diagnostics: result.diagnostics,
      errors,
      adapterIds: [adapter.id],
      duration: Date.now() - startTime,
    };
  }

  setAnalysisResult(uri: vscode.Uri, result: CachedAnalysis): void {
    this.analysisCache.set(uri.toString(), result);
  }

  getAnalysisResult(uri: vscode.Uri): CachedAnalysis | undefined {
    return this.analysisCache.get(uri.toString());
  }

  clearAnalysisResult(uri: vscode.Uri): void {
    this.analysisCache.delete(uri.toString());
  }

  getAdapter(adapterId: string): LinterAdapter | undefined {
    return this.adapters.find(a => a.id === adapterId);
  }
}