/// This example shows how to successfully obtain the definition of symbol

/// test-utils.js
import { fileURLToPath } from "node:url";
import { URI } from "vscode-uri";
import * as path from "node:path";
import * as fs from "node:fs";
// The javascript files are placed in target/debug
const PACKAGE_ROOT = path.resolve(__dirname, "../..");

function uri(...components: string[]): string {
  const resolved = filePath(...components);
  return URI.file(resolved).toString();
}

function filePath(...components: string[]): string {
  return URI.file(path.resolve(PACKAGE_ROOT, "test-data", ...components))
    .fsPath;
}
export function readContents(filepath: string): string {
  return fs.readFileSync(filepath, "utf-8").toString();
}

/// END test-utils.js

import { spawn } from "child_process";
import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
import {
  InitializeParams,
  TextDocumentItem,
  DidOpenTextDocumentParams,
  DocumentHighlightParams,
  DefinitionParams,
  DeclarationParams,
  LogMessageParams,
  InitializeResult,
  LocationLink,
} from "vscode-languageserver-protocol";
import { StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";

// Initialize the server process
const serverProcess = spawn(
  "npx",
  ["typescript-language-server", "--stdio", "--log-level", "4"],
  {
    stdio: ["pipe", "pipe", "inherit"],
  }
);

const reader = new StreamMessageReader(serverProcess.stdout);
const writer = new StreamMessageWriter(serverProcess.stdin);

// Create a connection for the server using stdio
const connection = createConnection(ProposedFeatures.all, reader, writer);

// Create a function to initialize the server
async function initializeServer() {
  const initializeParams: InitializeParams = {
    processId: null,
    // rootUri: uri(),
    rootUri: "file:///Users/user/src/nobody/007%20lean%20library/test-data",
    capabilities: {
      // I took these capabilities from the tests of typescript-language-server
      textDocument: {
        definition: { linkSupport: true },
        codeLens: {},
        completion: {
          completionItem: {
            insertReplaceSupport: true,
            snippetSupport: true,
            labelDetailsSupport: true,
          },
        },
        documentSymbol: {
          hierarchicalDocumentSymbolSupport: true,
        },
        publishDiagnostics: {
          tagSupport: {
            valueSet: [1, 2],
          },
        },
        moniker: {},
      },
    },
    initializationOptions: {
      disableAutomaticTypingAcquisition: true,
      // Its possible that if I send the definitions request to the light weight syntax server, then it will never perform the semantic definition
      // How do I specify which server to use for the request?
      tsserver: {
        useSyntaxServer: "never",
      },
    },
    workspaceFolders: null,
  };
  connection.listen();
  connection.onNotification("window/logMessage", (params: LogMessageParams) => {
    let level = params.type.toString();
    if (params.type === 1) {
      level = "ERROR";
    }
    if (params.type === 2) {
      level = "WARN";
    }
    if (params.type === 3) {
      level = "INFO";
    }
    if (params.type === 4) {
      level = "DEBUG";
    }
    // I am using console error because I like having the red color
    // in the debugger console to indicate these are the messages from the language server. I like
    // the contrast it provides. I'm using the default blue color from console.log for messages
    // coming from my code that is interacting with the language server.
    console.error(`[${level}] ${params.message}`);
  });
  const { capabilities }: InitializeResult = await connection.sendRequest(
    "initialize",
    initializeParams
  );
  console.assert(capabilities.definitionProvider);
  console.assert(
    capabilities.declarationProvider,
    "Server does not support textDocument/declaration"
  );
  console.assert(
    capabilities.semanticTokensProvider,
    "Server does not support semanaticTokensProvider"
  );
  await connection.sendNotification("initialized", {});
}

// Open a document and wait for diagnostics
async function openDocumentAndWaitForDiagnostics(
  connection: any,
  doc: TextDocumentItem
) {
  const params: DidOpenTextDocumentParams = {
    textDocument: doc,
  };
  connection.sendNotification("textDocument/didOpen", params);
}

// Helper function to get the last position of a string in the document
function lastPosition(doc: TextDocumentItem, searchString: string) {
  const lines = doc.text.split("\n");
  for (let i = lines.length - 1; i >= 0; i--) {
    const index = lines[i].lastIndexOf(searchString);
    if (index !== -1) {
      return { line: i, character: index };
    }
  }
  return { line: 0, character: 0 }; // Default to beginning if not found
}

// Run the test
async function runTest() {
  await initializeServer();

  // I want to note that if module1.ts and module2.ts existed on disk, then we would not have to
  // send textDocument/didOpen notifications.

  const doc2: TextDocumentItem = {
    uri: "file:///Users/user/src/nobody/007%20lean%20library/vendor/typescript-language-server/test-data/module1.ts",
    languageId: "typescript",
    version: 1,
    text: `
export function doStuff(): boolean {
  return true;
}
    `,
  };
  await openDocumentAndWaitForDiagnostics(connection, doc2);

  const doc: TextDocumentItem = {
    // uri: uri("module2.ts"),
    uri: "file:///Users/user/src/nobody/007%20lean%20library/vendor/typescript-language-server/test-data/module2.ts",
    languageId: "typescript",
    version: 1,
    // text: readContents(path.resolve("test-data/module2.ts")),
    text: `
import { doStuff } from "/Users/user/src/nobody/007 lean library/vendor/typescript-language-server/test-data/module1";

/**
 * A regular class
 */
export class MyClass {
    doSomething() {
        return doStuff();
    }
}

    `,
  };

  await openDocumentAndWaitForDiagnostics(connection, doc);

  const definitionParams: DefinitionParams = {
    textDocument: { uri: doc.uri },
    position: lastPosition(doc, "doStuff"),
  };

  const result: Location | Location[] | LocationLink | LocationLink[] =
    await connection.sendRequest("textDocument/definition", definitionParams);


  // if isArray result take the first element
  if (Array.isArray(result)) {
    if ("targetUri" in result[0]) {
      printDefinitionRange(result[0]);
    }
  }
  console.log(JSON.stringify(result, null, 2));

  function printDefinitionRange(result: LocationLink) {
    const range = result.targetSelectionRange;
    const start = result.targetSelectionRange.start;
    const end = result.targetSelectionRange.end;
    const fs = require("fs");
    const file = fs.readFileSync(URI.parse(result.targetUri).fsPath, "utf-8");
    const lines = file.split("\n");
    const selectedLines = lines.slice(start.line - 1, end.line);
    console.log("selected range:");
    console.log("````");
    console.log(selectedLines.join("\n"));
    console.log("````");
  }

  serverProcess.kill();
}

runTest().catch((error) => {
  console.error("Error:", error);
  serverProcess.kill();
});