const std = @import("std");
const AnalysisContext = @import("document_store.zig").AnalysisContext;
const ast = std.zig.ast;
const types = @import("types.zig");

/// REALLY BAD CODE, PLEASE DON'T USE THIS!!!!!!! (only for testing)
pub fn getFunctionByName(tree: *ast.Tree, name: []const u8) ?*ast.Node.FnProto {
    var decls = tree.root_node.decls.iterator(0);
    while (decls.next()) |decl_ptr| {
        var decl = decl_ptr.*;
        switch (decl.id) {
            .FnProto => {
                const func = decl.cast(ast.Node.FnProto).?;
                if (std.mem.eql(u8, tree.tokenSlice(func.name_token.?), name)) return func;
            },
            else => {},
        }
    }

    return null;
}

/// Get a declaration's doc comment node
fn getDocCommentNode(tree: *ast.Tree, node: *ast.Node) ?*ast.Node.DocComment {
    if (node.cast(ast.Node.FnProto)) |func| {
        return func.doc_comments;
    } else if (node.cast(ast.Node.VarDecl)) |var_decl| {
        return var_decl.doc_comments;
    } else if (node.cast(ast.Node.ContainerField)) |field| {
        return field.doc_comments;
    } else if (node.cast(ast.Node.ErrorTag)) |tag| {
        return tag.doc_comments;
    }
    return null;
}

/// Gets a declaration's doc comments, caller must free memory when a value is returned
/// Like:
///```zig
///var comments = getFunctionDocComments(allocator, tree, func);
///defer if (comments) |comments_pointer| allocator.free(comments_pointer);
///```
pub fn getDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, node: *ast.Node) !?[]const u8 {
    if (getDocCommentNode(tree, node)) |doc_comment_node| {
        return try collectDocComments(allocator, tree, doc_comment_node);
    }
    return null;
}

fn collectDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, doc_comments: *ast.Node.DocComment) ![]const u8 {
    var lines = std.ArrayList([]const u8).init(allocator);
    defer lines.deinit();

    var curr_line_tok = doc_comments.first_line;
    while (true) : (curr_line_tok += 1) {
        switch (tree.token_ids[curr_line_tok]) {
            .LineComment => continue,
            .DocComment, .ContainerDocComment => {
                try lines.append(std.fmt.trim(tree.tokenSlice(curr_line_tok)[3..]));
            },
            else => break,
        }
    }

    return try std.mem.join(allocator, "\\\n", lines.items);
}

/// Gets a function signature (keywords, name, return value)
pub fn getFunctionSignature(tree: *ast.Tree, func: *ast.Node.FnProto) []const u8 {
    const start = tree.token_locs[func.firstToken()].start;
    const end = tree.token_locs[switch (func.return_type) {
        .Explicit, .InferErrorSet => |node| node.lastToken(),
        .Invalid => |r_paren| r_paren,
    }].end;
    return tree.source[start..end];
}

/// Gets a function snippet insert text
pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: *ast.Tree, func: *ast.Node.FnProto, skip_self_param: bool) ![]const u8 {
    const name_tok = func.name_token orelse unreachable;

    var buffer = std.ArrayList(u8).init(allocator);
    try buffer.ensureCapacity(128);

    try buffer.appendSlice(tree.tokenSlice(name_tok));
    try buffer.append('(');

    var buf_stream = buffer.outStream();

    for (func.paramsConst()) |param, param_num| {
        if (skip_self_param and param_num == 0) continue;
        if (param_num != 0) try buffer.appendSlice(", ${") else try buffer.appendSlice("${");

        try buf_stream.print("{}:", .{param_num + 1});

        if (param.comptime_token) |_| {
            try buffer.appendSlice("comptime ");
        }

        if (param.noalias_token) |_| {
            try buffer.appendSlice("noalias ");
        }

        if (param.name_token) |name_token| {
            try buffer.appendSlice(tree.tokenSlice(name_token));
            try buffer.appendSlice(": ");
        }

        switch (param.param_type) {
            .var_args => try buffer.appendSlice("..."),
            .var_type => try buffer.appendSlice("var"),
            .type_expr => |type_expr| {
                var curr_tok = type_expr.firstToken();
                var end_tok = type_expr.lastToken();
                while (curr_tok <= end_tok) : (curr_tok += 1) {
                    const id = tree.token_ids[curr_tok];
                    const is_comma = id == .Comma;

                    if (curr_tok == end_tok and is_comma) continue;

                    try buffer.appendSlice(tree.tokenSlice(curr_tok));
                    if (is_comma or id == .Keyword_const) try buffer.append(' ');
                }
            },
        }

        try buffer.append('}');
    }
    try buffer.append(')');

    return buffer.toOwnedSlice();
}

/// Gets a function signature (keywords, name, return value)
pub fn getVariableSignature(tree: *ast.Tree, var_decl: *ast.Node.VarDecl) []const u8 {
    const start = tree.token_locs[var_decl.firstToken()].start;
    const end = tree.token_locs[var_decl.semicolon_token].start;
    return tree.source[start..end];
}

pub fn isTypeFunction(tree: *ast.Tree, func: *ast.Node.FnProto) bool {
    switch (func.return_type) {
        .Explicit => |node| return if (node.cast(std.zig.ast.Node.Identifier)) |ident|
            std.mem.eql(u8, tree.tokenSlice(ident.token), "type")
        else
            false,
        .InferErrorSet, .Invalid => return false,
    }
}

// STYLE

pub fn isCamelCase(name: []const u8) bool {
    return !std.ascii.isUpper(name[0]) and std.mem.indexOf(u8, name, "_") == null;
}

pub fn isPascalCase(name: []const u8) bool {
    return std.ascii.isUpper(name[0]) and std.mem.indexOf(u8, name, "_") == null;
}

// ANALYSIS ENGINE

pub fn getDeclNameToken(tree: *ast.Tree, node: *ast.Node) ?ast.TokenIndex {
    switch (node.id) {
        .VarDecl => {
            const vari = node.cast(ast.Node.VarDecl).?;
            return vari.name_token;
        },
        .FnProto => {
            const func = node.cast(ast.Node.FnProto).?;
            if (func.name_token == null) return null;
            return func.name_token.?;
        },
        .ContainerField => {
            const field = node.cast(ast.Node.ContainerField).?;
            return field.name_token;
        },
        // We need identifier for captures
        .Identifier => {
            const ident = node.cast(ast.Node.Identifier).?;
            return ident.token;
        },
        .TestDecl => {
            const decl = node.cast(ast.Node.TestDecl).?;
            return (decl.name.cast(ast.Node.StringLiteral) orelse return null).token;
        },
        else => {},
    }

    return null;
}

fn getDeclName(tree: *ast.Tree, node: *ast.Node) ?[]const u8 {
    const name = tree.tokenSlice(getDeclNameToken(tree, node) orelse return null);
    return switch (node.id) {
        .TestDecl => name[1 .. name.len - 1],
        else => name,
    };
}

/// Gets the child of node
pub fn getChild(tree: *ast.Tree, node: *ast.Node, name: []const u8) ?*ast.Node {
    var child_idx: usize = 0;
    while (node.iterate(child_idx)) |child| : (child_idx += 1) {
        const child_name = getDeclName(tree, child) orelse continue;
        if (std.mem.eql(u8, child_name, name)) return child;
    }
    return null;
}

/// Gets the child of slice
pub fn getChildOfSlice(tree: *ast.Tree, nodes: []*ast.Node, name: []const u8) ?*ast.Node {
    for (nodes) |child| {
        const child_name = getDeclName(tree, child) orelse continue;
        if (std.mem.eql(u8, child_name, name)) return child;
    }
    return null;
}

fn findReturnStatementInternal(
    tree: *ast.Tree,
    fn_decl: *ast.Node.FnProto,
    base_node: *ast.Node,
    already_found: *bool,
) ?*ast.Node.ControlFlowExpression {
    var result: ?*ast.Node.ControlFlowExpression = null;
    var child_idx: usize = 0;
    while (base_node.iterate(child_idx)) |child_node| : (child_idx += 1) {
        switch (child_node.id) {
            .ControlFlowExpression => {
                const cfe = child_node.cast(ast.Node.ControlFlowExpression).?;
                if (cfe.kind == .Return) {
                    // If we are calling ourselves recursively, ignore this return.
                    if (cfe.rhs) |rhs| {
                        if (rhs.cast(ast.Node.Call)) |call_node| {
                            if (call_node.lhs.id == .Identifier) {
                                if (std.mem.eql(u8, getDeclName(tree, call_node.lhs).?, getDeclName(tree, &fn_decl.base).?)) {
                                    continue;
                                }
                            }
                        }
                    }

                    if (already_found.*) return null;
                    already_found.* = true;
                    result = cfe;
                    continue;
                }
            },
            else => {},
        }

        result = findReturnStatementInternal(tree, fn_decl, child_node, already_found);
    }
    return result;
}

fn findReturnStatement(tree: *ast.Tree, fn_decl: *ast.Node.FnProto) ?*ast.Node.ControlFlowExpression {
    var already_found = false;
    return findReturnStatementInternal(tree, fn_decl, fn_decl.body_node.?, &already_found);
}

/// Resolves the return type of a function
fn resolveReturnType(analysis_ctx: *AnalysisContext, fn_decl: *ast.Node.FnProto) ?*ast.Node {
    if (isTypeFunction(analysis_ctx.tree(), fn_decl) and fn_decl.body_node != null) {
        // If this is a type function and it only contains a single return statement that returns
        // a container declaration, we will return that declaration.
        const ret = findReturnStatement(analysis_ctx.tree(), fn_decl) orelse return null;
        if (ret.rhs) |rhs|
            if (resolveTypeOfNode(analysis_ctx, rhs)) |res_rhs| switch (res_rhs.id) {
                .ContainerDecl => {
                    analysis_ctx.onContainer(res_rhs) catch return null;
                    return res_rhs;
                },
                else => return null,
            };

        return null;
    }

    return switch (fn_decl.return_type) {
        .Explicit, .InferErrorSet => |return_type| resolveTypeOfNode(analysis_ctx, return_type),
        .Invalid => null,
    };
}

/// Resolves the child type of an optional type
fn resolveUnwrapOptionalType(analysis_ctx: *AnalysisContext, opt: *ast.Node) ?*ast.Node {
    if (opt.cast(ast.Node.PrefixOp)) |prefix_op| {
        if (prefix_op.op == .OptionalType) {
            return resolveTypeOfNode(analysis_ctx, prefix_op.rhs);
        }
    }

    return null;
}

/// Resolves the child type of a defer type
fn resolveDerefType(analysis_ctx: *AnalysisContext, deref: *ast.Node) ?*ast.Node {
    if (deref.cast(ast.Node.PrefixOp)) |pop| {
        if (pop.op == .PtrType) {
            const op_token_id = analysis_ctx.tree().token_ids[pop.op_token];
            switch (op_token_id) {
                .Asterisk => return resolveTypeOfNode(analysis_ctx, pop.rhs),
                .LBracket, .AsteriskAsterisk => return null,
                else => unreachable,
            }
        }
    }
    return null;
}

fn makeSliceType(analysis_ctx: *AnalysisContext, child_type: *ast.Node) ?*ast.Node {
    // TODO: Better values for fields, better way to do this?
    var slice_type = analysis_ctx.arena.allocator.create(ast.Node.PrefixOp) catch return null;
    slice_type.* = .{
        .op_token = child_type.firstToken(),
        .op = .{
            .SliceType = .{
                .allowzero_token = null,
                .align_info = null,
                .const_token = null,
                .volatile_token = null,
                .sentinel = null,
            },
        },
        .rhs = child_type,
    };

    return &slice_type.base;
}

/// Resolves bracket access type (both slicing and array access)
fn resolveBracketAccessType(
    analysis_ctx: *AnalysisContext,
    lhs: *ast.Node,
    rhs: enum { Single, Range },
) ?*ast.Node {
    if (lhs.cast(ast.Node.PrefixOp)) |pop| {
        switch (pop.op) {
            .SliceType => {
                if (rhs == .Single) return resolveTypeOfNode(analysis_ctx, pop.rhs);
                return lhs;
            },
            .ArrayType => {
                if (rhs == .Single) return resolveTypeOfNode(analysis_ctx, pop.rhs);
                return makeSliceType(analysis_ctx, pop.rhs);
            },
            .PtrType => {
                if (pop.rhs.cast(std.zig.ast.Node.PrefixOp)) |child_pop| {
                    switch (child_pop.op) {
                        .ArrayType => {
                            if (rhs == .Single) {
                                return resolveTypeOfNode(analysis_ctx, child_pop.rhs);
                            }
                            return lhs;
                        },
                        else => {},
                    }
                }
            },
            else => {},
        }
    }
    return null;
}

/// Called to remove one level of pointerness before a field access
fn resolveFieldAccessLhsType(analysis_ctx: *AnalysisContext, lhs: *ast.Node) *ast.Node {
    return resolveDerefType(analysis_ctx, lhs) orelse lhs;
}

/// Resolves the type of a node
pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.Node {
    switch (node.id) {
        .VarDecl => {
            const vari = node.cast(ast.Node.VarDecl).?;

            return resolveTypeOfNode(analysis_ctx, vari.type_node orelse vari.init_node.?) orelse null;
        },
        .Identifier => {
            if (getChildOfSlice(analysis_ctx.tree(), analysis_ctx.scope_nodes, analysis_ctx.tree().getNodeSource(node))) |child| {
                if (child == node) return null;
                return resolveTypeOfNode(analysis_ctx, child);
            } else return null;
        },
        .ContainerField => {
            const field = node.cast(ast.Node.ContainerField).?;
            return resolveTypeOfNode(analysis_ctx, field.type_expr orelse return null);
        },
        .Call => {
            const call = node.cast(ast.Node.Call).?;
            const previous_tree = analysis_ctx.tree();

            const decl = resolveTypeOfNode(analysis_ctx, call.lhs) orelse return null;
            if (decl.cast(ast.Node.FnProto)) |fn_decl| {
                if (previous_tree != analysis_ctx.tree()) {
                    return resolveReturnType(analysis_ctx, fn_decl);
                }

                // Add type param values to the scope nodes
                const param_len = std.math.min(call.params_len, fn_decl.params_len);
                var scope_nodes = std.ArrayList(*ast.Node).fromOwnedSlice(&analysis_ctx.arena.allocator, analysis_ctx.scope_nodes);
                var analysis_ctx_clone = analysis_ctx.clone() catch return null;
                for (fn_decl.paramsConst()) |decl_param, param_idx| {
                    if (param_idx >= param_len) break;
                    if (decl_param.name_token == null) continue;

                    const type_param = switch (decl_param.param_type) {
                        .type_expr => |type_node| if (type_node.cast(ast.Node.Identifier)) |ident|
                            std.mem.eql(u8, analysis_ctx.tree().tokenSlice(ident.token), "type")
                        else
                            false,
                        else => false,
                    };
                    if (!type_param) continue;

                    // TODO Handle errors better
                    // TODO This may invalidate the analysis context so we copy it.
                    //      However, if the argument hits an import we just ignore it for now.
                    //      Once we return our own types instead of directly using nodes we can fix this.
                    const call_param_type = resolveTypeOfNode(&analysis_ctx_clone, call.paramsConst()[param_idx]) orelse continue;
                    if (analysis_ctx_clone.handle != analysis_ctx.handle) {
                        analysis_ctx_clone = analysis_ctx.clone() catch return null;
                        continue;
                    }

                    scope_nodes.append(makeVarDeclNode(
                        &analysis_ctx.arena.allocator,
                        decl_param.doc_comments,
                        decl_param.comptime_token,
                        decl_param.name_token.?,
                        null,
                        call_param_type,
                    ) catch return null) catch return null;
                    analysis_ctx.scope_nodes = scope_nodes.items;
                }

                return resolveReturnType(analysis_ctx, fn_decl);
            }
            return decl;
        },
        .StructInitializer => {
            const struct_init = node.cast(ast.Node.StructInitializer).?;
            return resolveTypeOfNode(analysis_ctx, struct_init.lhs);
        },
        .ErrorSetDecl => {
            const set = node.cast(ast.Node.ErrorSetDecl).?;
            var i: usize = 0;
            while (set.iterate(i)) |decl| : (i += 1) {
                // TODO handle errors better?
                analysis_ctx.error_completions.add(analysis_ctx.tree(), decl) catch {};
            }
            return node;
        },
        .SuffixOp => {
            const suffix_op = node.cast(ast.Node.SuffixOp).?;
            switch (suffix_op.op) {
                .UnwrapOptional => {
                    const left_type = resolveTypeOfNode(analysis_ctx, suffix_op.lhs) orelse return null;
                    return resolveUnwrapOptionalType(analysis_ctx, left_type);
                },
                .Deref => {
                    const left_type = resolveTypeOfNode(analysis_ctx, suffix_op.lhs) orelse return null;
                    return resolveDerefType(analysis_ctx, left_type);
                },
                .ArrayAccess => {
                    const left_type = resolveTypeOfNode(analysis_ctx, suffix_op.lhs) orelse return null;
                    return resolveBracketAccessType(analysis_ctx, left_type, .Single);
                },
                .Slice => {
                    const left_type = resolveTypeOfNode(analysis_ctx, suffix_op.lhs) orelse return null;
                    return resolveBracketAccessType(analysis_ctx, left_type, .Range);
                },
                else => {},
            }
        },
        .InfixOp => {
            const infix_op = node.cast(ast.Node.InfixOp).?;
            switch (infix_op.op) {
                .Period => {
                    // Save the child string from this tree since the tree may switch when processing
                    // an import lhs.
                    var rhs_str = nodeToString(analysis_ctx.tree(), infix_op.rhs) orelse return null;
                    // Use the analysis context temporary arena to store the rhs string.
                    rhs_str = std.mem.dupe(&analysis_ctx.arena.allocator, u8, rhs_str) catch return null;

                    // If we are accessing a pointer type, remove one pointerness level :)
                    const left_type = resolveFieldAccessLhsType(
                        analysis_ctx,
                        resolveTypeOfNode(analysis_ctx, infix_op.lhs) orelse return null,
                    );

                    const child = getChild(analysis_ctx.tree(), left_type, rhs_str) orelse return null;
                    return resolveTypeOfNode(analysis_ctx, child);
                },
                .UnwrapOptional => {
                    const left_type = resolveTypeOfNode(analysis_ctx, infix_op.lhs) orelse return null;
                    return resolveUnwrapOptionalType(analysis_ctx, left_type);
                },
                else => {},
            }
        },
        .PrefixOp => {
            const prefix_op = node.cast(ast.Node.PrefixOp).?;
            switch (prefix_op.op) {
                .SliceType,
                .ArrayType,
                .OptionalType,
                .PtrType,
                => return node,
                .Try => {
                    const rhs_type = resolveTypeOfNode(analysis_ctx, prefix_op.rhs) orelse return null;
                    switch (rhs_type.id) {
                        .InfixOp => {
                            const infix_op = rhs_type.cast(ast.Node.InfixOp).?;
                            if (infix_op.op == .ErrorUnion) return infix_op.rhs;
                        },
                        else => {},
                    }
                    return rhs_type;
                },
                else => {},
            }
        },
        .BuiltinCall => {
            const builtin_call = node.cast(ast.Node.BuiltinCall).?;
            const call_name = analysis_ctx.tree().tokenSlice(builtin_call.builtin_token);
            if (std.mem.eql(u8, call_name, "@This")) {
                if (builtin_call.params_len != 0) return null;
                return analysis_ctx.in_container;
            }

            if (!std.mem.eql(u8, call_name, "@import")) return null;
            if (builtin_call.params_len > 1) return null;

            const import_param = builtin_call.paramsConst()[0];
            if (import_param.id != .StringLiteral) return null;

            const import_str = analysis_ctx.tree().tokenSlice(import_param.cast(ast.Node.StringLiteral).?.token);
            return analysis_ctx.onImport(import_str[1 .. import_str.len - 1]) catch |err| block: {
                std.debug.warn("Error {} while processing import {}\n", .{ err, import_str });
                break :block null;
            };
        },
        .ContainerDecl => {
            analysis_ctx.onContainer(node) catch return null;

            const container = node.cast(ast.Node.ContainerDecl).?;
            const kind = analysis_ctx.tree().token_ids[container.kind_token];

            if (kind == .Keyword_struct or (kind == .Keyword_union and container.init_arg_expr == .None)) {
                return node;
            }

            var i: usize = 0;
            while (container.iterate(i)) |decl| : (i += 1) {
                if (decl.id != .ContainerField) continue;
                // TODO handle errors better?
                analysis_ctx.enum_completions.add(analysis_ctx.tree(), decl) catch {};
            }
            return node;
        },
        .MultilineStringLiteral, .StringLiteral, .FnProto => return node,
        else => std.debug.warn("Type resolution case not implemented; {}\n", .{node.id}),
    }
    return null;
}

fn maybeCollectImport(tree: *ast.Tree, builtin_call: *ast.Node.BuiltinCall, arr: *std.ArrayList([]const u8)) !void {
    if (!std.mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@import")) return;
    if (builtin_call.params_len > 1) return;

    const import_param = builtin_call.paramsConst()[0];
    if (import_param.id != .StringLiteral) return;

    const import_str = tree.tokenSlice(import_param.cast(ast.Node.StringLiteral).?.token);
    try arr.append(import_str[1 .. import_str.len - 1]);
}

/// Collects all imports we can find into a slice of import paths (without quotes).
/// The import paths are valid as long as the tree is.
pub fn collectImports(import_arr: *std.ArrayList([]const u8), tree: *ast.Tree) !void {
    // TODO: Currently only detects `const smth = @import("string literal")<.SomeThing>;`
    for (tree.root_node.decls()) |decl| {
        if (decl.id != .VarDecl) continue;
        const var_decl = decl.cast(ast.Node.VarDecl).?;
        if (var_decl.init_node == null) continue;

        switch (var_decl.init_node.?.id) {
            .BuiltinCall => {
                const builtin_call = var_decl.init_node.?.cast(ast.Node.BuiltinCall).?;
                try maybeCollectImport(tree, builtin_call, import_arr);
            },
            .InfixOp => {
                const infix_op = var_decl.init_node.?.cast(ast.Node.InfixOp).?;

                switch (infix_op.op) {
                    .Period => {},
                    else => continue,
                }
                if (infix_op.lhs.id != .BuiltinCall) continue;
                try maybeCollectImport(tree, infix_op.lhs.cast(ast.Node.BuiltinCall).?, import_arr);
            },
            else => {},
        }
    }
}

fn checkForContainerAndResolveFieldAccessLhsType(analysis_ctx: *AnalysisContext, node: *ast.Node) *ast.Node {
    const current_node = resolveFieldAccessLhsType(analysis_ctx, node);

    if (current_node.id == .ContainerDecl or current_node.id == .Root) {
        // TODO: Handle errors
        analysis_ctx.onContainer(current_node) catch {};
    }

    return current_node;
}

pub fn getFieldAccessTypeNode(
    analysis_ctx: *AnalysisContext,
    tokenizer: *std.zig.Tokenizer,
) ?*ast.Node {
    var current_node = analysis_ctx.in_container;

    while (true) {
        const tok = tokenizer.next();
        switch (tok.id) {
            .Eof => return resolveFieldAccessLhsType(analysis_ctx, current_node),
            .Identifier => {
                if (getChildOfSlice(analysis_ctx.tree(), analysis_ctx.scope_nodes, tokenizer.buffer[tok.loc.start..tok.loc.end])) |child| {
                    if (resolveTypeOfNode(analysis_ctx, child)) |child_type| {
                        current_node = child_type;
                    } else return null;
                } else return null;
            },
            .Period => {
                const after_period = tokenizer.next();
                switch (after_period.id) {
                    .Eof => return resolveFieldAccessLhsType(analysis_ctx, current_node),
                    .Identifier => {
                        if (after_period.loc.end == tokenizer.buffer.len) return resolveFieldAccessLhsType(analysis_ctx, current_node);

                        current_node = checkForContainerAndResolveFieldAccessLhsType(analysis_ctx, current_node);
                        if (getChild(analysis_ctx.tree(), current_node, tokenizer.buffer[after_period.loc.start..after_period.loc.end])) |child| {
                            if (resolveTypeOfNode(analysis_ctx, child)) |child_type| {
                                current_node = child_type;
                            } else return null;
                        } else return null;
                    },
                    .QuestionMark => {
                        if (resolveUnwrapOptionalType(analysis_ctx, current_node)) |child_type| {
                            current_node = child_type;
                        } else return null;
                    },
                    else => {
                        std.debug.warn("Unrecognized token {} after period.\n", .{after_period.id});
                        return null;
                    },
                }
            },
            .PeriodAsterisk => {
                if (resolveDerefType(analysis_ctx, current_node)) |child_type| {
                    current_node = child_type;
                } else return null;
            },
            .LParen => {
                switch (current_node.id) {
                    .FnProto => {
                        const func = current_node.cast(ast.Node.FnProto).?;
                        if (resolveReturnType(analysis_ctx, func)) |ret| {
                            current_node = ret;
                            // Skip to the right paren
                            var paren_count: usize = 1;
                            var next = tokenizer.next();
                            while (next.id != .Eof) : (next = tokenizer.next()) {
                                if (next.id == .RParen) {
                                    paren_count -= 1;
                                    if (paren_count == 0) break;
                                } else if (next.id == .LParen) {
                                    paren_count += 1;
                                }
                            } else return null;
                        } else return null;
                    },
                    else => {},
                }
            },
            .LBracket => {
                var brack_count: usize = 1;
                var next = tokenizer.next();
                var is_range = false;
                while (next.id != .Eof) : (next = tokenizer.next()) {
                    if (next.id == .RBracket) {
                        brack_count -= 1;
                        if (brack_count == 0) break;
                    } else if (next.id == .LBracket) {
                        brack_count += 1;
                    } else if (next.id == .Ellipsis2 and brack_count == 1) {
                        is_range = true;
                    }
                } else return null;

                if (resolveBracketAccessType(
                    analysis_ctx,
                    current_node,
                    if (is_range) .Range else .Single,
                )) |child_type| {
                    current_node = child_type;
                } else return null;
            },
            else => {
                std.debug.warn("Unimplemented token: {}\n", .{tok.id});
                return null;
            },
        }

        if (current_node.id == .ContainerDecl or current_node.id == .Root) {
            analysis_ctx.onContainer(current_node) catch return null;
        }
    }

    return resolveFieldAccessLhsType(analysis_ctx, current_node);
}

pub fn isNodePublic(tree: *ast.Tree, node: *ast.Node) bool {
    switch (node.id) {
        .VarDecl => {
            const var_decl = node.cast(ast.Node.VarDecl).?;
            return var_decl.visib_token != null;
        },
        .FnProto => {
            const func = node.cast(ast.Node.FnProto).?;
            return func.visib_token != null;
        },
        else => return true,
    }
}

pub fn nodeToString(tree: *ast.Tree, node: *ast.Node) ?[]const u8 {
    switch (node.id) {
        .ContainerField => {
            const field = node.cast(ast.Node.ContainerField).?;
            return tree.tokenSlice(field.name_token);
        },
        .ErrorTag => {
            const tag = node.cast(ast.Node.ErrorTag).?;
            return tree.tokenSlice(tag.name_token);
        },
        .Identifier => {
            const field = node.cast(ast.Node.Identifier).?;
            return tree.tokenSlice(field.token);
        },
        .FnProto => {
            const func = node.cast(ast.Node.FnProto).?;
            if (func.name_token) |name_token| {
                return tree.tokenSlice(name_token);
            }
        },
        else => {
            std.debug.warn("INVALID: {}\n", .{node.id});
        },
    }

    return null;
}

fn makeAccessNode(allocator: *std.mem.Allocator, expr: *ast.Node) !*ast.Node {
    const suffix_op_node = try allocator.create(ast.Node.SuffixOp);
    suffix_op_node.* = .{
        .op = .{ .ArrayAccess = expr },
        .lhs = expr,
        .rtoken = expr.lastToken(),
    };
    return &suffix_op_node.base;
}

fn makeUnwrapNode(allocator: *std.mem.Allocator, expr: *ast.Node) !*ast.Node {
    const suffix_op_node = try allocator.create(ast.Node.SuffixOp);
    suffix_op_node.* = .{
        .op = .UnwrapOptional,
        .lhs = expr,
        .rtoken = expr.lastToken(),
    };
    return &suffix_op_node.base;
}

fn makeVarDeclNode(
    allocator: *std.mem.Allocator,
    doc: ?*ast.Node.DocComment,
    comptime_token: ?ast.TokenIndex,
    name_token: ast.TokenIndex,
    type_expr: ?*ast.Node,
    init_expr: ?*ast.Node,
) !*ast.Node {
    // TODO: This will not be needed anymore when we use out own decl type instead of directly
    // repurposing ast nodes.
    const var_decl_node = try allocator.create(ast.Node.VarDecl);
    var_decl_node.* = .{
        .doc_comments = doc,
        .comptime_token = comptime_token,
        .visib_token = null,
        .thread_local_token = null,
        .name_token = name_token,
        .eq_token = null,
        .mut_token = name_token,
        .extern_export_token = null,
        .lib_name = null,
        .type_node = type_expr,
        .align_node = null,
        .section_node = null,
        .init_node = init_expr,
        .semicolon_token = name_token,
    };

    return &var_decl_node.base;
}

pub fn declsFromIndexInternal(
    arena: *std.heap.ArenaAllocator,
    decls: *std.ArrayList(*ast.Node),
    tree: *ast.Tree,
    node: *ast.Node,
    source_index: usize,
    innermost_container: **ast.Node,
) error{OutOfMemory}!void {
    switch (node.id) {
        .Root, .ContainerDecl => {
            innermost_container.* = node;
            var node_idx: usize = 0;
            while (node.iterate(node_idx)) |child_node| : (node_idx += 1) {
                // Skip over container fields, we can only dot access those.
                if (child_node.id == .ContainerField) continue;

                const is_contained = nodeContainsSourceIndex(tree, child_node, source_index);
                // If the cursor is in a variable decls it will insert itself anyway, we don't need to take care of it.
                if ((is_contained and child_node.id != .VarDecl) or !is_contained) try decls.append(child_node);
                if (is_contained) {
                    try declsFromIndexInternal(arena, decls, tree, child_node, source_index, innermost_container);
                }
            }
        },
        .FnProto => {
            const func = node.cast(ast.Node.FnProto).?;

            // TODO: This is a hack to enable param decls with the new parser
            for (func.paramsConst()) |param| {
                if (param.param_type != .type_expr or param.name_token == null) continue;

                try decls.append(try makeVarDeclNode(
                    &arena.allocator,
                    param.doc_comments,
                    param.comptime_token,
                    param.name_token.?,
                    param.param_type.type_expr,
                    null,
                ));
            }

            if (func.body_node) |body_node| {
                if (!nodeContainsSourceIndex(tree, body_node, source_index)) return;
                try declsFromIndexInternal(arena, decls, tree, body_node, source_index, innermost_container);
            }
        },
        .TestDecl => {
            const test_decl = node.cast(ast.Node.TestDecl).?;
            if (!nodeContainsSourceIndex(tree, test_decl.body_node, source_index)) return;
            try declsFromIndexInternal(arena, decls, tree, test_decl.body_node, source_index, innermost_container);
        },
        .Block => {
            var inode_idx: usize = 0;
            while (node.iterate(inode_idx)) |inode| : (inode_idx += 1) {
                if (nodeComesAfterSourceIndex(tree, inode, source_index)) return;
                try declsFromIndexInternal(arena, decls, tree, inode, source_index, innermost_container);
            }
        },
        .Comptime => {
            const comptime_stmt = node.cast(ast.Node.Comptime).?;
            if (nodeComesAfterSourceIndex(tree, comptime_stmt.expr, source_index)) return;
            try declsFromIndexInternal(arena, decls, tree, comptime_stmt.expr, source_index, innermost_container);
        },
        .If => {
            const if_node = node.cast(ast.Node.If).?;
            if (nodeContainsSourceIndex(tree, if_node.body, source_index)) {
                if (if_node.payload) |payload| {
                    std.debug.assert(payload.id == .PointerPayload);
                    const ptr_payload = payload.cast(ast.Node.PointerPayload).?;
                    std.debug.assert(ptr_payload.value_symbol.id == .Identifier);

                    try decls.append(try makeVarDeclNode(
                        &arena.allocator,
                        null,
                        null,
                        ptr_payload.value_symbol.firstToken(),
                        null,
                        try makeUnwrapNode(&arena.allocator, if_node.condition),
                    ));
                }
                return try declsFromIndexInternal(arena, decls, tree, if_node.body, source_index, innermost_container);
            }

            if (if_node.@"else") |else_node| {
                if (nodeContainsSourceIndex(tree, else_node.body, source_index)) {
                    if (else_node.payload) |payload| {
                        try declsFromIndexInternal(arena, decls, tree, payload, source_index, innermost_container);
                    }
                    return try declsFromIndexInternal(arena, decls, tree, else_node.body, source_index, innermost_container);
                }
            }
        },
        .While => {
            const while_node = node.cast(ast.Node.While).?;
            if (nodeContainsSourceIndex(tree, while_node.body, source_index)) {
                if (while_node.payload) |payload| {
                    std.debug.assert(payload.id == .PointerPayload);
                    const ptr_payload = payload.cast(ast.Node.PointerPayload).?;
                    std.debug.assert(ptr_payload.value_symbol.id == .Identifier);

                    try decls.append(try makeVarDeclNode(
                        &arena.allocator,
                        null,
                        null,
                        ptr_payload.value_symbol.firstToken(),
                        null,
                        try makeUnwrapNode(&arena.allocator, while_node.condition),
                    ));
                }
                return try declsFromIndexInternal(arena, decls, tree, while_node.body, source_index, innermost_container);
            }

            if (while_node.@"else") |else_node| {
                if (nodeContainsSourceIndex(tree, else_node.body, source_index)) {
                    if (else_node.payload) |payload| {
                        try declsFromIndexInternal(arena, decls, tree, payload, source_index, innermost_container);
                    }
                    return try declsFromIndexInternal(arena, decls, tree, else_node.body, source_index, innermost_container);
                }
            }
        },
        .For => {
            const for_node = node.cast(ast.Node.For).?;
            if (nodeContainsSourceIndex(tree, for_node.body, source_index)) {
                std.debug.assert(for_node.payload.id == .PointerIndexPayload);
                const ptr_idx_payload = for_node.payload.cast(ast.Node.PointerIndexPayload).?;
                std.debug.assert(ptr_idx_payload.value_symbol.id == .Identifier);
                try decls.append(try makeVarDeclNode(
                    &arena.allocator,
                    null,
                    null,
                    ptr_idx_payload.value_symbol.firstToken(),
                    null,
                    try makeAccessNode(&arena.allocator, for_node.array_expr),
                ));

                if (ptr_idx_payload.index_symbol) |idx| {
                    try decls.append(idx);
                }

                return try declsFromIndexInternal(arena, decls, tree, for_node.body, source_index, innermost_container);
            }

            if (for_node.@"else") |else_node| {
                if (nodeContainsSourceIndex(tree, else_node.body, source_index)) {
                    if (else_node.payload) |payload| {
                        try declsFromIndexInternal(arena, decls, tree, payload, source_index, innermost_container);
                    }
                    return try declsFromIndexInternal(arena, decls, tree, else_node.body, source_index, innermost_container);
                }
            }
        },
        .Switch => {
            const switch_node = node.cast(ast.Node.Switch).?;
            for (switch_node.casesConst()) |case| {
                const case_node = case.*.cast(ast.Node.SwitchCase).?;
                if (nodeContainsSourceIndex(tree, case_node.expr, source_index)) {
                    if (case_node.payload) |payload| {
                        try declsFromIndexInternal(arena, decls, tree, payload, source_index, innermost_container);
                    }
                    return try declsFromIndexInternal(arena, decls, tree, case_node.expr, source_index, innermost_container);
                }
            }
        },
        // TODO: These convey no type information...
        .Payload => try decls.append(node.cast(ast.Node.Payload).?.error_symbol),
        .PointerPayload => try decls.append(node.cast(ast.Node.PointerPayload).?.value_symbol),
        // This should be completely handled for the .For code.
        .PointerIndexPayload => unreachable,
        .VarDecl => {
            try decls.append(node);
            if (node.cast(ast.Node.VarDecl).?.init_node) |child| {
                if (nodeContainsSourceIndex(tree, child, source_index)) {
                    try declsFromIndexInternal(arena, decls, tree, child, source_index, innermost_container);
                }
            }
        },
        else => {},
    }
}

pub fn addChildrenNodes(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree, node: *ast.Node) !void {
    var node_idx: usize = 0;
    while (node.iterate(node_idx)) |child_node| : (node_idx += 1) {
        try decls.append(child_node);
    }
}

pub fn declsFromIndex(arena: *std.heap.ArenaAllocator, decls: *std.ArrayList(*ast.Node), tree: *ast.Tree, source_index: usize) !*ast.Node {
    var innermost_container = &tree.root_node.base;
    try declsFromIndexInternal(arena, decls, tree, &tree.root_node.base, source_index, &innermost_container);
    return innermost_container;
}

fn nodeContainsSourceIndex(tree: *ast.Tree, node: *ast.Node, source_index: usize) bool {
    const first_token = tree.token_locs[node.firstToken()];
    const last_token = tree.token_locs[node.lastToken()];
    return source_index >= first_token.start and source_index <= last_token.end;
}

fn nodeComesAfterSourceIndex(tree: *ast.Tree, node: *ast.Node, source_index: usize) bool {
    const first_token = tree.token_locs[node.firstToken()];
    const last_token = tree.token_locs[node.lastToken()];
    return source_index < first_token.start;
}

pub fn getImportStr(tree: *ast.Tree, source_index: usize) ?[]const u8 {
    var node = &tree.root_node.base;

    var child_idx: usize = 0;
    while (node.iterate(child_idx)) |child| {
        if (!nodeContainsSourceIndex(tree, child, source_index)) {
            child_idx += 1;
            continue;
        }
        if (child.cast(ast.Node.BuiltinCall)) |builtin_call| blk: {
            const call_name = tree.tokenSlice(builtin_call.builtin_token);

            if (!std.mem.eql(u8, call_name, "@import")) break :blk;
            if (builtin_call.params_len != 1) break :blk;

            const import_param = builtin_call.paramsConst()[0];
            const import_str_node = import_param.cast(ast.Node.StringLiteral) orelse break :blk;
            const import_str = tree.tokenSlice(import_str_node.token);
            return import_str[1 .. import_str.len - 1];
        }
        node = child;
        child_idx = 0;
    }
    return null;
}

pub const SourceRange = std.zig.Token.Loc;

pub const PositionContext = union(enum) {
    builtin: SourceRange,
    comment,
    string_literal: SourceRange,
    field_access: SourceRange,
    var_access: SourceRange,
    global_error_set,
    enum_literal,
    other,
    empty,

    pub fn range(self: PositionContext) ?SourceRange {
        return switch (self) {
            .builtin => |r| r,
            .comment => null,
            .string_literal => |r| r,
            .field_access => |r| r,
            .var_access => |r| r,
            .enum_literal => null,
            .other => null,
            .empty => null,
            .global_error_set => null,
        };
    }
};

const StackState = struct {
    ctx: PositionContext,
    stack_id: enum { Paren, Bracket, Global },
};

fn peek(arr: *std.ArrayList(StackState)) !*StackState {
    if (arr.items.len == 0) {
        try arr.append(.{ .ctx = .empty, .stack_id = .Global });
    }
    return &arr.items[arr.items.len - 1];
}

fn tokenRangeAppend(prev: SourceRange, token: std.zig.Token) SourceRange {
    return .{
        .start = prev.start,
        .end = token.loc.end,
    };
}

pub fn documentPositionContext(allocator: *std.mem.Allocator, document: types.TextDocument, position: types.Position) !PositionContext {
    const line = try document.getLine(@intCast(usize, position.line));
    const pos_char = @intCast(usize, position.character) + 1;
    const idx = if (pos_char > line.len) line.len else pos_char;

    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();

    var tokenizer = std.zig.Tokenizer.init(line[0..idx]);
    var stack = try std.ArrayList(StackState).initCapacity(&arena.allocator, 8);

    while (true) {
        const tok = tokenizer.next();
        // Early exits.
        switch (tok.id) {
            .Invalid, .Invalid_ampersands => {
                // Single '@' do not return a builtin token so we check this on our own.
                if (line[idx - 1] == '@') {
                    return PositionContext{
                        .builtin = .{
                            .start = idx - 1,
                            .end = idx,
                        },
                    };
                }
                return .other;
            },
            .LineComment, .DocComment, .ContainerDocComment => return .comment,
            .Eof => break,
            else => {},
        }

        // State changes
        var curr_ctx = try peek(&stack);
        switch (tok.id) {
            .StringLiteral, .MultilineStringLiteralLine => curr_ctx.ctx = .{ .string_literal = tok.loc },
            .Identifier => switch (curr_ctx.ctx) {
                .empty => curr_ctx.ctx = .{ .var_access = tok.loc },
                else => {},
            },
            .Builtin => switch (curr_ctx.ctx) {
                .empty => curr_ctx.ctx = .{ .builtin = tok.loc },
                else => {},
            },
            .Period, .PeriodAsterisk => switch (curr_ctx.ctx) {
                .empty => curr_ctx.ctx = .enum_literal,
                .enum_literal => curr_ctx.ctx = .empty,
                .field_access => {},
                .other => {},
                .global_error_set => {},
                else => curr_ctx.ctx = .{
                    .field_access = tokenRangeAppend(curr_ctx.ctx.range().?, tok),
                },
            },
            .QuestionMark => switch (curr_ctx.ctx) {
                .field_access => {},
                else => curr_ctx.ctx = .empty,
            },
            .LParen => try stack.append(.{ .ctx = .empty, .stack_id = .Paren }),
            .LBracket => try stack.append(.{ .ctx = .empty, .stack_id = .Bracket }),
            .RParen => {
                _ = stack.pop();
                if (curr_ctx.stack_id != .Paren) {
                    (try peek(&stack)).ctx = .empty;
                }
            },
            .RBracket => {
                _ = stack.pop();
                if (curr_ctx.stack_id != .Bracket) {
                    (try peek(&stack)).ctx = .empty;
                }
            },
            .Keyword_error => curr_ctx.ctx = .global_error_set,
            else => curr_ctx.ctx = .empty,
        }

        switch (curr_ctx.ctx) {
            .field_access => |r| curr_ctx.ctx = .{
                .field_access = tokenRangeAppend(r, tok),
            },
            else => {},
        }
    }

    return block: {
        if (stack.popOrNull()) |state| break :block state.ctx;
        break :block .empty;
    };
}

fn addOutlineNodes(allocator: *std.mem.Allocator, children: *std.ArrayList(types.DocumentSymbol), tree: *ast.Tree, child: *ast.Node) anyerror!void {
    switch (child.id) {
        .StringLiteral, .IntegerLiteral, .BuiltinCall, .Call, .Identifier, .InfixOp, .PrefixOp, .SuffixOp, .ControlFlowExpression, .ArrayInitializerDot, .SwitchElse, .SwitchCase, .For, .EnumLiteral, .PointerIndexPayload, .StructInitializerDot, .PointerPayload, .While, .Switch, .Else, .BoolLiteral, .NullLiteral, .Defer, .StructInitializer, .FieldInitializer, .If, .MultilineStringLiteral, .UndefinedLiteral, .VarType, .Block => return,

        .ContainerDecl => {
            const decl = child.cast(ast.Node.ContainerDecl).?;

            for (decl.fieldsAndDecls()) |cchild|
                try addOutlineNodes(allocator, children, tree, cchild);
            return;
        },
        else => {},
    }
    _ = try children.append(try getDocumentSymbolsInternal(allocator, tree, child));
}

fn getDocumentSymbolsInternal(allocator: *std.mem.Allocator, tree: *ast.Tree, node: *ast.Node) anyerror!types.DocumentSymbol {
    // const symbols = std.ArrayList(types.DocumentSymbol).init(allocator);
    const start_loc = tree.tokenLocation(0, node.firstToken());
    const end_loc = tree.tokenLocation(0, node.lastToken());
    const range = types.Range{
        .start = .{
            .line = @intCast(i64, start_loc.line),
            .character = @intCast(i64, start_loc.column),
        },
        .end = .{
            .line = @intCast(i64, end_loc.line),
            .character = @intCast(i64, end_loc.column),
        },
    };

    if (getDeclName(tree, node) == null) {
        std.debug.warn("NULL NAME: {}\n", .{node.id});
    }

    // TODO: Get my lazy bum to fix detail newlines
    return types.DocumentSymbol{
        .name = getDeclName(tree, node) orelse "no_name",
        // .detail = (try getDocComments(allocator, tree, node)) orelse "",
        .detail = "",
        .kind = switch (node.id) {
            .FnProto => .Function,
            .VarDecl => .Variable,
            .ContainerField => .Field,
            else => .Variable,
        },
        .range = range,
        .selectionRange = range,
        .children = ch: {
            var children = std.ArrayList(types.DocumentSymbol).init(allocator);

            var index: usize = 0;
            while (node.iterate(index)) |child| : (index += 1) {
                try addOutlineNodes(allocator, &children, tree, child);
            }

            break :ch children.items;
        },
    };

    // return symbols.items;
}

pub fn getDocumentSymbols(allocator: *std.mem.Allocator, tree: *ast.Tree) ![]types.DocumentSymbol {
    var symbols = std.ArrayList(types.DocumentSymbol).init(allocator);

    for (tree.root_node.decls()) |node| {
        _ = try symbols.append(try getDocumentSymbolsInternal(allocator, tree, node));
    }

    return symbols.items;
}