package com.vogella.lsp.asciidoc.server;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class AsciidocDocumentModel {

    // A single line of the document
    public record DocumentLine(int line, String text) {
    }

    private final List<DocumentLine> lines = new ArrayList<>();

    public AsciidocDocumentModel(String text) {
        int lineNumber = 0;
        for (String lineText : text.lines().toList()) {
            lines.add(new DocumentLine(lineNumber++, lineText));
        }
    }

    // Returns the content of the given line or null if the line does not exist
    public String getLineContent(int lineNumber) {
        if (lineNumber < 0 || lineNumber >= lines.size()) {
            return null;
        }
        return lines.get(lineNumber).text();
    }

    public List<DocumentLine> getResolvedLines() {
        return Collections.unmodifiableList(this.lines);
    }
}

package com.vogella.lsp.asciidoc.server;

import java.util.concurrent.CompletableFuture;

import org.eclipse.lsp4j.CompletionOptions;
import org.eclipse.lsp4j.InitializeParams;
import org.eclipse.lsp4j.InitializeResult;
import org.eclipse.lsp4j.ServerCapabilities;
import org.eclipse.lsp4j.TextDocumentSyncKind;
import org.eclipse.lsp4j.services.LanguageClient;
import org.eclipse.lsp4j.services.LanguageServer;
import org.eclipse.lsp4j.services.TextDocumentService;
import org.eclipse.lsp4j.services.WorkspaceService;

public class AsciidocLanguageServer implements LanguageServer {

    private final TextDocumentService textService;
    private final WorkspaceService workspaceService;
    private volatile boolean shutdownRequested;
    LanguageClient client;

    public AsciidocLanguageServer() {
        textService = new AsciidocTextDocumentService(this);
        workspaceService = new AsciidocWorkspaceService();
    }

    /**
     * Tells the client which functionality this server supports
     */
    @Override
    public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
        ServerCapabilities capabilities = new ServerCapabilities();
        capabilities.setTextDocumentSync(TextDocumentSyncKind.Full);
        capabilities.setCompletionProvider(new CompletionOptions());
        return CompletableFuture.completedFuture(new InitializeResult(capabilities));
    }

    @Override
    public CompletableFuture<Object> shutdown() {
        // The client announces that it will exit soon, free resources here
        shutdownRequested = true;
        return CompletableFuture.completedFuture(null);
    }

    @Override
    public void exit() {
        // A standalone server would terminate its process here, for example via
        // System.exit(shutdownRequested ? 0 : 1);
        // This server runs inside the IDE process, so the connection provider
        // stops the launcher instead
        if (!shutdownRequested) {
            System.err.println("exit received without a previous shutdown request");
        }
    }

    @Override
    public TextDocumentService getTextDocumentService() {
        return textService;
    }

    @Override
    public WorkspaceService getWorkspaceService() {
        return workspaceService;
    }

    public void setRemoteProxy(LanguageClient remoteProxy) {
        this.client = remoteProxy;
    }
}

package com.vogella.lsp.asciidoc.server;

import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;

import org.eclipse.lsp4j.CompletionItem;
import org.eclipse.lsp4j.CompletionList;
import org.eclipse.lsp4j.CompletionParams;
import org.eclipse.lsp4j.DidChangeTextDocumentParams;
import org.eclipse.lsp4j.DidCloseTextDocumentParams;
import org.eclipse.lsp4j.DidOpenTextDocumentParams;
import org.eclipse.lsp4j.DidSaveTextDocumentParams;
import org.eclipse.lsp4j.jsonrpc.messages.Either;
import org.eclipse.lsp4j.services.TextDocumentService;

public class AsciidocTextDocumentService implements TextDocumentService {

    private final Map<String, AsciidocDocumentModel> docs = new ConcurrentHashMap<>();

    private final AsciidocLanguageServer languageServer;

    public AsciidocTextDocumentService(AsciidocLanguageServer languageServer) {
        this.languageServer = languageServer;
    }

    @Override
    public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(CompletionParams position) {
        // Example: provide completions for AsciiDoc elements
        CompletionItem image = new CompletionItem("image::");
        CompletionItem include = new CompletionItem("include::");
        return CompletableFuture.completedFuture(Either.forLeft(List.of(image, include)));
    }

    @Override
    public void didOpen(DidOpenTextDocumentParams params) {
        AsciidocDocumentModel model = new AsciidocDocumentModel(params.getTextDocument().getText());
        docs.put(params.getTextDocument().getUri(), model);
    }

    @Override
    public void didChange(DidChangeTextDocumentParams params) {
        AsciidocDocumentModel model = new AsciidocDocumentModel(params.getContentChanges().get(0).getText());
        docs.put(params.getTextDocument().getUri(), model);
    }

    @Override
    public void didClose(DidCloseTextDocumentParams params) {
        docs.remove(params.getTextDocument().getUri());
    }

    @Override
    public void didSave(DidSaveTextDocumentParams params) {
    }
}

package com.vogella.lsp.asciidoc.server;

import org.eclipse.lsp4j.DidChangeConfigurationParams;
import org.eclipse.lsp4j.DidChangeWatchedFilesParams;
import org.eclipse.lsp4j.services.WorkspaceService;

public class AsciidocWorkspaceService implements WorkspaceService {


    @Override
    public void didChangeConfiguration(DidChangeConfigurationParams params) {
    }

    @Override
    public void didChangeWatchedFiles(DidChangeWatchedFilesParams params) {
    }

}

package com.vogella.lsp.asciidoc.server;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.eclipse.lsp4j.jsonrpc.Launcher;
import org.eclipse.lsp4j.launch.LSPLauncher;
import org.eclipse.lsp4j.services.LanguageClient;

public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        startServer(System.in, System.out);
    }

    public static void startServer(InputStream in, OutputStream out) throws InterruptedException, ExecutionException {
        AsciidocLanguageServer server = new AsciidocLanguageServer();   (1)
        Launcher<LanguageClient> launcher = LSPLauncher.createServerLauncher(server, in, out); (2)
        Future<Void> startListening = launcher.startListening();
        server.setRemoteProxy(launcher.getRemoteProxy());               (3)
        startListening.get();                                           (4)
    }
}

capabilities.setDocumentSymbolProvider(Boolean.TRUE);

@Override
public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>> documentSymbol(
        DocumentSymbolParams params) {
    return CompletableFuture.supplyAsync(() -> {
        // Create a symbol for a class
        DocumentSymbol classSymbol = new DocumentSymbol();
        classSymbol.setName("MyClass");
        classSymbol.setKind(SymbolKind.Class);
        classSymbol.setRange(new Range(new Position(0, 0), new Position(0, 10)));
        classSymbol.setSelectionRange(new Range(new Position(0, 0), new Position(0, 10)));

        // Create a symbol for a method inside the class
        DocumentSymbol methodSymbol = new DocumentSymbol();
        methodSymbol.setName("myMethod");
        methodSymbol.setKind(SymbolKind.Method);
        methodSymbol.setRange(new Range(new Position(1, 0), new Position(1, 10)));
        methodSymbol.setSelectionRange(new Range(new Position(1, 0), new Position(1, 10)));

        // Add the method symbol as a child of the class symbol
        classSymbol.setChildren(List.of(methodSymbol));

        List<Either<SymbolInformation, DocumentSymbol>> symbols = new ArrayList<>();
        symbols.add(Either.forRight(classSymbol));
        return symbols;
    });
}

capabilities.setHoverProvider(Boolean.TRUE);

@Override
public CompletableFuture<Hover> hover(HoverParams params) {
    return CompletableFuture.supplyAsync(() -> {
        // Get the position where the hover request was made
        Position position = params.getPosition();

        // We hover only after the first line
        if (position.getLine() > 0) {

            String content = """
                    **Important AsciiDoc elements:**

                    * `image::` - Defines an image element in AsciiDoc files.
                    * `include::` - Includes other AsciiDoc files in the current one.

                    **Usage example:**
                    ```asciidoc
                    image::path/to/image.png[]
                    include::example.adoc[]
                    ```
                    """;

            // Create the Hover object with content in Markdown format
            Hover hover = new Hover();
            hover.setContents(new MarkupContent(MarkupKind.MARKDOWN, content));
            return hover;
        }

        // No hover for the first line
        return null;
    });
}

capabilities.setDefinitionProvider(Boolean.TRUE);

@Override
public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> definition(
        DefinitionParams params) {

    // Get the document URI and retrieve the model
    AsciidocDocumentModel model = this.docs.get(params.getTextDocument().getUri());
    if (model == null) {
        return CompletableFuture.completedFuture(Either.forLeft(Collections.emptyList()));
    }

    // Get the line where the cursor is located
    int line = params.getPosition().getLine();
    int character = params.getPosition().getCharacter();

    // Retrieve the content of the line
    String lineContent = model.getLineContent(line);
    if (lineContent == null) {
        return CompletableFuture.completedFuture(Either.forLeft(Collections.emptyList()));
    }

    // Find the word under the cursor
    String wordUnderCursor = getWordAtPosition(lineContent, character);

    // Resolve this word to locations, the resolution logic depends on your
    // language, for example file-based links or symbol lookup
    List<Location> locations = findDefinitionLocations(wordUnderCursor);

    return CompletableFuture.completedFuture(Either.forLeft(locations));
}

/**
 * Finds the word under the cursor in a given line of text using simple word
 * boundaries.
 */
private String getWordAtPosition(String lineContent, int character) {
    int start = character;
    int end = character;

    // Find the start of the word (left of the cursor)
    while (start > 0 && Character.isLetterOrDigit(lineContent.charAt(start - 1))) {
        start--;
    }

    // Find the end of the word (right of the cursor)
    while (end < lineContent.length() && Character.isLetterOrDigit(lineContent.charAt(end))) {
        end++;
    }

    return lineContent.substring(start, end);
}

/**
 * Resolves the definition location(s) for a given word. This is a stub which
 * always returns the same location, implement your own resolution logic here.
 */
private List<Location> findDefinitionLocations(String word) {
    List<Location> locations = new ArrayList<>();
    Location location = new Location();
    location.setUri("file:///path/to/definitionFile");
    location.setRange(new Range(new Position(5, 0), new Position(5, 10)));
    locations.add(location);
    return locations;
}

private List<Diagnostic> validate(AsciidocDocumentModel model) {
    List<Diagnostic> diagnostics = new ArrayList<>();

    // Simulate finding a placeholder issue
    for (int i = 0; i < model.getResolvedLines().size(); i++) {
        String line = model.getResolvedLines().get(i).text();
        int index = line.indexOf("PLACEHOLDER_TEXT");
        if (index != -1) {
            // Create a diagnostic for the placeholder text issue
            Diagnostic diagnostic = new Diagnostic();
            diagnostic.setSeverity(DiagnosticSeverity.Warning);
            diagnostic.setMessage("Found placeholder text that should be replaced.");
            diagnostic.setCode("placeholder.text.issue");
            diagnostic.setRange(
                    new Range(new Position(i, index), new Position(i, index + "PLACEHOLDER_TEXT".length())));
            diagnostics.add(diagnostic);
        }
    }

    return diagnostics;
}

@Override
public void didOpen(DidOpenTextDocumentParams params) {
    AsciidocDocumentModel model = new AsciidocDocumentModel(params.getTextDocument().getText());
    docs.put(params.getTextDocument().getUri(), model);
    CompletableFuture.runAsync(() -> languageServer.client
            .publishDiagnostics(new PublishDiagnosticsParams(params.getTextDocument().getUri(), validate(model))));
}

@Override
public void didChange(DidChangeTextDocumentParams params) {
    AsciidocDocumentModel model = new AsciidocDocumentModel(params.getContentChanges().get(0).getText());
    docs.put(params.getTextDocument().getUri(), model);
    CompletableFuture.runAsync(() -> languageServer.client
            .publishDiagnostics(new PublishDiagnosticsParams(params.getTextDocument().getUri(), validate(model))));
}

capabilities.setCodeActionProvider(Boolean.TRUE);

@Override
public CompletableFuture<List<Either<Command, CodeAction>>> codeAction(CodeActionParams params) {
    List<Either<Command, CodeAction>> actions = new ArrayList<>();

    // Check the diagnostics for the current document
    for (Diagnostic diagnostic : params.getContext().getDiagnostics()) {
        if ("placeholder.text.issue".equals(diagnostic.getCode().getLeft())) {
            // Create a text edit for replacing the placeholder
            TextEdit edit = new TextEdit();
            edit.setRange(diagnostic.getRange());
            edit.setNewText("replacement_text");

            // Create a workspace edit
            WorkspaceEdit workspaceEdit = new WorkspaceEdit();
            workspaceEdit.setChanges(Collections.singletonMap(params.getTextDocument().getUri(), List.of(edit)));

            // Create the code action
            CodeAction codeAction = new CodeAction("Replace placeholder with 'replacement_text'");
            codeAction.setKind(CodeActionKind.QuickFix);
            codeAction.setEdit(workspaceEdit);

            actions.add(Either.forRight(codeAction));
        }
    }

    return CompletableFuture.completedFuture(actions);
}

capabilities.setCodeLensProvider(new CodeLensOptions(false));

// Returns all lines of the document as strings
public List<String> getLines() {
    List<String> result = new ArrayList<>();
    for (DocumentLine line : lines) {
        result.add(line.text());
    }
    return Collections.unmodifiableList(result);
}

@Override
public CompletableFuture<List<? extends CodeLens>> codeLens(CodeLensParams params) {
    return CompletableFuture.supplyAsync(() -> {
        // Retrieve the document from the model
        String uri = params.getTextDocument().getUri();
        AsciidocDocumentModel model = docs.get(uri);
        if (model == null) {
            return Collections.emptyList();
        }

        List<CodeLens> codeLenses = new ArrayList<>();
        List<String> lines = model.getLines();

        // Scan for "TODO" comments
        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i);
            int todoIndex = line.indexOf("TODO");
            if (todoIndex != -1) {
                // Define the range for the TODO
                Range range = new Range(new Position(i, todoIndex), new Position(i, todoIndex + "TODO".length()));

                // Create a CodeLens with a command
                Command command = new Command("Resolve TODO", "example.resolveTodo",
                        Collections.singletonList("Resolve the TODO at line " + (i + 1)));

                codeLenses.add(new CodeLens(range, command, null));
            }
        }

        return codeLenses;
    });
}