// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package go2go

import (
	"fmt"
	"go/ast"
	"go/token"
	"go/types"
	"strconv"
	"strings"
)

// lookupType returns the types.Type for an AST expression.
// Returns nil if the type is not known.
func (t *translator) lookupType(e ast.Expr) types.Type {
	if typ := t.importer.info.TypeOf(e); typ != nil {
		return typ
	}
	if typ, ok := t.types[e]; ok {
		return typ
	}
	return nil
}

// setType records the type for an AST expression. This is only used for
// AST expressions created during function instantiation.
// Uninstantiated AST expressions will be listed in t.importer.info.Types.
func (t *translator) setType(e ast.Expr, nt types.Type) {
	if ot, ok := t.importer.info.Types[e]; ok {
		if !t.sameType(ot.Type, nt) {
			panic("expression type changed")
		}
		return
	}
	if ot, ok := t.types[e]; ok {
		if !t.sameType(ot, nt) {
			panic("expression type changed")
		}
		return
	}
	t.types[e] = nt
}

// instantiateType instantiates typ using ta.
func (t *translator) instantiateType(ta *typeArgs, typ types.Type) types.Type {
	if t.err != nil {
		return nil
	}

	t.typeDepth++
	defer func() { t.typeDepth-- }()
	if t.typeDepth > 25 {
		t.err = fmt.Errorf("looping while instantiating %v %v", typ, ta.types)
		return nil
	}

	var inProgress *typeInstantiation
	for _, inst := range t.typeInstantiations(typ) {
		if t.sameTypes(ta.types, inst.types) {
			if inst.typ == nil {
				inProgress = inst
				break
			}
			return inst.typ
		}
	}

	ityp := t.doInstantiateType(ta, typ)
	if inProgress != nil {
		if inProgress.typ == nil {
			inProgress.typ = ityp
		} else {
			ityp = inProgress.typ
		}
	} else {
		typinst := &typeInstantiation{
			types: ta.types,
			typ:   ityp,
		}
		t.addTypeInstantiation(typ, typinst)
	}

	return ityp
}

// doInstantiateType does the work of instantiating typ using ta.
// This should only be called from instantiateType.
func (t *translator) doInstantiateType(ta *typeArgs, typ types.Type) types.Type {
	switch typ := typ.(type) {
	case *types.Basic:
		return typ
	case *types.Array:
		elem := typ.Elem()
		instElem := t.instantiateType(ta, elem)
		if elem == instElem {
			return typ
		}
		return types.NewArray(instElem, typ.Len())
	case *types.Slice:
		elem := typ.Elem()
		instElem := t.instantiateType(ta, elem)
		if elem == instElem {
			return typ
		}
		return types.NewSlice(instElem)
	case *types.Struct:
		n := typ.NumFields()
		fields := make([]*types.Var, n)
		changed := false
		tags := make([]string, n)
		hasTag := false
		for i := 0; i < n; i++ {
			v := typ.Field(i)
			instType := t.instantiateType(ta, v.Type())
			if v.Type() != instType {
				changed = true
			}
			fields[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), instType)

			tag := typ.Tag(i)
			if tag != "" {
				tags[i] = tag
				hasTag = true
			}
		}
		if !changed {
			return typ
		}
		if !hasTag {
			tags = nil
		}
		return types.NewStruct(fields, tags)
	case *types.Pointer:
		elem := typ.Elem()
		instElem := t.instantiateType(ta, elem)
		if elem == instElem {
			return typ
		}
		return types.NewPointer(instElem)
	case *types.Tuple:
		return t.instantiateTypeTuple(ta, typ)
	case *types.Signature:
		params := t.instantiateTypeTuple(ta, typ.Params())
		results := t.instantiateTypeTuple(ta, typ.Results())
		if params == typ.Params() && results == typ.Results() {
			return typ
		}
		r := types.NewSignature(typ.Recv(), params, results, typ.Variadic())
		if tparams := typ.TParams(); tparams != nil {
			r.SetTParams(tparams)
		}
		return r
	case *types.Interface:
		nm := typ.NumExplicitMethods()
		methods := make([]*types.Func, nm)
		changed := false
		for i := 0; i < nm; i++ {
			m := typ.ExplicitMethod(i)
			instSig := t.instantiateType(ta, m.Type()).(*types.Signature)
			if instSig != m.Type() {
				m = types.NewFunc(m.Pos(), m.Pkg(), m.Name(), instSig)
				changed = true
			}
			methods[i] = m
		}
		ne := typ.NumEmbeddeds()
		embeddeds := make([]types.Type, ne)
		for i := 0; i < ne; i++ {
			e := typ.EmbeddedType(i)
			instE := t.instantiateType(ta, e)
			if e != instE {
				changed = true
			}
			embeddeds[i] = instE
		}
		if !changed {
			return typ
		}
		return types.NewInterfaceType(methods, embeddeds)
	case *types.Map:
		key := t.instantiateType(ta, typ.Key())
		elem := t.instantiateType(ta, typ.Elem())
		if key == typ.Key() && elem == typ.Elem() {
			return typ
		}
		return types.NewMap(key, elem)
	case *types.Chan:
		elem := t.instantiateType(ta, typ.Elem())
		if elem == typ.Elem() {
			return typ
		}
		return types.NewChan(typ.Dir(), elem)
	case *types.Named:
		targs := typ.TArgs()
		targsChanged := false
		if len(targs) > 0 {
			newTargs := make([]types.Type, 0, len(targs))
			for _, targ := range targs {
				newTarg := t.instantiateType(ta, targ)
				if newTarg != targ {
					targsChanged = true
				}
				newTargs = append(newTargs, newTarg)
			}
			targs = newTargs
		}
		if targsChanged {
			return t.updateTArgs(typ, targs)
		}
		return typ
	case *types.TypeParam:
		if instType, ok := ta.typ(typ); ok {
			return instType
		}
		return typ
	default:
		panic(fmt.Sprintf("unimplemented Type %T", typ))
	}
}

// setTargs returns a new named type with updated type arguments.
func (t *translator) updateTArgs(typ *types.Named, targs []types.Type) *types.Named {
	nm := typ.NumMethods()
	methods := make([]*types.Func, 0, nm)
	for i := 0; i < nm; i++ {
		methods = append(methods, typ.Method(i))
	}
	obj := typ.Obj()
	obj = types.NewTypeName(obj.Pos(), obj.Pkg(), obj.Name(), nil)
	nt := types.NewNamed(obj, typ.Underlying(), methods)
	nt.SetTArgs(targs)
	return nt
}

// instantiateTypeTuple instantiates a types.Tuple.
func (t *translator) instantiateTypeTuple(ta *typeArgs, tuple *types.Tuple) *types.Tuple {
	if tuple == nil {
		return nil
	}
	l := tuple.Len()
	instTypes := make([]types.Type, l)
	changed := false
	for i := 0; i < l; i++ {
		typ := tuple.At(i).Type()
		instType := t.instantiateType(ta, typ)
		if typ != instType {
			changed = true
		}
		instTypes[i] = instType
	}
	if !changed {
		return tuple
	}
	vars := make([]*types.Var, l)
	for i := 0; i < l; i++ {
		v := tuple.At(i)
		vars[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), instTypes[i])
	}
	return types.NewTuple(vars...)
}

// addTypePackages adds all packages mentioned in typ to t.typePackages.
func (t *translator) addTypePackages(typ types.Type) {
	switch typ := typ.(type) {
	case *types.Basic:
	case *types.Array:
		t.addTypePackages(typ.Elem())
	case *types.Slice:
		t.addTypePackages(typ.Elem())
	case *types.Struct:
		n := typ.NumFields()
		for i := 0; i < n; i++ {
			t.addTypePackages(typ.Field(i).Type())
		}
	case *types.Pointer:
		t.addTypePackages(typ.Elem())
	case *types.Tuple:
		n := typ.Len()
		for i := 0; i < n; i++ {
			t.addTypePackages(typ.At(i).Type())
		}
	case *types.Signature:
		// We'll have seen typ.Recv elsewhere.
		t.addTypePackages(typ.Params())
		t.addTypePackages(typ.Results())
	case *types.Interface:
		nm := typ.NumExplicitMethods()
		for i := 0; i < nm; i++ {
			t.addTypePackages(typ.ExplicitMethod(i).Type())
		}
		ne := typ.NumEmbeddeds()
		for i := 0; i < ne; i++ {
			t.addTypePackages(typ.EmbeddedType(i))
		}
	case *types.Map:
		t.addTypePackages(typ.Key())
		t.addTypePackages(typ.Elem())
	case *types.Chan:
		t.addTypePackages(typ.Elem())
	case *types.Named:
		// This is the point of this whole method.
		if typ.Obj().Pkg() != nil {
			t.typePackages[typ.Obj().Pkg()] = true
		}
	case *types.TypeParam:
	default:
		panic(fmt.Sprintf("unimplemented Type %T", typ))
	}
}

// withoutTags returns a type with no struct tags. If typ has no
// struct tags anyhow, this just returns typ.
func (t *translator) withoutTags(typ types.Type) types.Type {
	switch typ := typ.(type) {
	case *types.Basic:
		return typ
	case *types.Array:
		elem := typ.Elem()
		elemNoTags := t.withoutTags(elem)
		if elem == elemNoTags {
			return typ
		}
		return types.NewArray(elemNoTags, typ.Len())
	case *types.Slice:
		elem := typ.Elem()
		elemNoTags := t.withoutTags(elem)
		if elem == elemNoTags {
			return typ
		}
		return types.NewSlice(elemNoTags)
	case *types.Struct:
		n := typ.NumFields()
		fields := make([]*types.Var, n)
		changed := false
		hasTag := false
		for i := 0; i < n; i++ {
			v := typ.Field(i)
			typeNoTags := t.withoutTags(v.Type())
			if v.Type() != typeNoTags {
				changed = true
			}
			fields[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), typeNoTags)
			if typ.Tag(i) != "" {
				hasTag = true
			}
		}
		if !changed && !hasTag {
			return typ
		}
		return types.NewStruct(fields, nil)
	case *types.Pointer:
		elem := typ.Elem()
		elemNoTags := t.withoutTags(elem)
		if elem == elemNoTags {
			return typ
		}
		return types.NewPointer(elemNoTags)
	case *types.Tuple:
		return t.tupleWithoutTags(typ)
	case *types.Signature:
		params := t.tupleWithoutTags(typ.Params())
		results := t.tupleWithoutTags(typ.Results())
		if params == typ.Params() && results == typ.Results() {
			return typ
		}
		r := types.NewSignature(typ.Recv(), params, results, typ.Variadic())
		if tparams := typ.TParams(); tparams != nil {
			r.SetTParams(tparams)
		}
		return r
	case *types.Interface:
		nm := typ.NumExplicitMethods()
		methods := make([]*types.Func, nm)
		changed := false
		for i := 0; i < nm; i++ {
			m := typ.ExplicitMethod(i)
			sigNoTags := t.withoutTags(m.Type()).(*types.Signature)
			if sigNoTags != m.Type() {
				m = types.NewFunc(m.Pos(), m.Pkg(), m.Name(), sigNoTags)
				changed = true
			}
			methods[i] = m
		}
		ne := typ.NumEmbeddeds()
		embeddeds := make([]types.Type, ne)
		for i := 0; i < ne; i++ {
			e := typ.EmbeddedType(i)
			eNoTags := t.withoutTags(e)
			if e != eNoTags {
				changed = true
			}
			embeddeds[i] = eNoTags
		}
		if !changed {
			return typ
		}
		return types.NewInterfaceType(methods, embeddeds)
	case *types.Map:
		key := t.withoutTags(typ.Key())
		elem := t.withoutTags(typ.Elem())
		if key == typ.Key() && elem == typ.Elem() {
			return typ
		}
		return types.NewMap(key, elem)
	case *types.Chan:
		elem := t.withoutTags(typ.Elem())
		if elem == typ.Elem() {
			return typ
		}
		return types.NewChan(typ.Dir(), elem)
	case *types.Named:
		targs := typ.TArgs()
		targsChanged := false
		if len(targs) > 0 {
			newTargs := make([]types.Type, 0, len(targs))
			for _, targ := range targs {
				newTarg := t.withoutTags(targ)
				if newTarg != targ {
					targsChanged = true
				}
				newTargs = append(newTargs, newTarg)
			}
			targs = newTargs
		}
		if targsChanged {
			return t.updateTArgs(typ, targs)
		}
		return typ
	case *types.TypeParam:
		return typ
	default:
		panic(fmt.Sprintf("unimplemented Type %T", typ))
	}
}

// tupleWithoutTags returns a tuple with all struct tag removed.
func (t *translator) tupleWithoutTags(tuple *types.Tuple) *types.Tuple {
	if tuple == nil {
		return nil
	}
	l := tuple.Len()
	typesNoTags := make([]types.Type, l)
	changed := false
	for i := 0; i < l; i++ {
		typ := tuple.At(i).Type()
		typNoTags := t.withoutTags(typ)
		if typ != typNoTags {
			changed = true
		}
		typesNoTags[i] = typNoTags
	}
	if !changed {
		return tuple
	}
	vars := make([]*types.Var, l)
	for i := 0; i < l; i++ {
		v := tuple.At(i)
		vars[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), typesNoTags[i])
	}
	return types.NewTuple(vars...)
}

// typeToAST converts a types.Type to an ast.Expr.
func (t *translator) typeToAST(typ types.Type) ast.Expr {
	var r ast.Expr
	switch typ := typ.(type) {
	case *types.Basic:
		r = ast.NewIdent(typ.Name())
	case *types.Array:
		r = &ast.ArrayType{
			Len: &ast.BasicLit{
				Kind:  token.INT,
				Value: strconv.FormatInt(typ.Len(), 10),
			},
			Elt: t.typeToAST(typ.Elem()),
		}
	case *types.Slice:
		r = &ast.ArrayType{
			Elt: t.typeToAST(typ.Elem()),
		}
	case *types.Struct:
		var fields []*ast.Field
		n := typ.NumFields()
		for i := 0; i < n; i++ {
			tf := typ.Field(i)
			var names []*ast.Ident
			if !tf.Embedded() {
				names = []*ast.Ident{
					ast.NewIdent(tf.Name()),
				}
			}
			var atag *ast.BasicLit
			if tag := typ.Tag(i); tag != "" {
				atag = &ast.BasicLit{
					Kind:  token.STRING,
					Value: strconv.Quote(tag),
				}
			}
			af := &ast.Field{
				Names: names,
				Type:  t.typeToAST(tf.Type()),
				Tag:   atag,
			}
			fields = append(fields, af)
		}
		r = &ast.StructType{
			Fields: &ast.FieldList{
				List: fields,
			},
		}
	case *types.Pointer:
		r = &ast.StarExpr{
			X: t.typeToAST(typ.Elem()),
		}
	case *types.Tuple:
		// We should only see this in a types.Signature,
		// where we handle it specially, since there is
		// no ast.Expr that can represent this.
		panic("unexpected types.Tuple")
	case *types.Signature:
		if len(typ.TParams()) > 0 {
			// We should only see type parameters for
			// a package scope function declaration.
			panic("unexpected type parameters")
		}
		r = &ast.FuncType{
			Params:  t.tupleToFieldList(typ.Params()),
			Results: t.tupleToFieldList(typ.Params()),
		}
	case *types.Interface:
		var methods []*ast.Field
		nm := typ.NumExplicitMethods()
		for i := 0; i < nm; i++ {
			m := typ.ExplicitMethod(i)
			f := &ast.Field{
				Names: []*ast.Ident{
					ast.NewIdent(m.Name()),
				},
				Type: t.typeToAST(m.Type()),
			}
			methods = append(methods, f)
		}
		ne := typ.NumEmbeddeds()
		for i := 0; i < ne; i++ {
			e := typ.EmbeddedType(i)
			f := &ast.Field{
				Type: t.typeToAST(e),
			}
			methods = append(methods, f)
		}
		r = &ast.InterfaceType{
			Methods: &ast.FieldList{
				List: methods,
			},
		}
	case *types.Map:
		r = &ast.MapType{
			Key:   t.typeToAST(typ.Key()),
			Value: t.typeToAST(typ.Elem()),
		}
	case *types.Chan:
		var dir ast.ChanDir
		switch typ.Dir() {
		case types.SendRecv:
			dir = ast.SEND | ast.RECV
		case types.SendOnly:
			dir = ast.SEND
		case types.RecvOnly:
			dir = ast.RECV
		default:
			panic("unsupported channel direction")
		}
		r = &ast.ChanType{
			Dir:   dir,
			Value: t.typeToAST(typ.Elem()),
		}
	case *types.Named:
		if len(typ.TArgs()) > 0 {
			_, id := t.lookupInstantiatedType(typ)
			r = id
		} else {
			var sb strings.Builder
			tn := typ.Obj()
			if tn.Pkg() != nil && tn.Pkg() != t.tpkg {
				sb.WriteString(tn.Pkg().Name())
				sb.WriteByte('.')
			}
			sb.WriteString(tn.Name())
			r = ast.NewIdent(sb.String())
		}
	case *types.TypeParam:
		// This should have been instantiated already.
		panic("unexpected type parameter")
	default:
		panic(fmt.Sprintf("unimplemented Type %T", typ))
	}

	t.setType(r, typ)
	return r
}

// tupleToFieldList converts a tupes.Tuple to a ast.FieldList.
func (t *translator) tupleToFieldList(tuple *types.Tuple) *ast.FieldList {
	var fields []*ast.Field
	n := tuple.Len()
	for i := 0; i < n; i++ {
		v := tuple.At(i)
		var names []*ast.Ident
		if v.Name() != "" {
			names = []*ast.Ident{
				ast.NewIdent(v.Name()),
			}
		}
		f := &ast.Field{
			Names: names,
			Type:  t.typeToAST(v.Type()),
		}
		fields = append(fields, f)
	}
	return &ast.FieldList{
		List: fields,
	}
}