feakin
diff --git a/fkl_lsp/Cargo.toml b/fkl_lsp/Cargo.toml
@@ -4,6 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+fkl-parser = { path = "../fkl_parser", version = "0.2.0" }
+
 lsp = { version = "0.93", package = "lsp-types" }
 lsp-text = { version = "0.9", features = ["tree-sitter"] }
 tree-sitter = { version = "0.9", package = "tree-sitter-facade" }
@@ -13,8 +15,12 @@ env_logger = "0.9"
 ropey = "1.0"
 serde_json = "1.0"
 tokio = { version = "1.17.0", features = ["full"] }
+tokio-util = { version = "0.7.4", features = ["compat"], optional = true }
 tower-lsp = { version = "0.17.0"}
 serde = { version = "1.0", features = ["derive"] }
 dashmap = "5.4"
 log = "0.4"
 im-rc = "15.0"
+
+[features]
+platform-agnostic = ["tokio-util"]
diff --git a/fkl_lsp/src/main.rs b/fkl_lsp/src/main.rs
@@ -2,33 +2,140 @@ use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::*;
 use tower_lsp::{Client, LanguageServer, LspService, Server};
 
+use dashmap::DashMap;
+
+use fkl_parser::ast_parse;
+
 #[derive(Debug)]
-struct Backend {
-  client: Client,
+pub struct Backend {
+    client: Client,
+
+    content_cache: DashMap<String, String>,
+}
+
+impl Backend {
+    pub fn new(client: Client) -> Self {
+        Self {
+            client,
+            content_cache: DashMap::new(),
+        }
+    }
+
+    async fn onchange(&self, params: TextDocumentItem) {
+        self.client
+            .log_message(MessageType::INFO, "text changed!")
+            .await;
+
+        let uri = params.uri;
+        let text = params.text;
+
+        self.content_cache.insert(uri.to_string(), text);
+
+        // TODO(CGQAQ): parsing raw text to AST using fkl_parser
+        let ast = ast_parse(&text).unwrap();
+    }
 }
 
 #[tower_lsp::async_trait]
 impl LanguageServer for Backend {
-  async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
-    Ok(InitializeResult::default())
-  }
-
-  async fn initialized(&self, _: InitializedParams) {
-    self.client
-      .log_message(MessageType::INFO, "server initialized!")
-      .await;
-  }
-
-  async fn shutdown(&self) -> Result<()> {
-    Ok(())
-  }
+    async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
+        Ok(InitializeResult {
+            server_info: Some(ServerInfo {
+                name: "fkl_lsp".to_string(),
+                version: Some(env!("CARGO_PKG_VERSION").to_string()),
+            }),
+            capabilities: ServerCapabilities {
+                text_document_sync: Some(TextDocumentSyncCapability::Kind(
+                    TextDocumentSyncKind::FULL,
+                )),
+                completion_provider: Some(CompletionOptions {
+                    resolve_provider: Some(false),
+                    trigger_characters: Some(vec![
+                        ".".to_string(),
+                        " ".to_string(),
+                        "\n".to_string(),
+                    ]),
+                    work_done_progress_options: Default::default(),
+                    all_commit_characters: None,
+                    ..Default::default()
+                }),
+                hover_provider: Some(HoverProviderCapability::Simple(true)),
+                workspace: Some(WorkspaceServerCapabilities {
+                    workspace_folders: Some(WorkspaceFoldersServerCapabilities {
+                        supported: Some(true),
+                        change_notifications: Some(OneOf::Left(true)),
+                    }),
+                    file_operations: None,
+                }),
+                ..ServerCapabilities::default()
+            },
+            ..Default::default()
+        })
+    }
+
+    async fn initialized(&self, _: InitializedParams) {
+        self.client
+            .log_message(MessageType::INFO, "server initialized!")
+            .await;
+    }
+
+    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        self.client
+            .log_message(MessageType::INFO, "text opened!")
+            .await;
+        self.onchange(params.text_document).await;
+    }
+
+    async fn did_change(&self, mut params: DidChangeTextDocumentParams) {
+        self.client
+            .log_message(MessageType::INFO, "text changed!")
+            .await;
+        self.onchange(TextDocumentItem {
+            uri: params.text_document.uri,
+            language_id: "fkl".to_string(),
+            text: std::mem::take(&mut params.content_changes[0].text),
+            version: params.text_document.version,
+        })
+        .await;
+    }
+
+    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        self.client
+            .log_message(MessageType::INFO, "completion")
+            .await;
+        self.client
+            .log_message(MessageType::INFO, format!("{:?}", params))
+            .await;
+
+        Ok(None)
+    }
+
+    async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {
+        self.client.log_message(MessageType::INFO, "hover").await;
+        self.client
+            .log_message(MessageType::INFO, format!("{:?}", params))
+            .await;
+
+        Ok(None)
+    }
+
+    async fn shutdown(&self) -> Result<()> {
+        self.client
+            .log_message(MessageType::WARNING, "server shutting down!")
+            .await;
+        Ok(())
+    }
 }
 
 #[tokio::main]
 async fn main() {
-  let stdin = tokio::io::stdin();
-  let stdout = tokio::io::stdout();
+    #[cfg(feature = "runtime-agnostic")]
+    use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
+
+    let (stdin, stdout) = (tokio::io::stdin(), tokio::io::stdout());
+    #[cfg(feature = "runtime-agnostic")]
+    let (stdin, stdout) = (stdin.compat(), stdout.compat_write());
 
-  let (service, socket) = LspService::new(|client| Backend { client });
-  Server::new(stdin, stdout, socket).serve(service).await;
+    let (service, socket) = LspService::new(|client| Backend::new(client));
+    Server::new(stdin, stdout, socket).serve(service).await;
 }