// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
module checker

import strings
import v.ast
import os
import token

enum DetailKind {
    text           = 1
    method         = 2
    function       = 3
    constructor    = 4
    field          = 5
    variable       = 6
    class          = 7
    interface      = 8
    module         = 9
    property       = 10
    unit           = 11
    value          = 12
    enum           = 13
    keyword        = 14
    snippet        = 15
    color          = 16
    file           = 17
    reference      = 18
    folder         = 19
    enum_member    = 20
    const          = 21
    struct         = 22
    event          = 23
    operator       = 24
    type_parameter = 25
}

struct Detail {
    kind               DetailKind // The type of item (e.g., Method, Function, Field)
    label              string     // The name of the completion item
    detail             string     // Additional info like the function signature or return type
    declaration        string     // Full fn declaration, e.g. "fn greet(name string) string"
    documentation      string     // The documentation for the item
    insert_text        ?string
    insert_text_format ?int // 1 for PlainText, 2 for Snippet
}

fn (mut c Checker) get_fn_from_call_expr(node ast.CallExpr) !ast.Fn {
    fn_name := node.name
    return if node.is_method {
        left_sym := c.table.sym(c.unwrap_generic(node.left_type))
        c.table.find_method(left_sym, fn_name) or {
            return error('failed to find method "${fn_name}"')
        }
    } else {
        c.table.find_fn(fn_name) or { return error('failed to find fn "${fn_name}"') }
    }
}

// Autocomplete for function parameters `os.write_bytes(**path string, bytes []u8***)` etc
pub fn (mut c Checker) autocomplete_for_fn_call_expr(node ast.CallExpr) {
    // Hover over a function call: cursor is on the function name, method is .completion.
    // Output the full fn declaration as a single Detail so VLS can display it.
    if c.pref.linfo.method == .completion && c.vls_is_the_node(node.name_pos) {
        f := c.get_fn_from_call_expr(node) or { return }
        fn_name := f.name.all_after_last('.')
        mut params := []string{cap: f.params.len}
        for i, param in f.params {
            if f.is_method && i == 0 {
                continue // skip receiver
            }
            params << '${param.name} ${c.table.type_to_str(param.typ)}'
        }
        ret_str := if f.return_type != ast.no_type && f.return_type != ast.void_type {
            ' ' + c.table.type_to_str(f.return_type)
        } else {
            ''
        }
        declaration := 'fn ${fn_name}(${params.join(', ')})${ret_str}'
        mut doc := ''
        receiver := if f.is_method {
            c.table.sym(f.receiver_type).name.all_after_last('.')
        } else {
            ''
        }
        if info := c.table.vls_info['fn_${f.mod}[${receiver}]${fn_name}'] {
            doc = info.doc
        }
        c.vls_write_details([
            Detail{
                kind:          .function
                label:         fn_name
                declaration:   declaration
                documentation: doc
            },
        ])
        exit(0)
    }
    if c.pref.linfo.method != .signature_help {
        return
    }
    if !c.vls_is_the_node(node.name_pos) {
        return
    }
    f := c.get_fn_from_call_expr(node) or {
        println(err)
        exit(1)
    }
    res := c.build_fn_summary(f)
    println(res)
    exit(0)
}

fn (mut c Checker) ident_hover(node_ ast.Expr) {
    if c.pref.linfo.method != .hover {
        return
    }
    if !c.vls_is_the_node(node_.pos()) {
        return
    }
    mut node := unsafe { node_ }
    mut declaration := ''
    mut doc := ''
    match mut node {
        ast.CallExpr {
            if !c.vls_is_the_node(node.name_pos) {
                return
            }
            f := c.get_fn_from_call_expr(node) or { return }
            fn_name := f.name.all_after_last('.')
            mut params := []string{cap: f.params.len}
            for i, param in f.params {
                if f.is_method && i == 0 {
                    continue
                }
                params << '${param.name} ${c.table.type_to_str(param.typ)}'
            }
            ret_str := if f.return_type != ast.no_type && f.return_type != ast.void_type {
                ' ' + c.table.type_to_str(f.return_type)
            } else {
                ''
            }
            declaration = 'fn ${fn_name}(${params.join(', ')})${ret_str}'
            receiver := if f.is_method {
                c.table.sym(f.receiver_type).name.all_after_last('.')
            } else {
                ''
            }
            if info := c.table.vls_info['fn_${f.mod}[${receiver}]${fn_name}'] {
                doc = info.doc
            }
        }
        ast.Ident {
            for _, obj in c.table.global_scope.objects {
                if obj is ast.ConstField && obj.name == node.name {
                    type_str := c.table.type_to_str(obj.typ)
                    declaration = 'const ${node.name.all_after_last('.')} ${type_str}'
                    if info := c.table.vls_info['const_${obj.name}'] {
                        doc = info.doc
                    }
                    break
                } else if obj is ast.GlobalField && obj.name == node.name {
                    type_str := c.table.type_to_str(obj.typ)
                    declaration = '__global ${node.name.all_after_last('.')} ${type_str}'
                    break
                }
            }
            if declaration == '' && !isnil(c.fn_scope) {
                if obj := c.fn_scope.find_var(node.name) {
                    type_str := c.table.type_to_str(obj.typ)
                    declaration = '${node.name} ${type_str}'
                }
            }
            if declaration == '' {
                full_name := if node.mod != '' { '${node.mod}.${node.name}' } else { node.name }
                idx := c.table.find_type_idx(full_name)
                if idx > 0 {
                    sym := c.table.type_symbols[idx]
                    declaration = c.vls_hover_type_declaration(sym)
                    key := c.vls_hover_type_info_key(sym)
                    if info := c.table.vls_info['${key}_${sym.name}'] {
                        doc = info.doc
                    }
                }
            }
        }
        ast.SelectorExpr {
            sym := c.table.sym(node.expr_type)
            if field := c.table.find_field_with_embeds(sym, node.field_name) {
                type_str := c.table.type_to_str(field.typ)
                declaration = '${node.field_name} ${type_str}'
            } else if method := c.table.find_method(sym, node.field_name) {
                fn_name := method.name.all_after_last('.')
                mut params := []string{cap: method.params.len}
                for i, param in method.params {
                    if method.is_method && i == 0 {
                        continue
                    }
                    params << '${param.name} ${c.table.type_to_str(param.typ)}'
                }
                ret_str := if method.return_type != ast.no_type
                    && method.return_type != ast.void_type {
                    ' ' + c.table.type_to_str(method.return_type)
                } else {
                    ''
                }
                declaration = 'fn ${fn_name}(${params.join(', ')})${ret_str}'
                receiver_name := sym.name.all_after_last('.')
                if info := c.table.vls_info['fn_${method.mod}[${receiver_name}]${fn_name}'] {
                    doc = info.doc
                }
            } else {
                return
            }
        }
        ast.StructInit {
            if c.vls_is_the_node(node.name_pos) {
                sym := c.table.sym(node.typ)
                declaration = c.vls_hover_type_declaration(sym)
                key := c.vls_hover_type_info_key(sym)
                if info := c.table.vls_info['${key}_${sym.name}'] {
                    doc = info.doc
                }
            } else {
                for field in node.init_fields {
                    if c.vls_is_the_node(field.name_pos) {
                        sym := c.table.sym(node.typ)
                        if struct_field := c.table.find_field_with_embeds(sym, field.name) {
                            type_str := c.table.type_to_str(struct_field.typ)
                            declaration = '${field.name} ${type_str}'
                        }
                        break
                    }
                }
            }
        }
        ast.EnumVal {
            enum_name := if node.enum_name == '' && node.typ != ast.void_type && node.typ != 0 {
                c.table.sym(node.typ).name
            } else {
                node.enum_name
            }
            declaration = '${enum_name.all_after_last('.')}.${node.val}'
        }
        ast.TypeNode {
            typ_str := c.table.type_to_str(node.typ)
            idx := c.table.find_type_idx(typ_str)
            if idx > 0 {
                sym := c.table.type_symbols[idx]
                declaration = c.vls_hover_type_declaration(sym)
                key := c.vls_hover_type_info_key(sym)
                if info := c.table.vls_info['${key}_${sym.name}'] {
                    doc = info.doc
                }
            }
        }
        ast.CastExpr {
            typ_str := if node.typname != '' {
                node.typname
            } else {
                c.table.type_to_str(node.typ)
            }
            idx := c.table.find_type_idx(typ_str)
            if idx > 0 {
                sym := c.table.type_symbols[idx]
                declaration = c.vls_hover_type_declaration(sym)
                key := c.vls_hover_type_info_key(sym)
                if info := c.table.vls_info['${key}_${sym.name}'] {
                    doc = info.doc
                }
            }
        }
        else {}
    }

    if declaration == '' {
        exit(0)
    }
    c.vls_write_hover(declaration, doc)
    exit(0)
}

fn (c &Checker) vls_hover_type_declaration(sym ast.TypeSymbol) string {
    name := sym.name.all_after_last('.')
    match sym.kind {
        .struct {
            return 'struct ${name}'
        }
        .enum {
            return 'enum ${name}'
        }
        .interface {
            return 'interface ${name}'
        }
        .alias {
            alias_info := sym.info as ast.Alias
            parent_str := c.table.type_to_str(alias_info.parent_type)
            return 'type ${name} = ${parent_str}'
        }
        .sum_type {
            sum_info := sym.info as ast.SumType
            variants := sum_info.variants.map(c.table.type_to_str(it)).join(' | ')
            return 'type ${name} = ${variants}'
        }
        else {
            return name
        }
    }
}

fn (c &Checker) vls_hover_type_info_key(sym ast.TypeSymbol) string {
    return match sym.kind {
        .alias { 'aliastype' }
        .sum_type { 'sumtype' }
        else { '${sym.kind}' }
    }
}

fn (c &Checker) vls_write_hover(declaration string, doc string) {
    mut lines := ['```v', declaration, '```']
    if doc.len > 0 {
        lines << ''
        lines << doc
    }
    value := lines.join('\n').replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n')
    println('{"contents":{"kind":"markdown","value":"${value}"}}')
}

fn (mut c Checker) name_pos_gotodef(name string) ?token.Pos {
    idx := c.table.find_type_idx(name)
    if idx > 0 {
        sym := c.table.type_symbols[idx]
        return sym.info.get_name_pos()
    }
    return none
}

fn (mut c Checker) ident_gotodef(node_ ast.Expr) {
    if c.pref.linfo.method != .definition {
        return
    }
    if !c.vls_is_the_node(node_.pos()) {
        return
    }
    mut node := unsafe { node_ }
    mut pos := token.Pos{}
    match mut node {
        ast.CallExpr {
            if !c.vls_is_the_node(node.name_pos) {
                return
            }
            f := c.get_fn_from_call_expr(node) or {
                println(err)
                exit(1)
            }
            pos = f.name_pos
        }
        ast.Ident {
            // global objects
            for _, obj in c.table.global_scope.objects {
                if obj is ast.ConstField && obj.name == node.name {
                    pos = obj.pos
                    break
                } else if obj is ast.GlobalField && obj.name == node.name {
                    pos = obj.pos
                    break
                } else if obj is ast.Var && obj.name == node.name {
                    pos = obj.pos
                    break
                }
            }
            // local objects
            if pos == token.Pos{} && !isnil(c.fn_scope) {
                if obj := c.fn_scope.find_var(node.name) {
                    pos = obj.pos
                }
            }
            // If not found as a variable/const, try as a type
            if pos == token.Pos{} {
                full_name := if node.mod != '' { '${node.mod}.${node.name}' } else { node.name }
                if np := c.name_pos_gotodef(full_name) {
                    pos = np
                }
            }
        }
        ast.StructInit {
            // Check if clicking on a field name in struct init
            for field in node.init_fields {
                if c.vls_is_the_node(field.name_pos) {
                    sym := c.table.sym(node.typ)
                    if struct_field := c.table.find_field_with_embeds(sym, field.name) {
                        pos = struct_field.pos
                        break
                    }
                }
            }
            if pos == token.Pos{} && c.vls_is_the_node(node.name_pos) {
                info := c.table.sym(node.typ).info
                if np := info.get_name_pos() {
                    pos = np
                }
            }
            if pos == token.Pos{} {
                return
            }
        }
        ast.SelectorExpr {
            // Check if clicking on the field name or method
            sym := c.table.sym(node.expr_type)
            if field := c.table.find_field_with_embeds(sym, node.field_name) {
                pos = field.pos
            } else {
                if method := c.table.find_method(sym, node.field_name) {
                    pos = method.name_pos
                } else {
                    println('failed to find field or method "${node.field_name}"')
                    exit(1)
                }
            }
        }
        ast.EnumVal {
            // Go to enum field definition
            mut enum_name := if node.enum_name == '' && node.typ != ast.void_type && node.typ != 0 {
                c.table.sym(node.typ).name
            } else {
                node.enum_name
            }
            if enum_decl := c.table.enum_decls[enum_name] {
                for field in enum_decl.fields {
                    if field.name == node.val {
                        pos = field.pos
                        break
                    }
                }
            }
        }
        ast.TypeNode {
            // Go to type definition
            typ_str := c.table.type_to_str(node.typ)
            if np := c.name_pos_gotodef(typ_str) {
                pos = np
            }
        }
        ast.CastExpr {
            // Go to type definition in cast expr
            if node.typname != '' {
                if np := c.name_pos_gotodef(node.typname) {
                    pos = np
                }
            }
            if pos == token.Pos{} && node.typ != ast.void_type {
                typ_str := c.table.type_to_str(node.typ)
                if np := c.name_pos_gotodef(typ_str) {
                    pos = np
                }
            }
        }
        else {}
    }

    if pos.file_idx != -1 {
        println('${c.table.filelist[pos.file_idx]}:${pos.line_nr + 1}:${pos.col}')
    }
    exit(0)
}

// Autocomplete for `myvar. ...`, `os. ...`
fn (mut c Checker) ident_autocomplete(node ast.Ident) {
    if c.pref.linfo.method != .completion {
        return
    }
    // Mini LS hack (v -line-info "a.v:16")
    if c.pref.is_verbose {
        println(
            'checker.ident_autocomplete() info.line_nr=${c.pref.linfo.line_nr} node.line_nr=${node.pos.line_nr} ' +
            ' node.col=${node.pos.col} pwd="${os.getwd()}" file="${c.file.path}", ' +
            ' pref.linfo.path="${c.pref.linfo.path}" node.name="${node.name}" node.mod="${node.mod}" col="${c.pref.linfo.col}"')
    }
    if node.mod == 'builtin' {
        // User can't type in `builtin.func(` at all
        return
    }
    if !c.vls_is_the_node(node.pos) {
        return
    }
    check_name := if c.pref.linfo.col == node.pos.col {
        if node.name == '' {
            // for `os` in middle of text, followed by something else in next line:
            // `os.
            //  something`
            node.mod
        } else {
            ''
        }
    } else if c.pref.linfo.col == node.pos.col + node.pos.len {
        // for `os` at end of scope :
        // `os. }`
        node.name
    } else {
        ''
    }
    if check_name.len == 0 {
        return
    }
    // Module autocomplete
    // `os. ...`
    mod_name := c.try_resolve_to_import_mod_name(check_name)
    if mod_name.len > 0 {
        c.module_autocomplete(mod_name)
        exit(0)
    }
    if node.kind == .unresolved || node.obj.typ == ast.no_type {
        exit(0)
    }
    sym := c.table.sym(c.unwrap_generic(node.obj.typ))
    mut details := []Detail{cap: 10}
    c.vls_gen_type_details(mut details, sym)
    c.vls_write_details(details)
    exit(0)
}

fn (mut c Checker) module_autocomplete(mod string) {
    mut details := []Detail{cap: 128}
    c.vls_gen_mod_funcs_details(mut details, mod)
    c.vls_gen_mod_type_details(mut details, mod, .alias, .interface, .enum, .sum_type, .struct)
    c.vls_gen_mod_consts_details(mut details, mod)
    c.vls_write_details(details)
}

fn (c &Checker) build_fn_summary(func ast.Fn) string {
    mut sb := strings.new_builder(128)
    fn_name := func.name.all_after_last('.')
    sb.writeln('{\n"signatures":[{')
    sb.write_string('\t"label":"${fn_name}(')
    mut params := []string{cap: func.params.len}
    for i, param in func.params {
        if func.is_method && i == 0 {
            // skip receiver
            continue
        }
        params << '${param.name} ${c.table.type_to_str(param.typ)}'
    }
    sb.write_string(params.join(', '))
    sb.write_string(')')
    if func.return_type != ast.void_type {
        sb.write_string(' ')
        sb.write_string(c.table.type_to_str(func.return_type))
    }
    sb.writeln('",\n\t"parameters":[{')
    for i, p in params {
        sb.write_string('\t\t"label":"${p}"')
        if i < params.len - 1 {
            sb.write_string(',')
        }
        sb.writeln('')
    }
    sb.writeln('\t}]')
    sb.writeln('}],')
    sb.writeln('"activeSignature":0,')
    sb.writeln('"activeParameter":0')
    sb.writeln('}')
    return sb.str()
}

fn (c &Checker) try_resolve_to_import_mod_name(name string) string {
    for imp in c.file.imports {
        if (imp.alias == name || imp.mod == name) && imp.alias in c.file.used_imports {
            return imp.mod
        }
    }
    return ''
}

fn (c &Checker) vls_gen_mod_funcs_details(mut details []Detail, mod string) {
    for _, f in c.table.fns {
        mut name := f.name
        if f.is_pub && !f.is_method && !f.is_static_type_method && name.all_before_last('.') == mod {
            name =
                name.all_after_last('.') // The user already typed `mod.`, so suggest the name without module
            type_string := if f.return_type != ast.no_type {
                c.table.type_to_str(f.return_type)
            } else {
                ''
            }
            mut doc := ''
            if info := c.table.vls_info['fn_${mod}[]${name}'] {
                doc = info.doc
            }
            // Build full fn declaration for hover display, e.g. "fn add(a int, b int) int"
            mut params := []string{cap: f.params.len}
            for param in f.params {
                params << '${param.name} ${c.table.type_to_str(param.typ)}'
            }
            ret_str := if f.return_type != ast.no_type && f.return_type != ast.void_type {
                ' ' + c.table.type_to_str(f.return_type)
            } else {
                ''
            }
            declaration := 'fn ${name}(${params.join(', ')})${ret_str}'
            details << Detail{
                kind:          .function
                label:         name
                detail:        type_string
                declaration:   declaration
                documentation: doc
            }
        }
    }
}

fn (c &Checker) vls_gen_mod_type_details(mut details []Detail, mod string, kinds ...ast.Kind) {
    for sym in c.table.type_symbols {
        if sym.is_pub && sym.kind in kinds {
            if sym.name.all_before_last('.') == mod {
                mut doc := ''
                key := match sym.kind {
                    .alias {
                        'aliastype'
                    }
                    .interface {
                        'interface'
                    }
                    .enum {
                        'enum'
                    }
                    .sum_type {
                        'sumtype'
                    }
                    .struct {
                        'struct'
                    }
                    else {
                        '${sym.kind}'
                    }
                }

                if info := c.table.vls_info['${key}_${sym.name}'] {
                    doc = info.doc
                }
                details << Detail{
                    kind:          c.vls_map_v_kind_to_lsp_kind(sym.kind)
                    label:         sym.name.all_after_last('.')
                    documentation: doc
                }
            }
        }
    }
}

fn (c &Checker) vls_gen_mod_consts_details(mut details []Detail, mod string) {
    for _, obj in c.table.global_scope.objects {
        if obj is ast.ConstField && obj.is_pub {
            if obj.name.all_before_last('.') == mod {
                mut doc := ''
                if info := c.table.vls_info['const_${obj.name}'] {
                    doc = info.doc
                }
                details << Detail{
                    kind:          .const
                    label:         obj.name.all_after_last('.')
                    documentation: doc
                }
            }
        }
    }
}

fn (c &Checker) vls_gen_type_details(mut details []Detail, sym ast.TypeSymbol) {
    match sym.kind {
        .struct {
            struct_info := sym.info as ast.Struct
            for field in struct_info.fields {
                field_sym := c.table.sym(field.typ)
                details << Detail{
                    kind:   .field
                    label:  field.name
                    detail: field_sym.name
                }
            }
        }
        .array {
            if sym.info is ast.Aggregate {
            } else if sym.info is ast.Array {
                details << Detail{
                    kind:   .property
                    label:  'len'
                    detail: 'int'
                }
                details << Detail{
                    kind:   .property // use class icon
                    label:  'cap'
                    detail: 'int'
                }
            }
        }
        .string {
            details << Detail{
                kind:   .property // use class icon
                label:  'len'
                detail: 'int'
            }
        }
        else {}
    }

    // Aliases and other types can have methods, add them
    for method in sym.methods {
        method_ret_type := c.table.sym(method.return_type)
        details << Detail{
            kind:   .method
            label:  method.name
            detail: method_ret_type.name
        }
    }
}

fn (c &Checker) vls_write_details(details []Detail) {
    mut sb := strings.new_builder(details.len * 32)
    sb.writeln('{"details": [')
    for detail in details {
        sb.write_string('{"kind":${int(detail.kind)},')
        sb.write_string('"label":"${detail.label}",')
        sb.write_string('"detail":"${detail.detail}",')
        sb.write_string('"declaration":"${detail.declaration}",')
        sb.write_string('"documentation":"${detail.documentation}",')
        if insert_text := detail.insert_text {
            sb.write_string('"insert_text":"${insert_text}",')
        }
        if insert_text_format := detail.insert_text_format {
            sb.write_string('"insert_text_format":${insert_text_format},')
        }
        sb.go_back(1)
        sb.writeln('},')
    }
    if details.len > 0 {
        sb.go_back(2)
    }
    sb.write_string('\n]}')
    print(sb.str())
}

fn (c &Checker) vls_map_v_kind_to_lsp_kind(kind ast.Kind) DetailKind {
    match kind {
        .alias, .sum_type {
            return .class
        }
        .function {
            return .function
        }
        .interface {
            return .interface
        }
        .enum {
            return .enum
        }
        .struct {
            return .struct
        }
        else {
            return .text
        }
    }

    return .text
}

fn (c &Checker) vls_is_the_node(pos token.Pos) bool {
    // Make sure this ident is on the same line and same file as request
    same_line := c.pref.linfo.line_nr == pos.line_nr
    if !same_line {
        return false
    }
    if pos.file_idx < 0 {
        return false
    }
    // Normalize paths for comparison to handle directory compilation
    linfo_path := os.real_path(c.pref.linfo.path)
    file_path := os.real_path(c.table.filelist[pos.file_idx])
    if linfo_path != file_path {
        return false
    }
    if c.pref.linfo.col > pos.col + pos.len || c.pref.linfo.col < pos.col {
        return false
    }
    return true
}