var moduleDocsCache = make(map[string]ModuleDocs)

type FunctionDoc struct {
	Name        string
	Parameters  string
	Description string
	Example     string
}

type FunctionDocs struct {
	Functions map[string]FunctionDoc
}

type ModuleDocs struct {
	Functions map[string]FunctionDocs
}

func Initialise(s settings.LSPSettings) {
	path := s.KamailioSourcePath() + "/src/modules"
	listOfModules, err := os.ReadDir(path)
	if err != nil {
		fmt.Println("Error reading directory")
		return
	}
	// Get All Modules
	for _, module := range listOfModules {
		// Parse README file for each module
		readme, err := os.ReadFile(path + "/" + module.Name() + "/README")
		if err != nil {
			fmt.Println("Error reading file")
			return
		}

		moduleDocs := NewModuleDocs()
		functionDocs := extractFunctionDoc(strings.Split(string(readme), "\n"))
		functionDocsMap := FunctionDocs{Functions: make(map[string]FunctionDoc)}
		for _, functionDoc := range functionDocs {
			functionDocsMap.AddFunctionDoc(functionDoc)
		}
		moduleDocs.AddFunctionDoc(module.Name(), functionDocsMap)
		moduleDocsCache[module.Name()] = moduleDocs
	}
}

func extractFunctionDoc(lines []string) []FunctionDoc {
	funcPattern := regexp.MustCompile(`^\s*\d+\.\d+\.\s*(\w+)\((.*)\)\s*$`)
	var functionDocs []FunctionDoc
	var functionDoc FunctionDoc
	var inExample bool
	var example string
	var exampleLineCount int
	for _, line := range lines {
		if match := funcPattern.FindStringSubmatch(line); match != nil {
			if functionDoc.Name != "" {
				functionDocs = append(functionDocs, functionDoc)
			}
			functionDoc = FunctionDoc{Name: match[1], Parameters: match[2]}
			inExample = false
			example = ""
		} else if functionDoc.Name != "" {
			if !inExample {
				// example has indentation of some spaces
				if strings.Contains(line, "Example") {
					inExample = true
				} else {
					functionDoc.Description += line + "\n"
				}
			} else {
				if strings.Contains(line, "...") {
					exampleLineCount++
					// end of example if there are 2 lines
					if exampleLineCount == 2 {
						inExample = false
					}
					functionDoc.Example = example
				} else {
					example += line + "\n"
				}
			}
		}
	}
	if functionDoc.Name != "" {
		functionDocs = append(functionDocs, functionDoc)
	}
	return functionDocs
}

type HoverRequest struct {
	Request
	Params HoverParams `json:"params"`
}

type HoverParams struct {
	TextDocuemntPositionParams
}

type HoverResponse struct {
	Response
	Result *Hover `json:"result"`
}

type Hover struct {
	Contents MarkupContent `json:"contents"`
	Range    *Range        `json:"range,omitempty"`
}

func NewHoverResponse(id int, contents string) HoverResponse {
	return HoverResponse{
		Response: Response{
			RPC: "2.0",
			ID:  id,
		},
		Result: &Hover{
			Contents: MarkupContent{
				Kind:  "markdown",
				Value: contents,
			},
		},
	}
}

func handleMessage(writer io.Writer, logger *log.Logger, state analysis.State, method string, contents []byte, analyser_channel chan analysis.State) {
	logger.Println("Received message with method: ", method)
	switch method {

	case MethodInitialize:
        ...

	case MethodDidOpen:
		...

    case MethodHover:
		var request lsp.HoverRequest
		if error := json.Unmarshal(contents, &request); error != nil {
			logger.Println("Error unmarshalling hover request: ", error)
			return
		}
		logger.Println("Hover request for document with URI: ", request.Params.TextDocument.URI)
		response := state.Hover(request.ID, request.Params.TextDocument.URI, request.Params.Position)
		logger.Printf("Sent hover response %v", response)
		lsp.WriteResponse(writer, response)

	case MethodDidChange:
        ...
	case MethodDefinition:
        ...
	case MethodFormatting:
        ...
	}
}

type State struct {
	// Key: URI, Value: Text content
	Documents map[lsp.DocumentURI]string
}

func (s *State) Hover(id int, uri lsp.DocumentURI, position lsp.Position) lsp.HoverResponse {
	text := s.Documents[uri]
	functionName := GetFunctionNameAtPosition(uri, position, []byte(text))
	documentation := docs.FindFunctionInAllModules(functionName)
	return lsp.NewHoverResponse(id, fmt.Sprintf("%s", documentation))
}

func GetFunctionNameAtPosition(uri lsp.DocumentURI, position lsp.Position, source_code []byte) string {
	node := stateTreeCache.nodes[uri]
	return getFunctionName(node, position, source_code)
}

func getFunctionName(node *sitter.Node, position lsp.Position, source_code []byte) string {
	nodeAtPosition := node.NamedDescendantForPointRange(
		sitter.Point{
			Row:    uint32(position.Line),
			Column: uint32(position.Character),
		},
		sitter.Point{
			Row:    uint32(position.Line),
			Column: uint32(position.Character),
		})
	functionName := nodeAtPosition.Content(source_code)
	return functionName
}

func FindFunctionInAllModules(functionName string) string {
	for moduleName, moduleDocs := range moduleDocsCache {
		if _, exists := moduleDocs.Functions[moduleName].Functions[functionName]; exists {
			return "Module: " + moduleName + "\n" + moduleDocs.GetFunctionDocAsString(moduleName, functionName)
		}
	}
	return "Function not found"
}

type Parser struct {
	parser   *sitter.Parser
	language *sitter.Language
	tree     *sitter.Tree
}

func NewParser() *Parser {
	return &Parser{
		parser: sitter.NewParser(),
	}
}

func (p *Parser) SetLanguage() {
	p.language = sitter.NewLanguage(kamailio_cfg.Language())
	p.parser.SetLanguage(p.language)
}

func (p *Parser) GetLanguage() *sitter.Language {
	return p.language
}

func (p *Parser) Parse(sourceCode []byte) *sitter.Node {
	tree, _ := p.parser.ParseCtx(context.Background(), nil, sourceCode)
	p.tree = tree
	n := p.tree.RootNode()
	return n
}

func (p *Parser) GetTree() *sitter.Tree {
	return p.tree
}

func (p *Parser) UpdateTree(content []byte) {
	newTree, _ := p.parser.ParseCtx(context.Background(), p.tree, content)
	p.tree = newTree
}
type StateTree struct {
    nodes map[lsp.DocumentURI]*sitter.Node
}

// module level state tree
var stateTreeCache StateTree

func NewStateTree() StateTree {
    return StateTree{
        nodes: make(map[lsp.DocumentURI]*sitter.Node),
    }
}

func (s *StateTree) AddNode(uri lsp.DocumentURI, node *sitter.Node) {
    s.nodes[uri] = node
}

func StartAnalyser(c <-chan State, writer io.Writer, logger *log.Logger, wg *sync.WaitGroup) {
    defer wg.Done()
    parser := NewParser()
    parser.SetLanguage()
    stateTree := NewStateTree()
    logger.Println("=====Analyser started")

    for {
        select {
        case state, ok := <-c:
            if !ok {
                logger.Println("Channel closed! Exiting...")
                return
            }
            for uri, content := range state.Documents {
                node := parser.Parse([]byte(content))
                //...
                stateTreeCache = stateTree
            }
        }
    }
}