package types

import (
	"fmt"
	"regexp"
	"strings"
)

//super is a map recording which class is the parent of each other class
var super map[string]string

//wrapped is a map recording whether a given GoType is to be "wrapped" in a
//go struct.
var wrapped map[string]bool

func ShouldWrap(gt string) bool {
	return wrapped[gt]
}

func PtrShouldWrap(gt string) bool {
	return gt != "" && gt[0] == '*' && wrapped[gt[1:]]
}

//goInterfaces records the names of top level Go interfaces.
var goInterfaces map[string]bool

func IsGoInterface(gt string) bool {
	return goInterfaces[gt]
}

func PtrIsGoInterface(gt string) bool {
	return gt != "" && gt[0] == '*' && goInterfaces[gt[1:]]
}

//TypeParameters maps, for each class, a TypedefName to a type, representing
//the Objective-C type parameters for that class
var TypeParameters map[string]map[string]string

//Typedefs maps from C types to the Type of a typedef with that name.
var typedefs map[string]*Type

func (t *Type) Typedef() *Type {
	return typedefs[t.CType()]
}

var (
	r_id           *regexp.Regexp
	r_instancename *regexp.Regexp
	r_instancetype *regexp.Regexp
)

func init() {
	super = make(map[string]string)
	wrapped = make(map[string]bool)
	goInterfaces = make(map[string]bool)
	TypeParameters = make(map[string]map[string]string)
	typedefs = make(map[string]*Type)

	r_id = regexp.MustCompile(`\bid\b`)
	r_instancename = regexp.MustCompile(`\binstancename\b`)
	r_instancetype = regexp.MustCompile(`\binstancetype\b`)
}

func Super(c string) string {
	return super[c]
}

func SetSuper(c, p string) {
	super[c] = p
}

func SetTypeParam(c, n, t string) {
	if TypeParameters[c] == nil {
		TypeParameters[c] = make(map[string]string)
	}
	TypeParameters[c][n] = t
}

func AddTypedef(n string, tp *Type) {
	//fmt.Printf("AddTypedef(): %s -> %s\n",n,t)
	typedefs[n] = tp
}

type Type struct {
	Node     *Node
	Class    string
	Variadic bool
}

func (t *Type) CloneToClass(c string) *Type {
	return &Type{
		Node:     t.Node,
		Class:    c,
		Variadic: t.Variadic,
	}
}

func clean(n *Node, c string) (*Node, bool) {
	if n == nil {
		return nil, false
	}
	ret := NewNode(n.Kind, n.Content)
	ret.Children = n.Children
	//fmt.Printf("clean(%s,%s)\n",n.CType(),c)
	recur := false
	if TypeParameters[c] != nil {
		for k, v := range TypeParameters[c] {
			recur = ret.renameTypedefs(k, v)
		}
	}
	if recur {
		clean(n, c)
		return ret, true
	}
	return n, false
}

func NewType(n *Node, c string) *Type {
	n2, _ := clean(n, c)
	return &Type{
		Node:  n2,
		Class: c,
	}
}

func NewTypeFromString(t, c string) *Type {
	//fmt.Printf("t/c: %s/%s\n",t,c)
	n, err := Parse(t)
	//fmt.Printf("%p %s",n,n.String())
	if err != nil {
		return &Type{}
	}
	if n2, ok := clean(n, c); ok {
		//found type parameters, re-parse
		return NewTypeFromString(n2.CType(), c)
	}
	return &Type{
		Node:  n,
		Class: c,
	}
}

func (t *Type) String() string {
	return t.Node.String()
}

func (t *Type) PointsTo() *Type {
	if td := t.Typedef(); td != nil {
		return td.PointsTo()
	}
	if pt := t.Node.PointsTo(); pt != nil {
		return NewType(t.Node.PointsTo(), t.Class)
	} else {
		return nil
	}
}

func Wrap(s string) {
	//fmt.Printf("wrapped[%s] = true\n",s)
	wrapped[s] = true
}

func (t *Type) BaseType() *Type {
	if t == nil {
		return nil
	}
//	if td := t.Typedef(); td != nil {
//		return td.BaseType()
//	}
	ret := NewType(
		t.Node.BaseType(),
		t.Class,
	)
	return ret
}

func swapstars(s string) string {
	for i := len(s) - 1; i > 0 && s[i] == '*'; {
		s = "*" + s[:i]
	}
	return strings.TrimSpace(s)
}

func (t *Type) CGoType() string {
	ct := swapstars("C." + t.CType())
	ct = strings.ReplaceAll(ct, "unsigned ", "u")
	ct = strings.ReplaceAll(ct, "signed ", "u")
	ct = strings.ReplaceAll(ct, "long ", "long")
	ct = strings.ReplaceAll(ct, "complex ", "complex")
	ct = strings.ReplaceAll(ct, " ", "_")
	return ct
}

func (t *Type) GoType() string {
	return _goType(t.CType())
}

func _goType(ct string) string {
	ct = strings.Title(ct)
	ct = strings.ReplaceAll(ct, " ", "")
	ct = strings.TrimPrefix(ct, "Struct")
	ct = swapstars(ct)
	if len(ct) > 0 && ct[0] == '*' && IsGoInterface(ct[1:]) {
		//return ct[1:]
		return ct // ??
	}
	
	if ct == "Id" {
		ct = "*Id"
	}
	//if len(ct) > 1 && ShouldWrap(ct[1:]) {
	if ShouldWrap(ct) {
		return ct
	}
	if len(ct) > 4 && ct[len(ct)-4:len(ct)] == "Void" {
		ct = ct[:len(ct)-5] + "unsafe.Pointer"
	}
	return ct
}

func (t *Type) CType() string {
	return t._CType(false)
}

func (t *Type) CTypeAttrib() string {
	return t._CType(true)
}

func (t *Type) _CType(attrib bool) string {
	if t == nil {
		//fmt.Println("nil sent to _CType()")
		return ""
	}
	var ct string
	if attrib {
		ignore := map[string]bool{"GenericList": true}
		ct = t.Node._CType(ignore)
	} else {
		ct = t.Node.CTypeSimplified()
	}
	ct = r_id.ReplaceAllString(ct, "NSObject*")
	ct = r_instancename.ReplaceAllString(ct, t.Class)
	ct = r_instancetype.ReplaceAllString(ct, t.Class+"*")
	return ct
}

func (t *Type) GoTypeDecl() string {
	if wrapped[t.GoType()] {
		return t.GoInterfaceDecl()
	}
	if t.Node.IsId() {
		return ""
	}
	gt := t.GoType()
	if Debug {
		fmt.Printf("  writing GoTypeDecl for %s\n",gt)
	}
	switch gt {
	case "", "Void":
		return ""
	default:
		return fmt.Sprintf(`
type %s %s
`, gt, t.CGoType())
	}
}

func (t *Type) GoInterfaceDecl() string {
	ct := t.CType()
	gt := t.GoType()
	if Debug {
		fmt.Printf("  writing GoInterfaceDecl for %s\n",gt)
	}
	if gt[0] == '*' {
		gt = gt[1:] // dereference wrapped types
		ct = ct[:len(ct)-1]
		fmt.Printf("  dereferenced %s\n",gt)
	}
	super := Super(ct)
	if super == "" {
		//fmt.Printf("goInterfaces[%s] = true\n",gt)
		goInterfaces[gt] = true
		return fmt.Sprintf(`
type %s interface {
	Ptr() unsafe.Pointer
}
`, gt)
	}
	if IsGoInterface(super) {
		super = "Id"
	}
	return fmt.Sprintf(`
type %s struct { %s }
func (o *%s) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) %s() *%s {
	ret := &%s{}
	ret.ptr = o.ptr
	return ret
}
`, gt, super, gt, gt, gt, gt)
}

func (t *Type) IsFunctionPtr() bool {
	if t == nil {
		return false
	}
	if td := t.Typedef(); td != nil {
		return td.IsFunctionPtr()
	}
	if pt := t.PointsTo(); pt != nil {
		return pt.IsFunction()
	}
	return false
}

func (t *Type) IsFunction() bool {
	if t == nil {
		//fmt.Println("nil sent to IsFunction()")
		return false
	}
	if td := t.Typedef(); td != nil {
		return td.IsFunction()
	}
	return t.Node.IsFunction()
}

func (t *Type) IsValist() bool {
	if t == nil {
		return false
	}
	if t.GoType() == "__va_list_tag" { // OS dependent
		return true
	}
	return false
}

func (t *Type) ReturnType() *Type {
	if td := t.Typedef(); td != nil {
		return td.ReturnType()
	}
	if rt := t.Node.ReturnType(); rt != nil {
		return NewType(rt, t.Class)
	}
	return nil
}

func (t *Type) IsPointer() bool {
	if t == nil {
		return false
	}
	if td := t.Typedef(); td != nil {
		return td.IsPointer()
	}
	return t.Node.IsPointer()
}

// cast C value to CGo
func (t *Type) CToGo(cval string) string {
	if t.IsPointer() {
		cval = "unsafe.Pointer(" + cval + ")"
	}
	return fmt.Sprintf("(%s)(%s)", t.GoType(), cval)
}

// Call a C function from Go with a given return type and parameter types
func GoToC(name string, pnames, snames []string, rtype *Type, ptypes []*Type, fun, fin bool) string {
	if rtype == nil {
		//fmt.Println("nil sent to GoToC")
		return ""
	}
	var ret strings.Builder
	rt := rtype.CType()
	rtgt := rtype.GoType()
	//fmt.Printf("GoToC(%s): rtgt == %s\n",name,rtgt)
	if PtrIsGoInterface(rtgt) {
		//fmt.Printf("  PtrIsGoInterface(%s) = true\n",rtgt)
		rtgt = "*Id"
	}
	sw := PtrShouldWrap(rtgt) || rtgt == "*Id"
	if rt != "void" {
		if sw {
			ret.WriteString(fmt.Sprintf(
				`ret := &%s{}
	ret.ptr = `, rtgt[1:]))
		} else {
			if rtgt == "BOOL" {
				ret.WriteString("ret := (")
				rtgt = "bool"
			} else {
				ret.WriteString("ret := (" + rtgt + ")(")
			}
			if rtype.IsPointer() {
				ret.WriteString("unsafe.Pointer(")
			}
		}
	}
	ret.WriteString("C." + name + "(")
	parms := []string{}
	for i := 0; i < len(pnames); i++ {
		pn, pt := pnames[i], ptypes[i]
		p := pn
		if (PtrShouldWrap(pt.GoType()) || PtrIsGoInterface(pt.GoType())) && !pt.Variadic {
			p = pn + ".Ptr()"
		} else {
			switch {
			case snames[i] != "":
				p = "unsafe.Pointer(&" + snames[i] + "[0])"
			case pt.Variadic:
				p = "unsafe.Pointer(&" + p + ")"
			case pt.IsPointer() && !fun:
				p = "unsafe.Pointer(" + pn + ")"
			default:
				p = "(" + pt.CGoType() + ")(" + pn + ")"
			}
		}
		parms = append(parms, p)
	}
	ret.WriteString(strings.Join(parms, ", "))
	ret.WriteString(")")
	if rt != "void" && !sw {
		ret.WriteString(")")
		if rtype.IsPointer() {
			ret.WriteString(")")
		}
	}
	if rt == "BOOL" {
		ret.WriteString(" != 0")
	}
	for i, sname := range snames {
		if sname == "" {
			continue
		}
		ptgt := (ptypes[i].GoType())[2:]
		if IsGoInterface(ptgt) {
			ptgt = "Id"
		}
		ret.WriteString(fmt.Sprintf(`
	(*%s) = (*%s)[:cap(*%s)]
	for i := 0; i < len(*%s); i++ {
		if %s[i] == nil {
			(*%s) = (*%s)[:i]
			break
		}
		if (*%s)[i] == nil {
			(*%s)[i] = &%s{}
		}
		(*%s)[i].ptr = %s[i]
	}`, pnames[i], pnames[i], pnames[i], pnames[i], sname, pnames[i], pnames[i], pnames[i], pnames[i], ptgt, pnames[i], sname))
	}
	if rt != "void" {
		if fin {
			ret.WriteString(fmt.Sprintf(`
	runtime.SetFinalizer(ret, func(o *%s) {
		o.Release()
	})`,rtgt))
		}
		ret.WriteString(`
	return ret`)
	}
	return ret.String()
}