package service

import (
	"go/ast"
)

var (
	classDeclarations []*Class

	isInMethod          = false
	currentReceiverName = ""
)

type Class struct {
	Name    string
	Struct  *ast.StructType
	methods []*ast.FuncDecl
}

func NewClass(className string) *Class {
	return &Class{Name: className}
}

func (c *Class) String() (code string) {
	code += c.classDefinitionToString()
	code += c.methodImplementationsToString()
	return
}
func (c *Class) classDefinitionToString() (code string) {
	code = "class " + c.Name + " {"
	code += "public:\n"

	code += c.structToString()
	code += "\n"

	code += c.methodDeclarationsToString()
	code += "\n"

	code += "};\n"
	return
}
func (c *Class) structToString() (code string) {
	code += handleExpr(c.Struct)
	code += "\n"
	return
}
func (c *Class) methodDeclarationsToString() (code string) {
	for _, m := range c.methods {
		code += c.methodDeclarationToString(m)
	}
	code += "\n"
	return
}
func (c *Class) methodDeclarationToString(m *ast.FuncDecl) (code string) {
	code += "  "
	code += "void " + m.Name.String() + "();"
	code += "\n"
	return
}

func (c *Class) methodImplementationsToString() (code string) {
	for _, m := range c.methods {
		code += c.methodImplementationToString(m)
	}
	code += "\n"
	return
}

func (c *Class) methodImplementationToString(m *ast.FuncDecl) (code string) {
	code += "void "
	code += c.Name + "::"
	code += m.Name.String() + "("

	code += ") {"
	if len(m.Recv.List) > 0 {
		n := m.Recv.List[0].Names
		if len(n) > 0 {
			isInMethod = true
			currentReceiverName = n[0].Name
		}
	}
	code += handleBlockStmt(m.Body)
	isInMethod = false
	code += "}"

	code += "\n"
	return
}

func (c *Class) AddMethod(m *ast.FuncDecl) {
	c.methods = append(c.methods, m)
}

// Handlers
func handleClass(t *ast.TypeSpec) string {
	st, ok := t.Type.(*ast.StructType)
	if !ok {
		return ""
	}

	addClassFromStructType(t.Name.String(), st)

	return ""
}
func addClassFromStructType(name string, s *ast.StructType) {
	c := createClass(name)
	c.Struct = s
}

func handleMethodDeclaration(fd *ast.FuncDecl) string {
	class := getOrCreateClassFromFuncDecl(fd)
	class.AddMethod(fd)
	return ""
}

func getOrCreateClassFromFuncDecl(fd *ast.FuncDecl) *Class {
	n := getClassNameFromReceiver(fd.Recv)
	return getOrCreateClass(n)
}
func getClassNameFromReceiver(recv *ast.FieldList) string {
	for _, f := range recv.List {
		return getClassNameFromStarReceiver(f.Type)
	}

	return ""
}
func getClassNameFromStarReceiver(expr ast.Expr) string {
	switch e := expr.(type) {
	case *ast.StarExpr:
		return handleExpr(e.X)
	}
	return ""
}

func getOrCreateClass(className string) *Class {
	for _, c := range classDeclarations {
		if c.Name == className {
			return c
		}
	}

	return createClass(className)
}

func createClass(className string) *Class {
	c := NewClass(className)
	addClassDeclaration(c)
	return c
}

func addClassDeclaration(c *Class) {
	dlock.Lock()
	defer dlock.Unlock()

	classDeclarations = append(classDeclarations, c)
}