package main

import (
	"bufio"
	"fmt"
	"go/ast"
	"go/constant"
	"go/parser"
	"go/token"
	"go/types"
	"io/fs"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	"golang.org/x/tools/go/packages"

	"github.com/johnandersen777/socialweb-computer-kcp/internal/apigen"
)

const bootstrapFile = "deploy/bus-bootstrap-callers.txt"

var annotationConventions = map[string]string{
	"kcp.io/path":                       "kcp writes the logical cluster path; read to resolve a cluster name to its workspace path",
	"kcp.io/cluster":                    "kcp writes the logical cluster of every object; read to address the object's workspace",
	"experimental.tenancy.kcp.io/owner": "kcp admission writes the workspace owner; read to keep it when re-applying a Workspace",
	"kubernetes.io/config.mirror":       "the kubelet marks static mirror pods; a drain skips them like kubectl does",
	"objectset.rio.cattle.io/owner-gvk": "k3s marks the objects its addon controller owns; read to leave k3s-owned objects alone",
}

func (c *checker) eachFile(fn func(p *packages.Package, f *ast.File)) {
	for _, p := range c.sortedLocal() {
		for _, f := range p.Syntax {
			fn(p, f)
		}
	}
}

func (c *checker) systemCallers() {
	allowed := map[string]bool{}
	if f, err := os.Open(filepath.Join(c.root, bootstrapFile)); err != nil {
		c.fail("system-caller", bootstrapFile, "%v", err)
	} else {
		scanner := bufio.NewScanner(f)
		header := true
		for scanner.Scan() {
			line := strings.TrimSpace(scanner.Text())
			if line == "" {
				continue
			}
			if header {
				header = false
				continue
			}
			cols := strings.Split(line, "\t")
			if len(cols) >= 2 {
				allowed[strings.TrimSpace(cols[0])+"\t"+strings.TrimSpace(cols[1])] = true
			}
		}
		f.Close()
	}
	bus := c.module + "/internal/bus"
	c.eachFile(func(p *packages.Package, f *ast.File) {
		if p.PkgPath == bus {
			return
		}
		ast.Inspect(f, func(n ast.Node) bool {
			switch x := n.(type) {
			case *ast.CallExpr:
				fn := calledFunc(p.TypesInfo, x.Fun)
				if fn == nil || fn.Pkg() == nil || fn.Pkg().Path() != bus || fn.Name() != "WithSystemCaller" {
					return true
				}
				name := ""
				if len(x.Args) == 2 {
					if tv, ok := p.TypesInfo.Types[x.Args[1]]; ok && tv.Value != nil && tv.Value.Kind() == constant.String {
						name = strings.TrimSpace(constant.StringVal(tv.Value))
					}
				}
				switch {
				case name == "":
					c.fail("system-caller", c.pos(x.Pos()), "bus.WithSystemCaller takes a constant caller name listed in %s", bootstrapFile)
				case !allowed[name+"\t"+c.rel(p.PkgPath)]:
					c.fail("system-caller", c.pos(x.Pos()), "System caller %q in %s is not listed in %s", name, c.rel(p.PkgPath), bootstrapFile)
				}
			case *ast.Ident:
				if obj, ok := p.TypesInfo.Uses[x].(*types.Const); ok && obj.Pkg() != nil && obj.Pkg().Path() == bus && obj.Name() == "SystemKind" {
					c.fail("system-caller", c.pos(x.Pos()), "bus.SystemKind outside internal/bus; a System caller is made only by bus.WithSystemCaller from a listed caller")
				}
			case *ast.KeyValueExpr:
				if k, ok := x.Key.(*ast.Ident); ok && k.Name == "Kind" {
					if tv, ok := p.TypesInfo.Types[x.Value]; ok && tv.Value != nil && tv.Value.Kind() == constant.String && strings.EqualFold(constant.StringVal(tv.Value), "System") {
						c.fail("system-caller", c.pos(x.Pos()), "a caller ref of kind System outside internal/bus; use bus.WithSystemCaller from a listed caller")
					}
				}
			}
			return true
		})
	})
}

func calledFunc(info *types.Info, fun ast.Expr) *types.Func {
	switch f := fun.(type) {
	case *ast.Ident:
		fn, _ := info.Uses[f].(*types.Func)
		return fn
	case *ast.SelectorExpr:
		fn, _ := info.Uses[f.Sel].(*types.Func)
		return fn
	case *ast.IndexExpr:
		return calledFunc(info, f.X)
	case *ast.IndexListExpr:
		return calledFunc(info, f.X)
	}
	return nil
}

var dynamicImports = []string{"k8s.io/client-go/dynamic", "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"}

func (c *checker) dynamicClients() {
	for _, top := range []string{"api", "cmd", "hack", "internal", "test"} {
		_ = filepath.WalkDir(filepath.Join(c.root, top), func(p string, d fs.DirEntry, err error) error {
			if err != nil || d.IsDir() || !strings.HasSuffix(p, ".go") {
				return nil
			}
			rel, _ := filepath.Rel(c.root, p)
			dir := filepath.ToSlash(filepath.Dir(rel))
			if under(dir, "internal/controllers/runtime", "internal/apigen") {
				return nil
			}
			fset := token.NewFileSet()
			f, err := parser.ParseFile(fset, p, nil, parser.ImportsOnly)
			if err != nil {
				return nil
			}
			for _, imp := range f.Imports {
				path, _ := strconv.Unquote(imp.Path.Value)
				if under(path, dynamicImports...) {
					c.fail("dynamic", fmt.Sprintf("%s:%d", rel, fset.Position(imp.Pos()).Line),
						"imports %s; only internal/controllers/runtime and internal/apigen use a dynamic client or unstructured objects (use kube.Resource with a typed object)", path)
				}
			}
			return nil
		})
	}
}

func isNamed(t types.Type, pkg, name string) bool {
	n, ok := types.Unalias(t).(*types.Named)
	return ok && n.Obj().Pkg() != nil && n.Obj().Pkg().Path() == pkg && n.Obj().Name() == name
}

const schemaPkg = "k8s.io/apimachinery/pkg/runtime/schema"

func (c *checker) gvrLiterals() {
	c.eachFile(func(p *packages.Package, f *ast.File) {
		if under(c.rel(p.PkgPath), "api") {
			return
		}
		ast.Inspect(f, func(n ast.Node) bool {
			switch x := n.(type) {
			case *ast.CompositeLit:
				if len(x.Elts) > 0 && isNamed(p.TypesInfo.TypeOf(x), schemaPkg, "GroupVersionResource") {
					c.fail("gvr", c.pos(x.Pos()), "a schema.GroupVersionResource literal outside api/; use the generated <Kind>GVR var or api/kcpgvr")
				}
			case *ast.CallExpr:
				sel, ok := x.Fun.(*ast.SelectorExpr)
				if !ok || sel.Sel.Name != "WithResource" || len(x.Args) != 1 {
					return true
				}
				if fn := calledFunc(p.TypesInfo, x.Fun); fn == nil || fn.Pkg() == nil || fn.Pkg().Path() != schemaPkg {
					return true
				}
				if tv, ok := p.TypesInfo.Types[x.Args[0]]; ok && tv.Value != nil {
					c.fail("gvr", c.pos(x.Pos()), "a GroupVersionResource built from a constant resource outside api/; use the generated <Kind>GVR var or api/kcpgvr")
				}
			}
			return true
		})
	})
}

func annotationSource(info *types.Info, e ast.Expr, marked map[types.Object]bool) bool {
	e = ast.Unparen(e)
	if t := info.TypeOf(e); t == nil || !isStringMap(t) {
		return false
	}
	switch x := e.(type) {
	case *ast.SelectorExpr:
		if s, ok := info.Selections[x]; ok && s.Kind() == types.FieldVal && s.Obj().Name() == "Annotations" {
			return true
		}
	case *ast.CallExpr:
		if fn := calledFunc(info, x.Fun); fn != nil && fn.Name() == "GetAnnotations" {
			return true
		}
	case *ast.Ident:
		if obj := info.Uses[x]; obj != nil && marked[obj] {
			return true
		}
	}
	return false
}

func isStringMap(t types.Type) bool {
	m, ok := t.Underlying().(*types.Map)
	if !ok {
		return false
	}
	k, kok := m.Key().Underlying().(*types.Basic)
	v, vok := m.Elem().Underlying().(*types.Basic)
	return kok && vok && k.Kind() == types.String && v.Kind() == types.String
}

func (c *checker) annotationReads() {
	c.eachFile(func(p *packages.Package, f *ast.File) {
		info := p.TypesInfo
		marked := map[types.Object]bool{}
		writes := map[ast.Expr]bool{}
		mark := func(lhs []ast.Expr, rhs []ast.Expr) {
			if len(lhs) != len(rhs) {
				return
			}
			for i, l := range lhs {
				id, ok := l.(*ast.Ident)
				if !ok || !annotationSource(info, rhs[i], marked) {
					continue
				}
				if obj := info.Defs[id]; obj != nil {
					marked[obj] = true
				} else if obj := info.Uses[id]; obj != nil {
					marked[obj] = true
				}
			}
		}
		ast.Inspect(f, func(n ast.Node) bool {
			switch x := n.(type) {
			case *ast.AssignStmt:
				for _, l := range x.Lhs {
					writes[l] = true
				}
				mark(x.Lhs, x.Rhs)
			case *ast.ValueSpec:
				lhs := make([]ast.Expr, len(x.Names))
				for i, id := range x.Names {
					lhs[i] = id
				}
				mark(lhs, x.Values)
			}
			return true
		})
		report := func(at token.Pos, key ast.Expr) {
			value := types.ExprString(key)
			if tv, ok := info.Types[key]; ok && tv.Value != nil && tv.Value.Kind() == constant.String {
				value = constant.StringVal(tv.Value)
				if _, ok := annotationConventions[value]; ok {
					return
				}
			}
			c.fail("annotation", c.pos(at), "reads annotation %s as a signal; carry it in a spec or status field, a label or an ownerReference, or list a metadata convention in hack/archcheck", strconv.Quote(value))
		}
		ast.Inspect(f, func(n ast.Node) bool {
			switch x := n.(type) {
			case *ast.IndexExpr:
				if !writes[x] && annotationSource(info, x.X, marked) {
					report(x.Pos(), x.Index)
				}
			case *ast.CallExpr:
				fn := calledFunc(info, x.Fun)
				if fn == nil || fn.Pkg() == nil {
					return true
				}
				switch {
				case fn.Name() == "HasAnnotation" && fn.Pkg().Path() == "k8s.io/apimachinery/pkg/apis/meta/v1" && len(x.Args) == 2:
					report(x.Pos(), x.Args[1])
				case strings.HasPrefix(fn.Name(), "Nested") && fn.Pkg().Path() == "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured":
					for i := 1; i+2 < len(x.Args); i++ {
						a, b := constString(info, x.Args[i]), constString(info, x.Args[i+1])
						if a == "metadata" && b == "annotations" {
							report(x.Pos(), x.Args[i+2])
						}
					}
				}
			}
			return true
		})
	})
}

func constString(info *types.Info, e ast.Expr) string {
	if tv, ok := info.Types[e]; ok && tv.Value != nil && tv.Value.Kind() == constant.String {
		return constant.StringVal(tv.Value)
	}
	return ""
}

func (c *checker) endpoints() {
	if _, err := apigen.Generate(c.root); err != nil {
		for _, line := range strings.Split(err.Error(), "\n") {
			if line = strings.TrimSpace(line); line != "" {
				c.fail("endpoint", "api", "%s", line)
			}
		}
	}
}

func (c *checker) implPackage(path string) bool {
	if !c.isBackend(path) {
		return false
	}
	rel := c.rel(path)
	return !under(rel, hostLibraries...) && strings.Count(rel, "/") == 2
}

func (c *checker) assertions() {
	contract := c.module + "/internal/contract/"
	for _, p := range c.sortedLocal() {
		if !c.implPackage(p.PkgPath) {
			continue
		}
		found := false
		for _, f := range p.Syntax {
			for _, decl := range f.Decls {
				gd, ok := decl.(*ast.GenDecl)
				if !ok || gd.Tok != token.VAR {
					continue
				}
				for _, s := range gd.Specs {
					vs := s.(*ast.ValueSpec)
					if vs.Type == nil || len(vs.Names) != 1 || vs.Names[0].Name != "_" {
						continue
					}
					n, ok := types.Unalias(p.TypesInfo.TypeOf(vs.Type)).(*types.Named)
					if !ok || n.Obj().Pkg() == nil || !strings.HasPrefix(n.Obj().Pkg().Path(), contract) {
						continue
					}
					if _, ok := n.Underlying().(*types.Interface); ok {
						found = true
					}
				}
			}
		}
		if !found {
			c.fail("assertion", c.rel(p.PkgPath), "an impl package states its contract at compile time: var _ <contract>.<Interface> = (*Impl)(nil) against an internal/contract interface")
		}
	}
}