# %%
import json
from subprocess import Popen, PIPE
import re
from typing import Any
import uuid
from pathlib import Path

# Path to the Rust Analyzer executable and the file to analyze
rust_analyzer_path = "rust-analyzer"
file_path = Path("src/main.rs").absolute()


def extract_content_length(response: str) -> int:
    # Split the response into lines
    lines = response.split("\r\n")

    # Find the line that starts with "Content-Length:"
    content_length_line = next(
        (line for line in lines if line.startswith("Content-Length:")), None
    )

    if content_length_line is not None:
        # Extract the number from the line using a regular expression
        match = re.search(r"Content-Length: (\d+)", content_length_line)
        if match:
            return int(match.group(1))
        else:
            raise ValueError("No number found in Content-Length line")
    else:
        raise ValueError("No Content-Length line found")


def send_request(server: Popen, request: dict[str, Any]) -> Any:
    send_notification(server, request)
    return receive_response(server)


def receive_response(server: Popen) -> Any:
    response = ""
    assert server.stdout is not None
    while not response.endswith("\r\n\r\n"):
        response += server.stdout.read(1).decode()
    content_length = extract_content_length(response)
    return json.loads(server.stdout.read(content_length).decode())


def send_notification(server: Popen, request: dict[str, Any]) -> None:
    request_json = json.dumps(request)
    header = f"Content-Length: {len(request_json.encode())}\r\n\r\n"
    assert server.stdin is not None
    server.stdin.write(header.encode())
    server.stdin.write(request_json.encode())
    server.stdin.flush()


# %%
# Start the Rust Analyzer server
server = Popen(
    [rust_analyzer_path],
    stdin=PIPE,
    stdout=PIPE,
)

# %%
# Initialize the LSP client
initialize_params: dict[str, Any] = {
    "processId": None,
    "capabilities": {},
    "initializationOptions": {"checkOnSave": {"enable": False}},
    "rootUri": f"file://{file_path.parent}",
}
initalize_request_id = uuid.uuid4()
initialize_request = {
    "jsonrpc": "2.0",
    "id": str(initalize_request_id),
    "method": "initialize",
    "params": initialize_params,
}

result = send_request(server, initialize_request)
print(result)
# %%
send_notification(server, {"jsonrpc": "2.0", "method": "initialized"})

# # %%
# # Send textDocument/didOpen notification
did_open_params = {
    "textDocument": {
        "uri": f"file://{file_path}",
        "languageId": "rust",
        "version": 1,
        "text": file_path.read_text(),
    }
}
did_open_notification = {
    "jsonrpc": "2.0",
    "method": "textDocument/didOpen",
    "params": did_open_params,
}

send_notification(server, did_open_notification)
# %%
result = receive_response(server)
print(result)

# %%
# Send textDocument/didChange notification
did_change_params = {
    "textDocument": {
        "uri": f"file://{file_path}",
        "version": 2,
    },
    "contentChanges": [
        {
            "text": file_path.read_text(),
        }
    ],
}
did_change_notification = {
    "jsonrpc": "2.0",
    "method": "textDocument/didChange",
    "params": did_change_params,
}

send_notification(server, did_change_notification)

# %%
result = receive_response(server)
print(result)

# %%
exit_request = json.dumps(
    {
        "jsonrpc": "2.0",
        "method": "exit",
    }
)
send_notification(server, exit_request)

server.terminate()