// Copyright 2015 The go-python 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 bind

import (
	"fmt"
	"go/ast"
	"go/doc"
	"go/types"
	"path/filepath"
	"reflect"
	"strconv"
	"strings"
)

// Package ties types.Package and ast.Package together.
// Package also collects information about specific types (structs, ifaces, etc)
type Package struct {
	pkg *types.Package
	n   int // number of entities to wrap
	sz  types.Sizes
	doc *doc.Package

	syms      *symtab // note: this is now *always* = symbols.current
	objs      map[string]Object
	consts    []*Const
	enums     []*Enum
	vars      []*Var
	structs   []*Struct
	ifaces    []*Interface
	slices    []*Slice
	maps      []*Map
	funcs     []*Func
	pyimports map[string]string // extra python imports from incidental python wrapper includes
	// calls   []*Signature // TODO: could optimize calls back into python to gen once
}

// Packages accumulates all the packages processed
var Packages []*Package

// ResetPackages resets any accumulated packages -- needed when doing tests
func ResetPackages() {
	universeMutex.Lock()
	defer universeMutex.Unlock()
	Packages = nil
	makeGoPackage()
	current = newSymtab(nil, universe)
}

// NewPackage creates a new Package, tying types.Package and ast.Package together.
func NewPackage(pkg *types.Package, doc *doc.Package) (*Package, error) {
	// protection for parallel tests
	universeMutex.Lock()
	defer universeMutex.Unlock()
	fmt.Printf("\n--- Processing package: %v ---\n", pkg.Path())
	sz := int64(reflect.TypeOf(int(0)).Size())
	p := &Package{
		pkg:       pkg,
		n:         0,
		sz:        &types.StdSizes{WordSize: sz, MaxAlign: sz},
		doc:       doc,
		syms:      current,
		objs:      map[string]Object{},
		pyimports: map[string]string{},
	}
	err := p.process()
	if err != nil {
		return nil, err
	}

	Packages = append(Packages, p)
	return p, err
}

// Name returns the package name.
func (p *Package) Name() string {
	return p.pkg.Name()
}

// ImportPath returns the package import path.
func (p *Package) ImportPath() string {
	return p.doc.ImportPath
}

// add given path to python imports -- these packages were referenced
func (p *Package) AddPyImport(ipath string, extra bool) {
	mypath := p.pkg.Path()
	if mypath == "go" {
		return
	}
	if ipath == mypath {
		return
	}
	if p.pyimports == nil {
		p.pyimports = make(map[string]string)
	}
	if _, has := p.pyimports[ipath]; has {
		return
	}
	nm := filepath.Base(ipath)
	p.pyimports[ipath] = nm
	// if extra {
	// 	fmt.Printf("%v added py import: %v = %v\n", mypath, ipath, nm)
	// }
}

// getDoc returns the doc string associated with types.Object
// parent is the name of the containing scope ("" for global scope)
func (p *Package) getDoc(parent string, o types.Object) string {
	n := o.Name()
	switch tp := o.(type) {
	case *types.Const:
		for _, c := range p.doc.Consts {
			for _, cn := range c.Names {
				if n == cn {
					return c.Doc
				}
			}
		}

	case *types.Var:
		if tp.IsField() && parent != "" {
			// Find the package-scoped struct
			for _, typ := range p.doc.Types {
				_ = typ
				if typ.Name != parent {
					continue
				}
				// Name matches package-scoped struct.
				// Make sure it is a struct type.
				for _, spec := range typ.Decl.Specs {
					typSpec, ok := spec.(*ast.TypeSpec)
					if !ok {
						continue
					}
					structSpec, ok := typSpec.Type.(*ast.StructType)
					if !ok {
						continue
					}
					// We have the package-scoped struct matching the parent name.
					// Find the matching field.
					for _, field := range structSpec.Fields.List {
						for _, fieldName := range field.Names {
							if fieldName.Name == tp.Name() {
								return field.Doc.Text()
							}
						}
					}
				}

			}
		}
		// Otherwise just check the captured vars
		for _, v := range p.doc.Vars {
			for _, vn := range v.Names {
				if n == vn {
					return v.Doc
				}
			}
		}

	case *types.Func:
		sig := o.Type().(*types.Signature)
		_, _, _, err := isPyCompatFunc(sig)
		if err != nil {
			return ""
		}

		doc := func() string {
			if o.Parent() == nil || (o.Parent() != nil && parent != "") {
				for _, typ := range p.doc.Types {
					if typ.Name != parent {
						continue
					}
					if o.Parent() == nil {
						for _, m := range typ.Methods {
							if m.Name == n {
								return m.Doc
							}
						}
					} else {
						for _, m := range typ.Funcs {
							if m.Name == n {
								return m.Doc
							}
						}
					}
				}
			} else {
				for _, f := range p.doc.Funcs {
					if n == f.Name {
						return f.Doc
					}
				}
			}
			return ""
		}()

		// if a function returns a type defined in the package,
		// it is organized under that type
		if doc == "" && sig.Results().Len() == 1 {
			ret := sig.Results().At(0).Type()
			if ntyp, ok := ret.(*types.Named); ok {
				tn := ntyp.Obj().Name()
				doc = func() string {
					for _, typ := range p.doc.Types {
						if typ.Name != tn {
							continue
						}
						for _, m := range typ.Funcs {
							if m.Name == n {
								return m.Doc
							}
						}
					}
					return ""
				}()
			}
		}

		parseFn := func(tup *types.Tuple) []string {
			params := []string{}
			if tup == nil {
				return params
			}
			for i := 0; i < tup.Len(); i++ {
				paramVar := tup.At(i)
				paramSig := p.syms.symtype(paramVar.Type())
				if paramSig == nil {
					continue
				}
				paramType := paramSig.pysig
				if paramVar.Name() != "" {
					paramType = fmt.Sprintf("%s %s", paramType, paramVar.Name())
				}
				params = append(params, paramType)
			}
			return params
		}

		params := parseFn(sig.Params())
		results := parseFn(sig.Results())

		paramString := strings.Join(params, ", ")
		resultString := strings.Join(results, ", ")

		//FIXME(sbinet): add receiver for methods?
		docSig := fmt.Sprintf("%s(%s) %s", o.Name(), paramString, resultString)

		if doc != "" {
			doc = fmt.Sprintf("%s\n\n%s", docSig, doc)
		} else {
			doc = docSig
		}
		return doc

	case *types.TypeName:
		for _, t := range p.doc.Types {
			if n == t.Name {
				return t.Doc
			}
		}

	default:
		// TODO(sbinet)
		panic(fmt.Errorf("not yet supported: %v (%T)", o, o))
	}

	return ""
}

// process collects informations about a go package.
func (p *Package) process() error {
	var err error

	p.syms.pkg = p.pkg
	p.syms.addImport(p.pkg)

	funcs := make(map[string]*Func)
	structs := make(map[string]*Struct)
	ifaces := make(map[string]*Interface)
	slices := make(map[string]*Slice)
	maps := make(map[string]*Map)

	scope := p.pkg.Scope()
	for _, name := range scope.Names() {
		obj := scope.Lookup(name)
		if !obj.Exported() {
			continue
		}

		p.n++
		p.syms.addSymbol(obj)
	}

	for _, name := range scope.Names() {
		obj := scope.Lookup(name)
		if !obj.Exported() {
			continue
		}

		switch obj := obj.(type) {
		case *types.Const:
			p.addConst(obj)

		case *types.Var:
			p.addVar(obj)

		case *types.Func:
			fv, err := newFuncFrom(p, "", obj, obj.Type().(*types.Signature))
			if err != nil {
				continue
			}
			funcs[name] = fv

		case *types.TypeName:
			named := obj.Type().(*types.Named)
			switch typ := named.Underlying().(type) {
			case *types.Struct:
				sv, err := newStruct(p, obj)
				if err != nil {
					fmt.Println(err)
					continue
				}
				structs[name] = sv

			case *types.Basic:
				// ok. handled by p.syms-types

			case *types.Array:
				// ok. handled by p.syms-types

			case *types.Interface:
				iv, err := newInterface(p, obj)
				if err != nil {
					fmt.Println(err)
					continue
				}
				ifaces[name] = iv

			case *types.Signature:
				// ok. handled by p.syms-types

			case *types.Slice:
				sl, err := newSlice(p, obj)
				if err != nil {
					fmt.Println(err)
					continue
				}
				slices[name] = sl

			case *types.Map:
				mp, err := newMap(p, obj)
				if err != nil {
					fmt.Println(err)
					continue
				}
				maps[name] = mp

			case *types.Chan:
				continue // don't handle

			default:
				panic(fmt.Errorf("not yet supported: %v (%T)", typ, obj))
			}

		default:
			panic(fmt.Errorf("not yet supported: %v (%T)", obj, obj))
		}

	}

	// attach docstrings to methods
	for _, n := range p.syms.names() {
		sym := p.syms.syms[n]
		if !sym.isNamed() {
			continue
		}
		switch typ := sym.GoType().(type) {
		case *types.Named:
			for i := 0; i < typ.NumMethods(); i++ {
				m := typ.Method(i)
				if !m.Exported() {
					continue
				}
				doc := p.getDoc(sym.goname, m)
				mname := types.ObjectString(m, nil)
				msym := p.syms.sym(mname)
				if msym == nil {
					continue
				}
				msym.doc = doc
			}
		}
	}

	// remove ctors from funcs.
	// add methods.
	for sname, s := range structs {
		styp := s.GoType()
		ptyp := types.NewPointer(styp)
		p.syms.addType(nil, ptyp)
		for name, fct := range funcs {
			if !fct.Obj().Exported() {
				continue
			}
			ret := fct.Return()
			if ret == nil {
				continue
			}
			retptr, retIsPtr := ret.(*types.Pointer)

			if ret == styp || (retIsPtr && retptr.Elem() == styp) {
				delete(funcs, name)
				fct.doc = p.getDoc(sname, scope.Lookup(name))
				fct.ctor = true
				s.ctors = append(s.ctors, fct)
				structs[sname] = s
				continue
			}
		}

		ntyp, ok := styp.(*types.Named)
		if !ok {
			continue
		}

		nmeth := ntyp.NumMethods()
		for mi := 0; mi < nmeth; mi++ {
			meth := ntyp.Method(mi)
			if !meth.Exported() {
				continue
			}
			msig := meth.Type().(*types.Signature)
			m, err := newFuncFrom(p, sname, meth, msig)
			if err != nil {
				continue
			}
			s.meths = append(s.meths, m)
			if isStringer(meth) {
				s.prots |= ProtoStringer
			}
		}
		p.addStruct(s)
	}

	for iname, ifc := range ifaces {
		mset := types.NewMethodSet(ifc.GoType())
		for i := 0; i < mset.Len(); i++ {
			meth := mset.At(i)
			if !meth.Obj().Exported() {
				continue
			}
			m, err := newFuncFrom(p, iname, meth.Obj(), meth.Type().(*types.Signature))
			if err != nil {
				continue
			}
			ifc.meths = append(ifc.meths, m)
		}
		p.addInterface(ifc)
	}

	for sname, s := range slices {
		styp := s.GoType()
		ntyp, ok := styp.(*types.Named)
		if !ok {
			continue
		}
		nmeth := ntyp.NumMethods()
		for mi := 0; mi < nmeth; mi++ {
			meth := ntyp.Method(mi)
			if !meth.Exported() {
				continue
			}
			msig := meth.Type().(*types.Signature)
			m, err := newFuncFrom(p, sname, meth, msig)
			if err != nil {
				continue
			}
			s.meths = append(s.meths, m)
			if isStringer(meth) {
				s.prots |= ProtoStringer
			}
		}
		p.addSlice(s)
	}

	for sname, s := range maps {
		styp := s.GoType()
		ntyp, ok := styp.(*types.Named)
		if !ok {
			continue
		}
		nmeth := ntyp.NumMethods()
		for mi := 0; mi < nmeth; mi++ {
			meth := ntyp.Method(mi)
			if !meth.Exported() {
				continue
			}
			msig := meth.Type().(*types.Signature)
			m, err := newFuncFrom(p, sname, meth, msig)
			if err != nil {
				continue
			}
			s.meths = append(s.meths, m)
			if isStringer(meth) {
				s.prots |= ProtoStringer
			}
		}
		p.addMap(s)
	}

	for _, fct := range funcs {
		p.addFunc(fct)
	}

	return err
}

func (p *Package) findEnum(ntyp *types.Named) *Enum {
	for _, enm := range p.enums {
		if enm.typ == ntyp {
			return enm
		}
	}
	return nil
}

func (p *Package) addConst(obj *types.Const) {
	if ntyp, ok := obj.Type().(*types.Named); ok {
		enm := p.findEnum(ntyp)
		if enm != nil {
			enm.AddConst(p, obj)
			return
		} else {
			val := obj.Val().String()
			_, err := strconv.Atoi(val)
			if err == nil {
				enm, err := newEnum(p, obj)
				if err == nil {
					p.enums = append(p.enums, enm)
					return
				}
			}
		}
	}

	nc, err := newConst(p, obj)
	if err == nil {
		p.consts = append(p.consts, nc)
	}
}

func (p *Package) addVar(obj *types.Var) {
	nv, err := newVarFrom(p, obj)
	if err == nil {
		p.vars = append(p.vars, nv)
	}
}

func (p *Package) addStruct(s *Struct) {
	p.structs = append(p.structs, s)
	s.idx = len(p.structs) - 1
	p.objs[s.GoName()] = s
}

func (p *Package) addInterface(ifc *Interface) {
	p.ifaces = append(p.ifaces, ifc)
	p.objs[ifc.GoName()] = ifc
}

func (p *Package) addSlice(slc *Slice) {
	p.slices = append(p.slices, slc)
	p.objs[slc.GoName()] = slc
}

func (p *Package) addMap(mp *Map) {
	p.maps = append(p.maps, mp)
	p.objs[mp.GoName()] = mp
}

func (p *Package) addFunc(f *Func) {
	p.funcs = append(p.funcs, f)
	p.objs[f.GoName()] = f
}

// Lookup returns the bind.Object corresponding to a types.Object
func (p *Package) Lookup(o types.Object) (Object, bool) {
	obj, ok := p.objs[o.Name()]
	return obj, ok
}

func (p *Package) sortStructEmbeds() {
	for {
		nswap := 0
		for _, s := range p.structs {
			emb := s.FirstEmbed()
			if emb == nil {
				continue
			}
			emss, ok := p.objs[emb.goname]
			if !ok {
				continue
			}
			if ems, isstru := emss.(*Struct); isstru {
				if ems.idx > s.idx {
					nswap++
					p.structs[s.idx], p.structs[ems.idx] = p.structs[ems.idx], p.structs[s.idx]
					s.idx, ems.idx = ems.idx, s.idx
				}
			}
		}
		if nswap == 0 {
			break
		}
		// fmt.Printf("%s nswap: %v\n", p.pkg.Path(), nswap)
	}
}