// Server → Client 自定义通知
interface CustomNotification {
  type: "info" | "warning" | "error";
  message: string;
  source: string;
}

// Server 发送自定义通知
connection.sendNotification("myLsp/showStatusBar", {
  text: "Analyzing project...",
  tooltip: "Indexing 127 files",
});

// Client 监听自定义通知
client.onNotification("myLsp/showStatusBar", (params) => {
  statusBar.setText(params.text);
  statusBar.setTooltip(params.tooltip);
});

// Server 提供自定义请求
connection.onRequest("myLsp/getProjectStats", async (params) => {
  const stats = {
    totalFiles: countFiles(params.rootUri),
    totalLines: countLines(params.rootUri),
    languages: detectLanguages(params.rootUri),
    lastIndexed: getLastIndexedTime(),
  };
  return stats;
});

// Client 调用自定义请求
const stats = await client.sendRequest("myLsp/getProjectStats", {
  rootUri: workspaceFolder.uri,
});
console.log(`Project has ${stats.totalFiles} files, ${stats.totalLines} lines`);

// Client 在 initialize 时传递自定义选项
const result = await client.sendRequest("initialize", {
  processId: process.pid,
  rootUri: workspaceFolder.uri,
  initializationOptions: {
    maxNumberOfProblems: 100,
    enableExperimentalFeatures: true,
    customRulesPath: "/path/to/rules.json",
    analysisDepth: 3,
  },
  capabilities: {},
});

// Server 读取初始化选项
connection.onInitialize((params) => {
  const options = params.initializationOptions || {};
  config.maxProblems = options.maxNumberOfProblems ?? 100;
  config.experimental = options.enableExperimentalFeatures ?? false;
  config.rulesPath = options.customRulesPath;
  config.depth = options.analysisDepth ?? 2;
});

capabilities: {
  semanticTokensProvider: {
    legend: {
      tokenTypes: [
        "namespace", "type", "class", "enum", "interface", "struct",
        "typeParameter", "parameter", "variable", "property",
        "enumMember", "function", "method", "macro", "keyword",
        "modifier", "comment", "string", "number", "regexp", "operator",
      ],
      tokenModifiers: [
        "declaration", "definition", "readonly", "static",
        "deprecated", "abstract", "async", "modification",
        "documentation", "defaultLibrary",
      ],
    },
    range: true,
    full: {
      delta: true,
    },
  },
}

interface SemanticToken {
  line: number;
  startChar: number;
  length: number;
  tokenType: number;
  tokenModifiers: number;
}

connection.onRequest("textDocument/semanticTokens/full", (params) => {
  const doc = docManager.get(params.textDocument.uri);
  if (!doc) return { data: [] };

  const tokens = analyzeTokens(doc);
  return encodeTokens(tokens);
});

function analyzeTokens(doc: TextDocumentItem): SemanticToken[] {
  const tokens: SemanticToken[] = [];
  const lines = doc.text.split("\n");

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];

    // 匹配关键字
    const kwPattern = /\b(def|class|if|else|for|while|return|import|from|as)\b/g;
    let match;
    while ((match = kwPattern.exec(line)) !== null) {
      tokens.push({
        line: i,
        startChar: match.index,
        length: match[0].length,
        tokenType: 14, // keyword
        tokenModifiers: 0,
      });
    }

    // 匹配函数名
    const fnPattern = /(?:def|function)\s+(\w+)/g;
    while ((match = fnPattern.exec(line)) !== null) {
      tokens.push({
        line: i,
        startChar: match.index + match[0].indexOf(match[1]),
        length: match[1].length,
        tokenType: 11, // function
        tokenModifiers: 1, // declaration
      });
    }

    // 匹配字符串
    const strPattern = /(["'])(?:(?!\1).)*\1/g;
    while ((match = strPattern.exec(line)) !== null) {
      tokens.push({
        line: i,
        startChar: match.index,
        length: match[0].length,
        tokenType: 17, // string
        tokenModifiers: 0,
      });
    }
  }

  return tokens.sort((a, b) => a.line - b.line || a.startChar - b.startChar);
}

function encodeTokens(tokens: SemanticToken[]): { data: number[] } {
  const data: number[] = [];
  let prevLine = 0;
  let prevChar = 0;

  for (const token of tokens) {
    const deltaLine = token.line - prevLine;
    const deltaChar = deltaLine === 0 ? token.startChar - prevChar : token.startChar;

    data.push(deltaLine, deltaChar, token.length, token.tokenType, token.tokenModifiers);

    prevLine = token.line;
    prevChar = token.startChar;
  }

  return { data };
}

// Server 请求创建进度
connection.onRequest("window/workDoneProgress/create", async (params) => {
  return params.token;
});

// 发送进度
async function analyzeProjectWithProgress(): Promise<void> {
  const token = "analysis-progress";

  // 开始
  connection.sendProgress("window/workDoneProgress", token, {
    kind: "begin",
    title: "Analyzing Project",
    message: "Scanning files...",
    cancellable: true,
    percentage: 0,
  });

  const files = await getAllProjectFiles();
  for (let i = 0; i < files.length; i++) {
    // 检查取消
    if (isCancelled(token)) break;

    // 报告进度
    connection.sendProgress("window/workDoneProgress", token, {
      kind: "report",
      message: `Analyzing ${files[i].name}`,
      percentage: Math.round((i / files.length) * 100),
    });

    await analyzeFile(files[i]);
  }

  // 结束
  connection.sendProgress("window/workDoneProgress", token, {
    kind: "end",
    message: "Analysis complete",
  });
}

connection.onRequest("textDocument/references", async (params, token) => {
  const progressToken = "ref-search";

  connection.sendProgress("window/workDoneProgress", progressToken, {
    kind: "begin",
    title: "Finding References",
    cancellable: true,
    percentage: 0,
  });

  const results: Location[] = [];
  const files = getAllProjectFiles();

  for (let i = 0; i < files.length; i++) {
    // 检查客户端取消请求
    if (token.isCancellationRequested) {
      connection.sendProgress("window/workDoneProgress", progressToken, {
        kind: "end",
        message: "Cancelled",
      });
      throw new ResponseError(ErrorCodes.RequestCancelled, "Request cancelled");
    }

    connection.sendProgress("window/workDoneProgress", progressToken, {
      kind: "report",
      message: `Searching ${files[i].name}`,
      percentage: Math.round((i / files.length) * 100),
    });

    const refs = await findReferencesInFile(files[i], params);
    results.push(...refs);
  }

  connection.sendProgress("window/workDoneProgress", progressToken, {
    kind: "end",
    message: `Found ${results.length} references`,
  });

  return results;
});

// Client 设置 trace 级别
connection.sendNotification("$/setTrace", {
  value: "verbose", // "off" | "messages" | "verbose"
});

// Server 接收 trace 设置
connection.onRequest("$/setTrace", (params) => {
  currentTraceLevel = params.value;
});

// Server 发送追踪日志
function trace(message: string, verbose?: string): void {
  if (currentTraceLevel === "off") return;
  if (currentTraceLevel === "verbose" && verbose) {
    connection.sendNotification("$/logTrace", {
      message: verbose,
      verbose: "true",
    });
  }
  connection.sendNotification("$/logTrace", { message });
}

// 使用 window/logMessage 发送日志
function log(type: MessageType, message: string): void {
  connection.sendNotification("window/logMessage", {
    type,     // 1=Error, 2=Warning, 3=Info, 4=Log
    message,
  });
}

// 使用 window/showMessage 显示弹窗
function showMessage(type: MessageType, message: string): void {
  connection.sendNotification("window/showMessage", {
    type,
    message,
  });
}

capabilities: {
  foldingRangeProvider: true,
}

connection.onRequest("textDocument/foldingRange", (params) => {
  const doc = docManager.get(params.textDocument.uri);
  if (!doc) return [];

  const lines = doc.text.split("\n");
  const ranges: FoldingRange[] = [];
  const stack: { line: number; char: string }[] = [];

  for (let i = 0; i < lines.length; i++) {
    const trimmed = lines[i].trimStart();
    if (trimmed.endsWith("{") || trimmed.endsWith(":") || trimmed.endsWith("(")) {
      stack.push({ line: i, char: trimmed.slice(-1) });
    } else if (trimmed.startsWith("}") || trimmed.startsWith(")") || (trimmed === "" && stack.length > 0)) {
      const start = stack.pop();
      if (start && i - start.line > 1) {
        ranges.push({
          startLine: start.line,
          endLine: i - 1,
          kind: "region",
        });
      }
    }
  }

  return ranges;
});

capabilities: {
  linkedEditingRangeProvider: true,
}

connection.onRequest("textDocument/linkedEditingRange", (params) => {
  const doc = docManager.get(params.textDocument.uri);
  if (!doc) return null;

  const text = doc.text;
  const offset = doc.offsetAt(params.position);

  // 匹配 HTML 标签
  const tagMatch = findHTMLTagAtPosition(text, offset);
  if (!tagMatch) return null;

  return {
    ranges: [tagMatch.openRange, tagMatch.closeRange],
    wordPattern: "\\w+",
  };
});