package compose

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strings"
	"time"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/types"

	"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)

const (
	ConditionComponentDrift = "ComponentDrift"

	ReasonDriftReverted = "ChildEditReverted"
	ReasonNoDrift       = "NoDrift"
)

type driftState struct {
	children map[string]string

	since time.Time
}

func driftKey(r Root) string { return r.Workspace + "|" + r.Owner() }

func (c *Composer) revertForeignSpec(ctx context.Context, r Root, ws string, gvr schema.GroupVersionResource, u kube.Doc) error {
	ri, err := c.Client(ws, gvr)
	if err != nil {
		return err
	}
	rc := ri.In(docMetaField(u, "namespace"))
	kind, name := docField(u, "kind"), docMetaField(u, "name")
	child := kind + "/" + name
	live, err := kube.Get[kube.Doc](ctx, rc, name)
	if err != nil {
		return fmt.Errorf("compose: reading %s in %s for drift: %w", child, ws, err)
	}
	desired, _ := u["spec"].(map[string]any)
	liveSpec, _ := (*live)["spec"].(map[string]any)
	var drifted []string
	patch := map[string]any{}
	for _, key := range foreignSpecKeys(*live, r.Manager()) {
		want, wanted := desired[key]
		have, present := liveSpec[key]
		switch {
		case !wanted && present:
			patch[key] = nil
		case wanted && !reflect.DeepEqual(normalizeJSON(want), normalizeJSON(have)):
			patch[key] = want
		default:
			continue
		}
		drifted = append(drifted, key)
	}
	if len(drifted) == 0 {
		c.setDrift(r, child, "")
		return nil
	}
	sort.Strings(drifted)
	data, err := json.Marshal(map[string]any{"spec": patch})
	if err != nil {
		return err
	}
	if _, err := kube.Patch[kube.Doc](ctx, rc, name, types.MergePatchType, data, metav1.PatchOptions{FieldManager: r.Manager()}); err != nil {
		return fmt.Errorf("compose: reverting the edited spec of %s in %s: %w", child, ws, err)
	}
	message := fmt.Sprintf("%s: spec.%s set by another manager is reverted to the spec %s %s composes", child,
		strings.Join(drifted, ", spec."), r.Kind, r.Name)
	c.log.Warn("a direct edit of a composed child is reverted", "root", r.Owner(), "child", child, "workspace", ws, "fields", drifted)
	c.Event(ctx, r, ws, docField(u, "apiVersion"), kind, name, "Warning", ReasonChildEditReverted, message)
	c.setDrift(r, child, message)
	return nil
}

func foreignSpecKeys(live kube.Doc, manager string) []string {
	meta, _ := live["metadata"].(map[string]any)
	entries, _ := meta["managedFields"].([]any)
	seen := map[string]bool{}
	var out []string
	for _, raw := range entries {
		entry, _ := raw.(map[string]any)
		if entry == nil || entry["manager"] == manager || entry["subresource"] == "status" {
			continue
		}
		fields, _ := entry["fieldsV1"].(map[string]any)
		spec, _ := fields["f:spec"].(map[string]any)
		for key := range spec {
			name, ok := strings.CutPrefix(key, "f:")
			if !ok || seen[name] {
				continue
			}
			seen[name] = true
			out = append(out, name)
		}
	}
	sort.Strings(out)
	return out
}

func normalizeJSON(v any) any {
	raw, err := json.Marshal(v)
	if err != nil {
		return v
	}
	var out any
	if err := json.Unmarshal(raw, &out); err != nil {
		return v
	}
	return out
}

func (c *Composer) setDrift(r Root, child, message string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.drift == nil {
		c.drift = map[string]*driftState{}
	}
	key := driftKey(r)
	state := c.drift[key]
	if message == "" {
		if state != nil {
			delete(state.children, child)
			if len(state.children) == 0 {
				delete(c.drift, key)
			}
		}
		return
	}
	if state == nil {
		state = &driftState{children: map[string]string{}, since: time.Now().UTC()}
		c.drift[key] = state
	}
	state.children[child] = message
}

func (c *Composer) driftCondition(r Root, gen int64) map[string]any {
	c.mu.Lock()
	state := c.drift[driftKey(r)]
	var messages []string
	since := time.Now().UTC()
	if state != nil {
		for _, m := range state.children {
			messages = append(messages, m)
		}
		since = state.since
	}
	c.mu.Unlock()
	cond := map[string]any{"type": ConditionComponentDrift, "observedGeneration": gen,
		"lastTransitionTime": since.Format(time.RFC3339)}
	if len(messages) == 0 {
		cond["status"], cond["reason"], cond["message"] = string(metav1.ConditionFalse), ReasonNoDrift, "every composed child matches its desired spec"
		return cond
	}
	sort.Strings(messages)
	cond["status"], cond["reason"], cond["message"] = string(metav1.ConditionTrue), ReasonDriftReverted, strings.Join(messages, "; ")
	return cond
}

func withDriftCondition(m map[string]any, cond map[string]any) {
	list, _ := m["conditions"].([]any)
	out := make([]any, 0, len(list)+1)
	replaced := false
	for _, raw := range list {
		existing, _ := raw.(map[string]any)
		if existing != nil && existing["type"] == ConditionComponentDrift {
			if existing["status"] == cond["status"] {
				cond["lastTransitionTime"] = existing["lastTransitionTime"]
			}
			out = append(out, cond)
			replaced = true
			continue
		}
		out = append(out, raw)
	}
	if !replaced {
		out = append(out, cond)
	}
	m["conditions"] = out
}