package main

import (
	_ "embed"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	logger "git.site.quack-lab.dev/dave/cylogger"
	"github.com/PuerkitoBio/goquery"
)

//go:embed class.tmpl
var templatestr string
var classTemplate *template.Template

var fns = template.FuncMap{
	"plus1": func(x int) int {
		return x + 1
	},
}

func init() {
	var err error
	classTemplate, err = template.New("class").Funcs(fns).Parse(templatestr)
	if err != nil {
		logger.Error("Error parsing template: %v", err)
		return
	}
}

type (
	Class struct {
		ClassName    string
		Fields       []Field
		Methods      []Method
		Constructors []Constructor
	}
	Field struct {
		Name    string
		Type    string
		Comment string
	}
	Method struct {
		Name    string
		Params  []Param
		Returns []Return
		Comment string
	}
	Param struct {
		Name    string
		Type    string
		Comment string
	}
	Return struct {
		Type    string
		Comment string
	}
	Constructor struct {
		Params  []Param
		Comment string
	}
)

func (c *Class) GetOutFile(root string) (*os.File, error) {
	if c.ClassName == "" {
		return nil, fmt.Errorf("ClassName is empty")
	}
	filename := fmt.Sprintf("%s.lua", c.ClassName)
	filename = strings.ReplaceAll(filename, " ", "")
	filename = strings.ReplaceAll(filename, "-", "")
	filename = strings.ReplaceAll(filename, ",", "")
	filename = strings.ReplaceAll(filename, ":", "")
	filePath := filepath.Join(root, filename)
	filePath = filepath.Clean(filePath)
	f, err := os.Create(filePath)
	if err != nil {
		return nil, err
	}
	return f, nil
}

func (c *Class) Write(root string, tmpl *template.Template) error {
	outfile, err := c.GetOutFile(root)
	if err != nil {
		return fmt.Errorf("error creating output file %v: %v", c.ClassName, err)
	}
	err = tmpl.Execute(outfile, c)
	if err != nil {
		return fmt.Errorf("error writing output file %v: %v", c.ClassName, err)
	}
	return nil
}

func ParseClass(file string) (*Class, error) {
	log := logger.Default.WithPrefix(file)
	log.Info("Parsing file")
	res := Class{
		Fields:       []Field{},
		Methods:      []Method{},
		Constructors: []Constructor{},
	}
	filehandle, err := os.Open(file)
	if err != nil {
		return nil, fmt.Errorf("error opening file: %w", err)
	}
	defer filehandle.Close()

	doc, err := goquery.NewDocumentFromReader(filehandle)
	if err != nil {
		return nil, fmt.Errorf("error parsing file: %w", err)
	}

	class := doc.Find("div.floatright > h1")
	if class.Length() == 0 {
		return nil, fmt.Errorf("no class found")
	}
	res.ClassName = strings.TrimSpace(class.Text())

	res.Constructors, err = getConstructors(doc)
	if err != nil {
		return nil, fmt.Errorf("error getting constructors: %w", err)
	}

	res.Fields, err = getFields(doc)
	if err != nil {
		return nil, fmt.Errorf("error getting fields: %w", err)
	}

	res.Methods, err = getMethods(doc)
	if err != nil {
		return nil, fmt.Errorf("error getting methods: %w", err)
	}

	log.Info("Parsing complete")
	return &res, nil
}

// TODO: Implement parsing comments for return values
// Something like "---returns (something) -> comment"
// Where "-> comment" is only shown if there's a comment
// And "---returns" only if there's a return type
// This is NOT a luals annotation because we can not use annotations on @overload
// But just a regular plain Lua comment
// TODO: Implement parsing comments for classes and constructors
func getConstructors(doc *goquery.Document) ([]Constructor, error) {
	res := []Constructor{}

	codeblocks := doc.Find("div.floatright > div.codecontainer")
	if codeblocks.Length() == 0 {
		return res, fmt.Errorf("no codeblocks found")
	}

	// The first code block should be the constructor
	// So far I have not found any classes with overloaded constructors...
	// So I can not handle that case yet
	constructorBlock := codeblocks.Eq(0)
	constructor := constructorBlock.Find("div.function")
	paramTypes := constructor.Find("span.type")
	paramNames := constructor.Find("span.parameter")

	resConstructor := Constructor{}
	paramTypes.Each(func(i int, s *goquery.Selection) {
		pname := strings.TrimSpace(paramNames.Eq(i).Text())
		ptype := strings.TrimSpace(paramTypes.Eq(i).Text())
		ptype = MapType(ptype)

		resConstructor.Params = append(resConstructor.Params, Param{
			Name:    pname,
			Type:    ptype,
			Comment: "",
		})
	})

	constructorDetails := constructorBlock.Children().Eq(1)
	constructorParameterDetails := constructorDetails.Find("span.parameter")
	constructorParameterDetails.Each(func(i int, s *goquery.Selection) {
		param := strings.TrimSpace(s.Text())
		parameterParent := s.Parent()
		parameterDescription := parameterParent.Text()
		parameterDescription = strings.ReplaceAll(parameterDescription, fmt.Sprintf("\n%s\n", param), "")
		parameterDescription = strings.TrimSpace(parameterDescription)
		resConstructor.Params[i].Comment = parameterDescription
	})

	constructorBlock.Find("div:not(.function):not(.indented) > p:not(:has(*))").Each(func(i int, s *goquery.Selection) {
		resConstructor.Comment += strings.TrimSpace(s.Text()) + "\n"
		resConstructor.Comment = strings.TrimSpace(resConstructor.Comment)
	})

	logger.Dump("resConstructor", resConstructor)
	return append(res, resConstructor), nil
}

func getFields(doc *goquery.Document) ([]Field, error) {
	res := []Field{}
	properties := doc.Find("div.floatright > div.codecontainer#Properties")
	properties.ChildrenFiltered("div").Each(func(i int, s *goquery.Selection) {
		property := Field{}
		property.Name = strings.TrimSpace(s.Find("span.property").Text())
		property.Type = strings.TrimSpace(s.Find("span.type").Text())
		property.Type = MapType(property.Type)
		comment := s.Find("td[align='right']").Text()
		if comment != "" {
			property.Comment = strings.TrimSpace(comment)
		}
		res = append(res, property)
	})
	return res, nil
}

// TODO: Implement parsing return value types and comments
func getMethods(doc *goquery.Document) ([]Method, error) {
	res := []Method{}

	codeblocks := doc.Find("div.floatright > div.codecontainer")
	codeblocks.ChildrenFiltered("div.function").Each(func(i int, s *goquery.Selection) {
		method := Method{}
		method.Name = strings.TrimSpace(s.AttrOr("id", ""))
		method.Comment = strings.TrimSpace(s.Find("span.comment").Text())

		types := s.Find("span.type")
		parameters := s.Find("span.parameter")
		types.Each(func(i int, s *goquery.Selection) {
			param := Param{}
			param.Name = strings.TrimSpace(parameters.Eq(i).Text())
			if IsReservedKeyword(param.Name) {
				param.Name = fmt.Sprintf("__%s", param.Name)
			}
			param.Type = strings.TrimSpace(types.Eq(i).Text())
			param.Type = MapType(param.Type)
			method.Params = append(method.Params, param)
		})

		res = append(res, method)
	})

	return res, nil
}