package manifests

import (
	"errors"
	"fmt"
	"io/fs"
	"reflect"
	"strings"

	"sigs.k8s.io/yaml"

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

const IndexPath = "sets.yaml"

var ErrMissingValue = errors.New("manifests: a value the template names is unset")

type Index struct {
	Sets      []Set       `json:"sets"`
	Unapplied []Unapplied `json:"unapplied"`
}

type Unapplied struct {
	Path string `json:"path"`
	Why  string `json:"why"`
}

type Set struct {
	Name    string  `json:"name"`
	Summary string  `json:"summary"`
	Values  string  `json:"values"`
	Scope   string  `json:"scope,omitempty"`
	Phases  []Phase `json:"phases"`
	Base    string  `json:"-"`

	BaseCluster string `json:"-"`
}

const ScopeKcp = "kcp"

const SharedWorkspaceSuffix = "-provider"

func Rebase(base, ws string) string {
	if base == "" || base == kcp.RootWorkspace {
		return ws
	}
	if ws == kcp.RootWorkspace {
		return base
	}
	rest, ok := strings.CutPrefix(ws, kcp.RootWorkspace+":")
	if !ok {
		return ws
	}
	first, _, _ := strings.Cut(rest, ":")
	if strings.HasSuffix(first, SharedWorkspaceSuffix) {
		return ws
	}
	return base + ":" + rest
}

func ServiceSuffix(ws string) string {
	return strings.TrimPrefix(kcp.ServiceFQDN("x", "default", ws, kcp.DefaultServiceDomain), "x.default.")
}

const (
	TLSServe = "serve"
	TLSTrust = "trust"
	TLSNone  = "none"
)

type Phase struct {
	Name      string `json:"name"`
	Workspace string `json:"workspace"`
	Files     []File `json:"files,omitempty"`
	Before    []Wait `json:"before,omitempty"`
	After     []Wait `json:"after,omitempty"`
}

type File struct {
	Path        string   `json:"path"`
	Each        string   `json:"each,omitempty"`
	As          string   `json:"as,omitempty"`
	Kinds       []string `json:"kinds,omitempty"`
	ExceptKinds []string `json:"exceptKinds,omitempty"`
}

type Wait struct {
	Kind       string   `json:"kind"`
	Name       string   `json:"name,omitempty"`
	Workspace  string   `json:"workspace,omitempty"`
	For        string   `json:"for"`
	Capture    *Capture `json:"capture,omitempty"`
	BestEffort bool     `json:"bestEffort,omitempty"`
}

type Capture struct {
	Into string `json:"into"`
	From string `json:"from"`
}

func Load() (Index, error) {
	b, err := fs.ReadFile(deploy.FS, IndexPath)
	if err != nil {
		return Index{}, fmt.Errorf("manifests: %w", err)
	}
	return Parse(b)
}

func Parse(b []byte) (Index, error) {
	var ix Index
	if err := yaml.UnmarshalStrict(b, &ix); err != nil {
		return Index{}, fmt.Errorf("manifests: %s: %w", IndexPath, err)
	}
	if err := ix.validate(); err != nil {
		return Index{}, fmt.Errorf("manifests: %s: %w", IndexPath, err)
	}
	return ix, nil
}

func (ix Index) Set(name string) (Set, bool) {
	for _, s := range ix.Sets {
		if s.Name == name {
			return s, true
		}
	}
	return Set{}, false
}

func (ix Index) Names() []string {
	out := make([]string, 0, len(ix.Sets))
	for _, s := range ix.Sets {
		out = append(out, s.Name)
	}
	return out
}

func (ix Index) validate() error {
	var problems []string
	add := func(format string, args ...any) { problems = append(problems, fmt.Sprintf(format, args...)) }
	sets := map[string]bool{}
	for _, s := range ix.Sets {
		if s.Name == "" || sets[s.Name] {
			add("set %q is unnamed or named twice", s.Name)
		}
		sets[s.Name] = true
		if s.Scope != "" && s.Scope != ScopeKcp {
			add("set %s: scope %q is not %s", s.Name, s.Scope, ScopeKcp)
		}
		vt, ok := valueTypes[s.Values]
		if !ok {
			add("set %s: values %q is no values type (%s)", s.Name, s.Values, strings.Join(ValueTypeNames(), ", "))
			continue
		}
		if len(s.Phases) == 0 {
			add("set %s has no phase", s.Name)
		}
		phases := map[string]bool{}
		for _, p := range s.Phases {
			where := "set " + s.Name + " phase " + p.Name
			if p.Name == "" || phases[p.Name] {
				add("%s: unnamed or named twice", where)
			}
			phases[p.Name] = true
			if p.Workspace == "" {
				add("%s names no workspace", where)
			}
			if len(p.Files) == 0 && len(p.Before) == 0 && len(p.After) == 0 {
				add("%s applies nothing and waits for nothing", where)
			}
			for _, f := range p.Files {
				if _, err := fs.Stat(deploy.FS, f.Path); err != nil {
					add("%s: %s is not in deploy.FS", where, f.Path)
				}
				if len(f.Kinds) > 0 && len(f.ExceptKinds) > 0 {
					add("%s: %s names both kinds and exceptKinds", where, f.Path)
				}
				if (f.Each == "") != (f.As == "") {
					add("%s: %s names each without as, or as without each", where, f.Path)
				}
				if f.Each != "" {
					if fld, ok := vt().Elem().FieldByName(f.Each); !ok || fld.Type.Kind() != reflect.Slice {
						add("%s: %s: each %s is no list field of %s", where, f.Path, f.Each, s.Values)
					}
				}
			}
			for _, w := range append(append([]Wait{}, p.Before...), p.After...) {
				if err := w.check(vt().Elem()); err != nil {
					add("%s: %v", where, err)
				}
			}
		}
	}
	for _, u := range ix.Unapplied {
		if _, err := fs.Stat(deploy.FS, u.Path); err != nil {
			add("unapplied %s is not in deploy.FS", u.Path)
		}
		if strings.TrimSpace(u.Why) == "" {
			add("unapplied %s gives no reason", u.Path)
		}
	}
	if len(problems) > 0 {
		return errors.New(strings.Join(problems, "; "))
	}
	return nil
}

func (w Wait) check(values reflect.Type) error {
	k, ok := WaitKinds[w.Kind]
	if !ok {
		return fmt.Errorf("wait kind %q is not one of %v", w.Kind, waitKindNames())
	}
	from, ok := k.For[w.For]
	if !ok {
		return fmt.Errorf("a %s wait cannot be for %q", w.Kind, w.For)
	}
	if w.Kind == "APIBinding" && w.Name != "" {
		return errors.New("an APIBinding wait is for every binding in its workspace and names none")
	}
	if w.Capture == nil {
		return nil
	}
	if w.Capture.From != from || from == "" {
		return fmt.Errorf("a %s %s wait cannot capture %q", w.Kind, w.For, w.Capture.From)
	}
	fld, ok := values.FieldByName(w.Capture.Into)
	if !ok || fld.Type.Kind() != captureKinds[from] {
		return fmt.Errorf("capture into %s: no %s field of that name", w.Capture.Into, captureKinds[from])
	}
	return nil
}