package main

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

	"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 {
		Error.Printf("Error parsing template: %v", err)
		return
	}
}

type (
	Class struct {
		ClassName    string
		Description  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
		Returns string
		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)
	log.Printf("Writing file to '%s'", 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)
	}
	// spew.Dump(c)
	err = tmpl.Execute(outfile, c)
	if err != nil {
		return fmt.Errorf("error writing output file %v: %v", c.ClassName, err)
	}
	return nil
}

type ClassParser struct {
	log       *log.Logger
	inputfile string
}

func NewClassParser(file string) *ClassParser {
	return &ClassParser{
		log:       log.New(io.MultiWriter(os.Stdout, os.Stderr), fmt.Sprintf("%s[ClassParser] %s%s", GenerateRandomAnsiColor(), file, Reset), log.Lmicroseconds|log.Lshortfile),
		inputfile: file,
	}
}

func (p *ClassParser) Parse() (*Class, error) {
	p.log.Printf("Parsing file: '%s'", p.inputfile)
	res := Class{
		Fields:       []Field{},
		Methods:      []Method{},
		Constructors: []Constructor{},
	}
	filehandle, err := os.Open(p.inputfile)
	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)
	}
	p.log.Printf("Document loaded")

	dataContainer := doc.Find("div.floatright")
	if dataContainer.Length() == 0 {
		return nil, fmt.Errorf("no data container found")
	}
	p.log.Printf("Data container found")

	className, err := p.getClassName(dataContainer)
	if err != nil {
		return nil, fmt.Errorf("error getting class name: %w", err)
	}
	res.ClassName = className
	p.log.Printf("Class name resolved as '%s'", res.ClassName)

	classDescription, err := p.getClassDescription(dataContainer)
	if err == nil {
		// return nil, fmt.Errorf("error getting class description: %w", err)
		res.Description = classDescription
		p.log.Printf("Class description resolved as '%s'", res.Description)
	}

	constructor, err := p.getConstructor(dataContainer)
	if err != nil {
		return nil, fmt.Errorf("error getting constructor: %w", err)
	}
	res.Constructors = append(res.Constructors, constructor)
	p.log.Printf("Constructor resolved")

	// Doing div+div specifically skips only the constructor which is usually the first div
	// So the constructor would then be located at h1 + p + div OR h1 + div if there is no description (no p)
	dataElements := dataContainer.ChildrenFiltered("div + div")
	if dataElements.Length() == 0 {
		return nil, fmt.Errorf("no data elements found")
	}
	p.log.Printf("Data elements (%d) found", dataElements.Length())

	dataElements.Each(func(i int, s *goquery.Selection) {
		id, ok := s.Attr("id")
		if !ok {
			return
		}
		if id == "Properties" {
			s.Children().Each(func(i int, s *goquery.Selection) {
				p.log.Printf("Parsing field")
				field, err := p.parseField(s)
				if err != nil {
					Error.Printf("Error parsing field: %v", err)
					return
				}
				res.Fields = append(res.Fields, field)
			})
		} else {
			p.log.Printf("Parsing method")
			method, err := p.parseMethod(s)
			if err != nil {
				Error.Printf("Error parsing method: %v", err)
				return
			}
			res.Methods = append(res.Methods, method)
		}
	})

	p.log.Printf("Class parsed")
	return &res, nil
}

func (p *ClassParser) getClassName(dataContainer *goquery.Selection) (string, error) {
	p.log.Printf("Getting class name")
	class := dataContainer.ChildrenFiltered("h1")
	if class.Length() == 0 {
		return "", fmt.Errorf("no class found")
	}
	res := CleanUp(class.Text())
	p.log.Printf("Class name resolved as '%s'", res)
	return res, nil
}

var manySpaceRe = regexp.MustCompile(`\s{2,}`)

func (p *ClassParser) getClassDescription(dataContainer *goquery.Selection) (string, error) {
	p.log.Printf("Getting class description")
	class := dataContainer.ChildrenFiltered("h1 + p")
	if class.Length() == 0 {
		return "", fmt.Errorf("no class description found")
	}
	res := CleanUp(class.Text())
	p.log.Printf("Class description resolved as '%s'", res)
	return res, nil
}

func (p *ClassParser) getConstructor(dataContainer *goquery.Selection) (Constructor, error) {
	resConstructor := Constructor{}
	p.log.Printf("Getting constructor")

	constructorBlock := dataContainer.Find("h1 + p + div")
	if constructorBlock.Length() == 0 {
		p.log.Printf("No constructor block found, trying fallback (h1 + div)")
		constructorBlock = dataContainer.Find("h1 + div")
		if constructorBlock.Length() == 0 {
			return resConstructor, fmt.Errorf("no constructor found")
		}
		p.log.Printf("Fallback constructor block found")
	}

	types := constructorBlock.Find("div.function span.type")
	if types.Length() == 0 {
		return resConstructor, fmt.Errorf("no types found")
	}
	p.log.Printf("Constructor types found")
	params := constructorBlock.Find("div.function span.parameter")
	if params.Length() == 0 {
		return resConstructor, fmt.Errorf("no params found")
	}
	p.log.Printf("Constructor params found")

	types.Each(func(i int, s *goquery.Selection) {
		resConstructor.Params = append(resConstructor.Params, Param{
			Name:    CleanUp(params.Eq(i).Text()),
			Type:    MapType(CleanUp(types.Eq(i).Text())),
			Comment: "",
		})
	})
	p.log.Printf("Constructor params resolved")

	descriptor := constructorBlock.Find("div:not(.function)")
	if descriptor.Length() == 0 {
		return resConstructor, fmt.Errorf("no descriptor found")
	}
	p.log.Printf("Constructor descriptor found")

	// 0 nothing
	// 1 parameters
	// 2 returns
	state := 0
	children := descriptor.Eq(0).Children()
	childrenLength := children.Length()
	children.Each(func(i int, s *goquery.Selection) {
		if i == childrenLength-1 {
			// For some stupid reason the last child is always a mispalced </p> tag that does not close any open <p>
			// I assume this is a bug with their documentation generator
			// So we just ignore it
			return
		}
		text := CleanUp(s.Text())
		if text == "" {
			return
		}
		if s.Is("p") {
			switch text {
			case "Parameters":
				state = 1
				return
			case "Returns":
				state = 2
				return
			}
		} else {
			switch state {
			case 0:
				return
			case 1:
				param := s.ChildrenFiltered("span.parameter").Text()
				paramTrimmed := CleanUp(param)
				p.log.Printf("Parameter '%s' found", paramTrimmed)
				for i := range resConstructor.Params {
					cparam := &resConstructor.Params[i]
					if paramTrimmed == cparam.Name {
						cleanText := strings.TrimPrefix(text, param)
						cparam.Comment = CleanUp(cleanText)
					}
				}
			case 2:
				cleaned := CleanUp(s.Text())
				p.log.Printf("Return value '%s' found", cleaned)
				if resConstructor.Returns != "" {
					resConstructor.Returns += "\n"
				}
				resConstructor.Returns = cleaned
			}
		}
	})

	p.log.Printf("Constructor resolved")
	// spew.Dump(resConstructor)
	return resConstructor, nil
}

func (p *ClassParser) parseField(s *goquery.Selection) (Field, error) {
	res := Field{}
	p.log.Printf("Parsing field")

	id, ok := s.Attr("id")
	if !ok {
		return res, fmt.Errorf("no id found")
	}
	res.Name = id
	p.log.Printf("Field name resolved as '%s'", res.Name)

	typeElement := s.Find("span.type")
	if typeElement.Length() == 0 {
		return res, fmt.Errorf("no type found")
	}
	res.Type = MapType(CleanUp(typeElement.Text()))
	p.log.Printf("Field type resolved as '%s'", res.Type)

	readonlyElement := s.Find("td[align='right']")
	if readonlyElement.Length() != 0 {
		// return res, fmt.Errorf("no readonly found")
		res.Comment = CleanUp(readonlyElement.Text())
		p.log.Printf("Field comment resolved as '%s'", res.Comment)
	}

	comments := s.ChildrenFiltered("div")
	if comments.Length() == 0 {
		return res, fmt.Errorf("no comments found")
	}
	comments.Each(func(i int, s *goquery.Selection) {
		text := CleanUp(s.Text())
		if text == "" {
			return
		}
		p.log.Printf("Field comment resolved as '%s'", text)
		if res.Comment != "" {
			res.Comment += ". "
		}
		res.Comment += text
	})
	res.Comment = strings.ReplaceAll(res.Comment, "\n--", ". ")

	p.log.Printf("Field resolved")
	return res, nil
}

func (p *ClassParser) parseMethod(s *goquery.Selection) (Method, error) {
	res := Method{}
	p.log.Printf("Parsing method")

	id, ok := s.Attr("id")
	if !ok {
		return res, fmt.Errorf("no id found")
	}
	res.Name = id
	p.log.Printf("Method name resolved as '%s'", res.Name)

	signatureData := s.Children().Eq(0)
	returns := signatureData.Find("span.keyword")
	if returns.Length() != 0 {
		returnsText := CleanUp(returns.Text())
		returnsText = strings.ReplaceAll(returnsText, "function", "")
		returnsText = CleanUp(returnsText)

		res.Returns = append(res.Returns, Return{
			Type:    MapType(returnsText),
			Comment: "",
		})
		p.log.Printf("Method return value resolved as '%s'", res.Returns[0].Type)
	}

	types := signatureData.Find("span.type")
	parameters := signatureData.Find("span.parameter")
	types.Each(func(i int, s *goquery.Selection) {
		res.Params = append(res.Params, Param{
			Name:    MapName(CleanUp(parameters.Eq(i).Text())),
			Type:    MapType(CleanUp(types.Eq(i).Text())),
			Comment: "",
		})
		p.log.Printf("Method parameter resolved as '%s'", res.Params[i].Name)
	})

	// 0 nothing
	// 1 parameters
	// 2 returns
	state := 0
	signatureDetails := s.Children().Eq(1)
	signatureDetailsChildren := signatureDetails.Children()
	signatureDetailsChildrenLength := signatureDetailsChildren.Length()
	signatureDetailsChildren.Each(func(i int, s *goquery.Selection) {
		if s.Is("p") && i == 0 {
			methodDescription := CleanUp(s.Text())
			methodDescription = strings.ReplaceAll(methodDescription, "\n--", "<br>\n\t---")
			res.Comment = methodDescription
			p.log.Printf("Method description resolved as '%s'", res.Comment)
		}
		if i == signatureDetailsChildrenLength-1 {
			// For some stupid reason the last child is always a mispalced </p> tag that does not close any open <p>
			// I assume this is a bug with their documentation generator
			// So we just ignore it
			return
		}
		text := CleanUp(s.Text())
		if text == "" {
			return
		}
		if s.Is("p") {
			switch text {
			case "Parameters":
				state = 1
			case "Returns":
				state = 2
				return
			}
		} else {
			if s.Is("div.indented") {
				if state == 1 {
					parameter := ""
					html, err := s.Html()
					if err != nil {
						Error.Printf("Error parsing html: %v", err)
						return
					}
					html = strings.ReplaceAll(html, "\t", "")
					htmlLines := strings.Split(html, "\n")
					for _, line := range htmlLines {
						if strings.Contains(line, "<span class=\"parameter\">") {
							line = strings.TrimSpace(line)
							line = strings.ReplaceAll(line, "<span class=\"parameter\">", "")
							line = strings.ReplaceAll(line, "</span>", "")
							parameter = line
							p.log.Printf("Parameter '%s' found", parameter)
							continue
						}
						if strings.Contains(line, "<br/>") {
							comment := strings.TrimSpace(line)
							comment = strings.ReplaceAll(comment, "<br/>", "")
							for i := range res.Params {
								if res.Params[i].Name == parameter {
									res.Params[i].Comment = comment
									p.log.Printf("Parameter '%s' comment resolved as '%s'", parameter, comment)
									break
								}
							}
						}
					}
				} else if state == 2 {
					text := CleanUp(s.Text())
					if text == "" {
						return
					}
					p.log.Printf("Return value comment '%s' found", text)
					// TODO: Figure out what to do when a function
					if res.Returns[0].Comment != "" {
						res.Returns[0].Comment += "\n"
					}
					res.Returns[0].Comment += text
				}
			}
		}
	})

	p.log.Printf("Method resolved")
	return res, nil
}

func CleanUp(s string) string {
	s = strings.TrimSpace(s)
	s = strings.ReplaceAll(s, "\t", " ")
	s = strings.ReplaceAll(s, "\n", "")
	s = manySpaceRe.ReplaceAllString(s, " ")
	s = strings.ReplaceAll(s, ". ", "\n--")
	return s
}