use crate::core::hdlparam::HdlParam;
use crate::core::primitive_parser::PrimitiveText;
use crate::core::sv_parser::make_fast_from_syntaxtree;
use crate::core::vhdl_parser::make_fast_from_design_file;
use crate::core::vhdl_parser::vhdl_parse_str;
use crate::definition::def_types::*;
use crate::definition::get_scopes_from_syntax_tree;
use crate::definition::get_scopes_from_vhdl_fast;
use crate::diagnostics::{get_diagnostics, is_hidden};
use crate::server::LSPServer;
use crate::server::ProjectConfig;
use crate::utils::to_escape_path;
#[allow(unused)]
use log::info;
use log::{debug, error};
use pathdiff::diff_paths;
use ropey::{Rope, RopeSlice};
use serde_json::Value;
use std::cmp::min;
use std::collections::HashMap;
use std::env::current_dir;
#[allow(unused)]
use std::ops::Deref;
use std::ops::Range as StdRange;
use std::path::Path;
use std::path::PathBuf;
use std::str::FromStr;
use std::sync::{Arc, Condvar, Mutex, RwLock};
use std::thread;
use sv_parser::*;
use vhdl_lang::Project;
use thread::JoinHandle;
use tower_lsp::lsp_types::*;
use walkdir::WalkDir;

impl LSPServer {
    pub fn did_open(&self, params: DidOpenTextDocumentParams) -> PublishDiagnosticsParams {
        let document: TextDocumentItem = params.text_document;
        let uri = document.uri.clone();

        // check if doc is already added
        if self.srcs.names.read().unwrap().contains_key(&document.uri) {
            // convert to a did_change that replace the entire text
            self.did_change(DidChangeTextDocumentParams {
                text_document: VersionedTextDocumentIdentifier::new(document.uri, document.version),
                content_changes: vec![TextDocumentContentChangeEvent {
                    range: None,
                    range_length: None,
                    text: document.text,
                }],
            });
        } else {
            self.srcs.add(self, document);
        }
        // diagnostics
        let urls = self.srcs.names.read().unwrap().keys().cloned().collect();
        let file_id = self.srcs.get_id(&uri);
        if let Some(file) = self.srcs.get_file(file_id) {
            let file = file.read().unwrap();
            get_diagnostics(uri, &file.text, urls, &self.conf.read().unwrap())
        } else {
            PublishDiagnosticsParams {
                uri,
                diagnostics: Vec::new(),
                version: None,
            }
        }
    }

    pub fn did_change(&self, params: DidChangeTextDocumentParams) {
        let file_id = self.srcs.get_id(&params.text_document.uri);
        if let Some(file) = self.srcs.get_file(file_id) {
            let mut file = file.write().unwrap();

            // 根据输入的 change 动态更新对应的代码的文本片段
            for change in params.content_changes {
                if change.range.is_none() {
                    file.text = Rope::from_str(&change.text);
                } else {
                    file.text.apply_change(&change);
                }
                file.last_change_range = change.range;
            }
            file.version = params.text_document.version;
            drop(file);
    
            // invalidate syntaxtree and wake parse thread
            let meta_data = self.srcs.get_meta_data(file_id).unwrap();
            let (lock, cvar) = &*meta_data.read().unwrap().valid_parse;
            let mut valid = lock.lock().unwrap();
            *valid = false;
            cvar.notify_all();
        }
    }

    pub fn did_save(&self, params: DidSaveTextDocumentParams) -> PublishDiagnosticsParams {
        let urls = self.srcs.names.read().unwrap().keys().cloned().collect();
        let file_id = self.srcs.get_id(&params.text_document.uri);
        let uri = params.text_document.uri.clone();

        if let Some(file) = self.srcs.get_file(file_id) {
            let file = file.read().unwrap();
            get_diagnostics(
                uri,
                &file.text,
                urls,
                &self.conf.read().unwrap(),
            )
        } else {
            PublishDiagnosticsParams {
                uri,
                diagnostics: Vec::new(),
                version: None,
            }
        }
    }

    pub fn did_delete_files(&self, params: DeleteFilesParams) {
        // 删除 sources 内对应的文件
        for file_delete in params.files {
            let url = Url::parse(&file_delete.uri).unwrap();
            let pathbuf = PathBuf::from_str(url.path()).unwrap();
            let pathbuf = to_escape_path(&pathbuf);
            let path_string = pathbuf.to_str().unwrap();

            {
                let mut fast_sync_controller = self.srcs.fast_sync_controller.write().unwrap();
                fast_sync_controller.remove(path_string);
            }

            self.srcs.hdl_param.delete_file(path_string);

            {
                let mut names = self.srcs.names.write().unwrap();
                names.remove(&url);
            }

            {
                let mut global_scope = self.srcs.scope_tree.write().unwrap();
                match &mut *global_scope {
                    Some(scope) => {
                        scope.defs.retain(|x| x.url() != url);
                        scope.scopes.retain(|x| x.url() != url);
                    },
                    None => {},
                }
            }

            {
                let mut vhdl_project = self.srcs.vhdl_project.write().unwrap();
                match &mut *vhdl_project {
                    Some(vhdl_project) => {
                        let config_file_strs = vhdl_project.config_file_strs.clone()
                                                            .into_iter()
                                                            .filter(|x| x != path_string)
                                                            .collect::<Vec<String>>();
                        let mut messages = Vec::new();
                        let config_str = format!(
                            r#"
                                [libraries]
                                digital_lsp.files = [{}]
                            "#, config_file_strs.join(",")
                        );
                        let config = vhdl_lang::Config::from_str(&config_str, Path::new(""));
                        if let Ok(mut config) = config {
                            config.append(&vhdl_project.std_config, &mut messages);
                            let mut project = Project::from_config(config, &mut messages);
                            project.analyse();
                            *vhdl_project = VhdlProject { project, std_config: vhdl_project.std_config.clone(), config_file_strs };
                        }
                    }
                    None => ()
                }
            }
        }
    }
}

/// The Source struct holds all file specific information
pub struct Source {
    /// id
    pub id: usize,
    /// uri
    pub uri: Url,
    /// 代码文本信息
    pub text: Rope,
    /// 版本号
    pub version: i32,
    /// 解析的 IR，分为 DesignFile（VHDL）和 SyntaxTree（SV）两种
    pub parse_ir: Option<ParseIR>,
    /// 用于在解析失败时恢复解析的量
    pub last_change_range: Option<Range>,
}

pub enum ParseIR {
    /// 基于 vhdl-parser 的IR，存放 VHDL
    #[allow(unused)]
    DesignFile(vhdl_lang::ast::DesignFile),
    /// 存放 sv 的 IR
    SyntaxTree(sv_parser::SyntaxTree)
}


/// file metadata, including whether or not the syntax tree is up to date
pub struct SourceMeta {
    pub id: usize,
    pub valid_parse: Arc<(Mutex<bool>, Condvar)>,
    #[allow(unused)]
    pub parse_handle: JoinHandle<()>,
}

/// find SystemVerilog/Verilog sources recursively from opened files
fn find_src_paths(dirs: &[PathBuf]) -> Vec<PathBuf> {
    let mut paths: Vec<PathBuf> = Vec::new();

    for dir in dirs {
        let walker = WalkDir::new(dir).into_iter();
        for entry in walker.filter_entry(|e| !is_hidden(e)) {
            let entry = entry.unwrap();
            if entry.file_type().is_file() && entry.path().extension().is_some() {
                let extension = entry.path().extension().unwrap();

                if extension == "sv" || extension == "svh" || extension == "v" || extension == "vh" {
                    let entry_path = entry.path().to_path_buf();
                    if !paths.contains(&entry_path) {
                        paths.push(entry_path);
                    }
                }
            }
        }
    }
    paths
}

/// The Sources struct manages all source files
pub struct Sources {
    // all files
    pub files: Arc<RwLock<Vec<Arc<RwLock<Source>>>>>,
    // map file urls to id
    pub names: Arc<RwLock<HashMap<Url, usize>>>,
    // file metadata
    pub meta: Arc<RwLock<Vec<Arc<RwLock<SourceMeta>>>>>,
    /// scope tree 类型的树形结构，用于提供 sv 的 lsp
    pub scope_tree: Arc<RwLock<Option<GenericScope>>>,
    // vhdl project, store vhdl design files, do lsp
    pub vhdl_project: Arc<RwLock<Option<VhdlProject>>>,
    // include directories, passed to parser to resolve `include
    pub include_dirs: Arc<RwLock<Vec<PathBuf>>>,
    // primitive instance text
    pub primitive_text: Arc<PrimitiveText>,
    /// hdlparam 后端实现
    pub hdl_param: Arc<HdlParam>,
    // 同步解析线程和发送 fast 请求的
    pub fast_sync_controller: Arc<RwLock<HashMap<String, Arc<RwLock<bool>>>>>,
    // lsp 配置相关的
    pub lsp_configuration: Arc<RwLock<HashMap<String, Value>>>
}

impl std::default::Default for Sources {
    fn default() -> Self {
        Self::new()
    }
}

impl Sources {
    pub fn new() -> Self {
        Self {
            files: Arc::new(RwLock::new(Vec::new())),
            names: Arc::new(RwLock::new(HashMap::new())),
            meta: Arc::new(RwLock::new(Vec::new())),
            scope_tree: Arc::new(RwLock::new(None)),
            vhdl_project: Arc::new(RwLock::new(None)),
            include_dirs: Arc::new(RwLock::new(Vec::new())),
            primitive_text: Arc::new(PrimitiveText::new()),
            hdl_param: Arc::new(HdlParam::new()),
            fast_sync_controller: Arc::new(RwLock::new(HashMap::<String, Arc<RwLock<bool>>>::new())),
            lsp_configuration: Arc::new(RwLock::new(HashMap::<String, Value>::new()))
        }
    }

    pub fn init_primitive(&self, tool_chain: &str, extension_path: &str) {
        let primitive_bin = format!("{}/resources/dide-lsp/static/{}/primitive.bin", extension_path, tool_chain);
        info!("attempt to find primitives in {}", primitive_bin);
        
        if let Some(primitive_xml) = crate::core::primitive_parser::load_primitive_bin(&primitive_bin) {
            let primitive_text_handle = self.primitive_text.clone();
            let hdl_param_handle = self.hdl_param.clone();
            for (name, template) in primitive_xml.name_to_template {
                // use "primitive/name" as a fake path
                let fake_path = "primitive/".to_string() + &name;
                hdl_param_handle.update_fast(fake_path, template.fast);
                primitive_text_handle.update_text(&name, &template.text);
            }
        }
    }

    /// 增加一个 hdl 文件，并为该文件添加单独的解析线程
    pub fn add(&self, server: &LSPServer, doc: TextDocumentItem) {
        // 对于当前的文件增加一个解析线程，不断进行解析和同步
        #[allow(clippy::mutex_atomic)] // https://github.com/rust-lang/rust-clippy/issues/1516
        let valid_parse = Arc::new((Mutex::new(false), Condvar::new()));
        let valid_parse2 = valid_parse.clone();
        let mut files = self.files.write().unwrap();
        let source = Arc::new(RwLock::new(Source {
            id: files.len(),
            uri: doc.uri.clone(),
            text: Rope::from_str(&doc.text),
            version: doc.version,
            parse_ir: None,
            last_change_range: None,
        }));
        let source_handle = source.clone();
        let scope_handle = self.scope_tree.clone();
        let project_handle = self.vhdl_project.clone();
        let hdl_param_handle = self.hdl_param.clone();
        let inc_dirs = self.include_dirs.clone();

        let uri = doc.uri.clone();

        let conf = server.conf.clone();

        info!("launch worker to parse {:?}", doc.uri.to_string());
        let language_id = doc.language_id.to_string();

        // 新建一个 fast controller 用于控制下方的解析线程和外部的请求函数
        let pathbuf = PathBuf::from_str(&doc.uri.path()).unwrap();
        let pathbuf = to_escape_path(&pathbuf);
        let path_string = pathbuf.to_str().unwrap();
        let mut fast_controller = self.fast_sync_controller.write().unwrap();
        let fast_lock = Arc::new(RwLock::new(true));
        fast_controller.insert(path_string.to_string(), fast_lock.clone());
        drop(fast_controller);

        // spawn parse thread
        let parse_handle = thread::spawn(move || {
            let (lock, cvar) = &*valid_parse2;
            loop {
                info!("do parse in {:?}, language_id: {:?}", uri.to_string(), language_id);

                // 此时 update fast 的地方为 write 会进行阻塞
                {
                    let _unused = fast_lock.read().unwrap();
                    // 从内存中直接获取增量更新系统维护的代码文本
                    let file = source_handle.read().unwrap();
                    let text = file.text.clone();
                    let uri = &file.uri.clone();

                    let range = &file.last_change_range.clone();
                    drop(file);
                    match language_id.as_str() {
                        "vhdl" => {
                            vhdl_parser_pipeline(
                                &conf,
                                &source_handle,
                                &scope_handle,
                                &project_handle,
                                &hdl_param_handle,
                                &text,
                                uri,
                            );
                        },
                        "verilog" | "systemverilog" => {
                            sv_parser_pipeline(
                                &conf,
                                &source_handle,
                                &scope_handle,
                                &hdl_param_handle,
                                &text,
                                uri,
                                range,
                                &inc_dirs.read().unwrap()
                            );
                        },
                        _ => {}
                    }
                }

                // 通过条件锁进行控制
                let mut valid = lock.lock().unwrap();
                *valid = true;
                cvar.notify_all();
                while *valid {
                    valid = cvar.wait(valid).unwrap();
                }
            }
        });
        files.push(source);
        let fid = files.len() - 1;
        self.meta
            .write()
            .unwrap()
            .push(Arc::new(RwLock::new(SourceMeta {
                id: fid,
                valid_parse,
                parse_handle,
            })));

        self.names.write().unwrap().insert(doc.uri, fid);
    }

    /// get file by id
    pub fn get_file(&self, id: usize) -> Option<Arc<RwLock<Source>>> {
        let files = self.files.read().ok()?;
        for file in files.iter() {
            let source = file.read().ok()?;
            if source.id == id {
                return Some(file.clone());
            }
        }
        None
    }

    /// get metadata by file id
    pub fn get_meta_data(&self, id: usize) -> Option<Arc<RwLock<SourceMeta>>> {
        let meta = self.meta.read().ok()?;
        for data in meta.iter() {
            let i = data.read().ok()?;
            if i.id == id {
                return Some(data.clone());
            }
        }
        None
    }

    /// wait for a valid parse
    pub fn wait_parse_ready(&self, id: usize, wait_valid: bool) {
        if let Some(file) = self.get_file(id) {
            let file = file.read().unwrap();
            if file.parse_ir.is_none() || wait_valid {
                drop(file);
                let meta_data = self.get_meta_data(id).unwrap();
                let (lock, cvar) = &*meta_data.read().unwrap().valid_parse;
                let mut valid = lock.lock().unwrap();
                while !*valid {
                    valid = cvar.wait(valid).unwrap();
                }
            }
        }
    }

    /// get file id from url
    pub fn get_id(&self, uri: &Url) -> usize {
        *self.names.read().unwrap().get(uri).unwrap()
    }

    /// compute identifier completions
    pub fn get_completions(
        &self,
        token: &str,
        byte_idx: usize,
        url: &Url,
    ) -> Option<CompletionList> {
        debug!("retrieving identifier completion for token: {}", &token);
        Some(CompletionList {
            is_incomplete: false,
            items: self
                .scope_tree
                .read()
                .ok()?
                .as_ref()?
                .get_completion(token, byte_idx, url),
        })
    }

    /// compute dot completions
    pub fn get_dot_completions(
        &self,
        token: &str,
        byte_idx: usize,
        url: &Url,
    ) -> Option<CompletionList> {
        debug!("retrieving dot completion for token: {}", &token);
        let tree = self.scope_tree.read().ok()?;
        Some(CompletionList {
            is_incomplete: false,
            items: tree
                .as_ref()?
                .get_dot_completion(token, byte_idx, url, tree.as_ref()?),
        })
    }

    #[allow(unused)]
    pub fn get_lsp_configuration_string_value(&self, name: &str) -> Option<String> {
        let lsp_configuration = self.lsp_configuration.read().unwrap();
        if let Some(Value::String(value)) = lsp_configuration.get(name) {
            return Some(value.to_string());
        }
        None
    }

    #[allow(unused)]
    pub fn get_lsp_configuration_i64_value(&self, name: &str) -> Option<i64> {
        let lsp_configuration = self.lsp_configuration.read().unwrap();
        if let Some(Value::Number(number)) = lsp_configuration.get(name) {
            return number.as_i64();
        }
        None
    }

    #[allow(unused)]
    pub fn get_lsp_configuration_bool_value(&self, name: &str) -> Option<bool> {
        let lsp_configuration = self.lsp_configuration.read().unwrap();
        if let Some(Value::Bool(value)) = lsp_configuration.get(name) {
            return Some(*value);
        }
        None
    }
}


pub fn recovery_sv_parse_with_retry(
    doc: &Rope,
    uri: &Url,
    last_change_range: &Option<Range>,
    inc_paths: &[PathBuf],
) -> Option<SyntaxTree>{
    if let Some(syntax_tree) = recovery_sv_parse(doc, uri, last_change_range, inc_paths, false) {
        Some(syntax_tree)
    } else {
        recovery_sv_parse(doc, uri, last_change_range, inc_paths, true)
    }
}

/// 更加稳定地解析 sv 和 v
/// 支持遇到错误进行自动修复，然后再解析
pub fn recovery_sv_parse(
    doc: &Rope,
    uri: &Url,
    last_change_range: &Option<Range>,
    inc_paths: &[PathBuf],
    allow_incomplete: bool,
) -> Option<SyntaxTree> {
    let mut parse_iterations = 1;
    let mut i = 0;
    let mut includes: Vec<PathBuf> = inc_paths.to_vec();
    let mut defines = HashMap::new();
    let mut reverted_change = false;
    let mut text = doc.clone();

    let recover_text_by_byte_idx = |byte_idx: usize, reverted_change: &mut bool, text: &mut Rope| {
        let mut line_start = text.byte_to_line(byte_idx);
        let mut line_end = text.byte_to_line(byte_idx) + 1;

        // println!("byte: {byte_idx}, line_start: {line_start}, line_end: {line_end}");
    
        if !(*reverted_change) {
            if let Some(range) = last_change_range {
                line_start = range.start.line as usize;
                line_end = range.end.line as usize + 1;
                *reverted_change = true;
            }
        }

        // 把 last_change 处的地方替换成空格
        for line_idx in line_start .. line_end {
            let line = text.line(line_idx);
            let start_char = text.line_to_char(line_idx);
            let line_length = line.len_chars();
            text.remove(start_char..(start_char + line_length - 1));
            text.insert(start_char, &" ".to_owned().repeat(line_length));
        }
    };

    // 最多解析 500 次
    while i < parse_iterations && i < 500 {
        i += 1;
        match parse_sv_str(
            &text.to_string(),
            uri.to_file_path().unwrap(),
            &defines,
            &includes,
            true,
            allow_incomplete
        ) {
            Ok((syntax_tree, _)) => {
                return Some(syntax_tree);
            }
            Err(err) => {
                // println!("err: {err:?}");
                match err {
                    // 语法错误
                    sv_parser::Error::Parse(trace) => match trace {
                        Some((_, byte_idx)) => {
                            // 把出错的地方替换成空格
                            recover_text_by_byte_idx(byte_idx, &mut reverted_change, &mut text);
                            parse_iterations += 1;
                        }
                        None => return None,
                    },
                    
                    // 遇到 include 错误，那就把提示中的 include 加入解析中再次解析
                    sv_parser::Error::Include { source: x } => {
                        if let sv_parser::Error::File { source: _, path: z } = *x {
                            // Include paths have to be relative to the working directory
                            // so we have to convert a source file relative path to a working directory
                            // relative path. This should have been handled by sv-parser
                            let mut inc_path_given = z.clone();
                            let mut uri_path = uri.to_file_path().unwrap();
                            uri_path.pop();
                            let rel_path = diff_paths(uri_path, current_dir().unwrap()).unwrap();
                            inc_path_given.pop();
                            let inc_path = rel_path.join(inc_path_given);
                            if !includes.contains(&inc_path) {
                                includes.push(inc_path);
                            } else {
                                error!("parser: include error: {:?}", z);
                                break;
                            }
                            parse_iterations += 1;
                        }
                    }

                    // 宏定义不存在的错误
                    sv_parser::Error::DefineNotFound(not_found_macro_name) => {
                        let com_define = Define {
                            identifier: not_found_macro_name.to_string(),
                            arguments: Vec::new(),
                            text: Some(DefineText {text: "UNKNOWN_MACRO".to_string(), origin: None})
                        };
                        defines.insert(not_found_macro_name, Some(com_define));
                        parse_iterations += 1;
                    }
                    sv_parser::Error::Preprocess(trace) => match trace {
                        Some((_, byte_idx)) => {
                            // 把出错的地方替换成空格
                            // println!("text {text:?}");
                            recover_text_by_byte_idx(byte_idx, &mut reverted_change, &mut text);
                            parse_iterations += 1;
                        }
                        None => return None
                    }
                    sv_parser::Error::DefineArgNotFound(trace) => match trace {
                        Some((_, start_byte_idx, _)) => {
                            recover_text_by_byte_idx(start_byte_idx, &mut reverted_change, &mut text);
                            // recover_text_by_byte_idx(end_byte_idx, &mut reverted_change, &mut text);
                            parse_iterations += 1;
                        }
                        _ => return None
                    }
                    sv_parser::Error::DefineNoArgs(trace) => match trace {
                        Some((_, start_byte_idx, _)) => {
                            recover_text_by_byte_idx(start_byte_idx, &mut reverted_change, &mut text);
                            parse_iterations += 1;
                        }
                        _ => return None
                    }
                    _ => error!("parse error, {:?}", err),
                };
            }
        }
    }
    None

}

pub fn sv_parser_pipeline(
    #[allow(unused)]
    conf: &Arc<RwLock<ProjectConfig>>,
    source_handle: &Arc<RwLock<Source>>,
    scope_handle: &Arc<RwLock<Option<GenericScope>>>,
    hdl_param_handle: &Arc<HdlParam>,
    doc: &Rope,
    uri: &Url,
    last_change_range: &Option<Range>,
    include_dirs: &Vec<PathBuf>
) {
    if doc.len_chars() == 0 {
        return;
    }
    
    let path = match PathBuf::from_str(uri.path()) {
        Ok(path) => path,
        Err(error) => {
            info!("error happen in <goto_include_definition>: {:?}", error);
            return;
        }
    };
    let escape_path = to_escape_path(&path);
    let escape_path_string = escape_path.to_str().unwrap_or("");
    if escape_path_string.len() == 0 {
        info!("error happen in [sv_parser_pipeline], escape_path_string is empty");
        return;
    }

    info!("debug, parse: {:?}", path);
    let syntax_tree = recovery_sv_parse_with_retry(
        doc,
        uri,
        last_change_range,
        include_dirs
    );
    info!("finish parse {:?}", path);

    // 更新 scope tree
    let mut scope_tree = match &syntax_tree {
        Some(tree) => get_scopes_from_syntax_tree(tree, uri),
        None => None,
    };

    let mut file = source_handle.write().unwrap();

    // 加入语法树 & 更新 fast
    if let Some(syntax_tree) = syntax_tree {
        if let Ok(fast) = make_fast_from_syntaxtree(&syntax_tree, &escape_path) {
            hdl_param_handle.update_fast(escape_path_string.to_string(), fast);
        }
        let parse_ir = ParseIR::SyntaxTree(syntax_tree);
        file.parse_ir = Some(parse_ir);
    } else {
        file.parse_ir = None;
    }
    // file.syntax_tree = syntax_tree;
    drop(file);

    info!("finish parse {:?}", uri.to_string());

    // 更新 global_scope，用于 sv 的解析
    // global_scope 为全局最大的那个 scope，它的 scopes 和 defs 下的元素和每一个文件一一对应
    let mut global_scope = scope_handle.write().unwrap();
    match &mut *global_scope {
        Some(scope) => match &mut scope_tree {
            Some(tree) => {
                // 更新所有 uri 为当前 uri 的文件结构
                scope.defs.retain(|x| &x.url() != uri);
                scope.scopes.retain(|x| &x.url() != uri);

                scope.defs.append(&mut tree.defs);
                scope.scopes.append(&mut tree.scopes);
            }
            None => (),
        },
        // 使用 scope_tree 来更新全局的 scope
        None => *global_scope = scope_tree,
    }
    // eprintln!("{:#?}", *global_scope);
    drop(global_scope);
}

pub fn vhdl_parser_pipeline(
    conf: &Arc<RwLock<ProjectConfig>>,
    source_handle: &Arc<RwLock<Source>>,
    scope_handle: &Arc<RwLock<Option<GenericScope>>>,
    project_handle: &Arc<RwLock<Option<VhdlProject>>>,
    hdl_param_handle: &Arc<HdlParam>,
    doc: &Rope,
    uri: &Url
) {
    if doc.len_chars() == 0 {
        return;
    }

    let path = match PathBuf::from_str(uri.path()) {
        Ok(path) => path,
        Err(error) => {
            info!("error happen in <goto_include_definition>: {:?}", error);
            return;
        }
    };
    let escape_path = to_escape_path(&path);
    let escape_path_string = escape_path.to_str().unwrap_or("");
    if escape_path_string.len() == 0 {
        info!("error happen in [vhdl_parser_pipeline], escape_path_string is empty");
        return;
    }

    let extension_path = {
        let configure = conf.read().unwrap();
        configure.extension_path.to_string()
    };

    let mut file = source_handle.write().unwrap();
    let text = doc.to_string();
    let mut scope_tree = if let Some(design_file) = vhdl_parse_str(&escape_path, &text) {
        if let Some(mut fast) = make_fast_from_design_file(&design_file) {
            let parse_ir = ParseIR::DesignFile(design_file);
            file.parse_ir = Some(parse_ir);

            for module in &fast.content {
                info!("parse port number: {:?}", module.ports.len());
            }

            let file_type = {
                let fast_map = hdl_param_handle.path_to_hdl_file.read().unwrap();
                if let Some(hdl_file) = fast_map.get(escape_path_string) {
                    hdl_file.fast.file_type.to_string()
                } else {
                    if let Some(relative_path) = escape_path_string.strip_prefix(&extension_path) {
                        if relative_path.starts_with("/user/ip") || relative_path.starts_with("user/ip") {
                            "ip".to_string()
                        } else {
                            "common".to_string()
                        }
                    } else {
                        "common".to_string()
                    }                    
                }
            };

            fast.file_type = file_type;
            hdl_param_handle.update_fast(escape_path_string.to_string(), fast.clone());
            let scope_tree = get_scopes_from_vhdl_fast(&fast, doc, uri);
            scope_tree
        } else {
            None
        }
    } else {
        file.parse_ir = None;
        None
    };
    drop(file);


    info!("finish parse {:?}", uri.to_string());

    // 更新 global_scope，用于 sv 的解析
    // global_scope 为全局最大的那个 scope，它的 scopes 和 defs 下的元素和每一个文件一一对应
    let mut global_scope = scope_handle.write().unwrap();
    match &mut *global_scope {
        Some(scope) => match &mut scope_tree {
            Some(tree) => {
                // 更新所有 uri 为当前 uri 的文件结构
                scope.defs.retain(|x| &x.url() != uri);
                scope.scopes.retain(|x| &x.url() != uri);

                scope.defs.append(&mut tree.defs);
                scope.scopes.append(&mut tree.scopes);
            }
            None => (),
        },
        // 使用 scope_tree 来更新全局的 scope
        None => *global_scope = scope_tree,
    }
    // eprintln!("{:#?}", *global_scope);

    let mut global_project = project_handle.write().unwrap();
    match &mut *global_project {
        Some(vhdl_project) => {
            if let Some(source) = vhdl_project.project.get_source(&escape_path) {
                source.change(None, &doc.to_string());
                vhdl_project.project.update_source(&source);
                vhdl_project.project.analyse();
            } else {
                vhdl_project.config_file_strs.push(format!("{:?}", escape_path));
                let mut messages = Vec::new();
                let config_str = format!(
                    r#"
                        [libraries]
                        digital_lsp.files = [{}]
                    "#, vhdl_project.config_file_strs.join(",")
                );
                let config = vhdl_lang::Config::from_str(&config_str, Path::new(""));
                if let Ok(mut config) = config {
                    config.append(&vhdl_project.std_config, &mut messages);
                    let mut project = Project::from_config(config, &mut messages);
                    project.analyse();
                    *vhdl_project = VhdlProject { project, std_config: vhdl_project.std_config.clone(), config_file_strs: vhdl_project.config_file_strs.clone() };
                }
            }
        }
        None => {
            let std_cfg_path = match PathBuf::from_str(&(extension_path + "/resources/dide-lsp/static/vhdl_std_lib/vhdl_ls.toml")) {
                Ok(path) => path,
                Err(e) => {
                    info!("error happen in <vhdl_parse_pipeline>: {:?}", e);
                    return;
                }
            };
            match vhdl_lang::Config::read_file_path(&std_cfg_path) {
                Ok(std_config) => {
                    let config_str = format!(
                        r#"
                            [libraries]
                            digital_lsp.files = [{:?}]
                        "#, escape_path
                    );
                    let mut config_file_strs = Vec::new();
                    config_file_strs.push(format!("{:?}", escape_path));
                    let config = vhdl_lang::Config::from_str(&config_str, Path::new(""));
                    if let Ok(mut config) = config {
                        let mut messages = Vec::new();
                        config.append(&std_config, &mut messages);
                        let mut project = Project::from_config(config, &mut messages);
                        project.analyse();
                        *global_project = Some(VhdlProject { project, std_config, config_file_strs });
                    }
                }
                Err(e) => info!("error happen in <vhdl_parse_pipeline>: Can't load standard vhdl lib from {std_cfg_path:#?} because {e:#?}")
            }
        }
    }
    drop(global_project);

    drop(global_scope);
}

//TODO: add bounds checking for utf8<->utf16 conversions
/// This trait defines some helper functions to convert between lsp types
/// and char/byte positions
pub trait LSPSupport {
    fn pos_to_byte(&self, pos: &Position) -> usize;
    fn pos_to_char(&self, pos: &Position) -> usize;
    fn byte_to_pos(&self, byte_idx: usize) -> Position;
    fn char_to_pos(&self, char_idx: usize) -> Position;
    fn range_to_char_range(&self, range: &Range) -> StdRange<usize>;
    fn char_range_to_range(&self, range: StdRange<usize>) -> Range;
    fn apply_change(&mut self, change: &TextDocumentContentChangeEvent);
}

/// Extend ropey's Rope type with lsp convenience functions
impl LSPSupport for Rope {
    fn pos_to_byte(&self, pos: &Position) -> usize {
        return self.char_to_byte(self.pos_to_char(pos));
    }
    fn pos_to_char(&self, pos: &Position) -> usize {
        let line_slice = self.line(pos.line as usize);
        return self.line_to_char(pos.line as usize) + line_slice.utf16_cu_to_char(pos.character as usize);
    }
    fn byte_to_pos(&self, byte_idx: usize) -> Position {
        // info!("byte_idx: {byte_idx}");
        let self_len = if self.len_bytes() != 0 { self.len_bytes() - 1 } else { 0 };
        return self.char_to_pos(self.byte_to_char(min(byte_idx, self_len)));
    }
    fn char_to_pos(&self, char_idx: usize) -> Position {
        let line = self.char_to_line(char_idx);
        let line_slice = self.line(line);
        return Position {
            line: line as u32,
            character: line_slice.char_to_utf16_cu(char_idx - self.line_to_char(line)) as u32,
        };
    }
    fn range_to_char_range(&self, range: &Range) -> StdRange<usize> {
        return self.pos_to_char(&range.start)..self.pos_to_char(&range.end);
    }
    fn char_range_to_range(&self, range: StdRange<usize>) -> Range {
        return Range {
            start: self.char_to_pos(range.start),
            end: self.char_to_pos(range.end),
        };
    }
    fn apply_change(&mut self, change: &TextDocumentContentChangeEvent) {
        if let Some(range) = change.range {
            let char_range = self.range_to_char_range(&range);
            self.remove(char_range.clone());
            if !change.text.is_empty() {
                self.insert(char_range.start, &change.text);
            }
        }
    }
}

impl<'a> LSPSupport for RopeSlice<'a> {
    fn pos_to_byte(&self, pos: &Position) -> usize {
        self.char_to_byte(self.pos_to_char(pos))
    }
    fn pos_to_char(&self, pos: &Position) -> usize {
        let line_slice = self.line(pos.line as usize);
        self.line_to_char(pos.line as usize) + line_slice.utf16_cu_to_char(pos.character as usize)
    }
    fn byte_to_pos(&self, byte_idx: usize) -> Position {
        // info!("byte_idx: {byte_idx}");
        self.char_to_pos(self.byte_to_char(min(byte_idx, self.len_bytes() - 1)))
    }
    fn char_to_pos(&self, char_idx: usize) -> Position {
        let line = self.char_to_line(char_idx);
        let line_slice = self.line(line);
        Position {
            line: line as u32,
            character: line_slice.char_to_utf16_cu(char_idx - self.line_to_char(line)) as u32,
        }
    }
    fn range_to_char_range(&self, range: &Range) -> StdRange<usize> {
        self.pos_to_char(&range.start)..self.pos_to_char(&range.end)
    }
    fn char_range_to_range(&self, range: StdRange<usize>) -> Range {
        Range {
            start: self.char_to_pos(range.start),
            end: self.char_to_pos(range.end),
        }
    }
    fn apply_change(&mut self, _: &TextDocumentContentChangeEvent) {
        panic!("can't edit a rope slice");
    }
}