package reconciler

import (
	"context"
	"testing"

	"github.com/alexei/tinyforge/internal/docker"
	"github.com/alexei/tinyforge/internal/store"
)

// fakeDocker is a tiny stand-in for docker.Client. The reconciler depends on
// the DockerLister interface so we don't need a real daemon for unit tests.
type fakeDocker struct {
	items []docker.ReconcileItem
}

func (f *fakeDocker) ListAllForReconciler(ctx context.Context) ([]docker.ReconcileItem, error) {
	return f.items, nil
}

func newTestStore(t *testing.T) *store.Store {
	t.Helper()
	s, err := store.New(":memory:")
	if err != nil {
		t.Fatalf("create store: %v", err)
	}
	t.Cleanup(func() { s.Close() })
	return s
}

func TestReconcileWorkloadLabelledStackContainer(t *testing.T) {
	st := newTestStore(t)

	// Set up a stack workload (no project/site interaction).
	stack, err := st.CreateStack(store.Stack{
		Name: "wf-stack", ComposeProjectName: "tinyforge-wf-stack",
	})
	if err != nil {
		t.Fatalf("CreateStack: %v", err)
	}
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// One container with the canonical workload labels stamped.
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-abc",
		Name:  "wf-stack-web-1",
		Image: "nginx:1.27",
		State: "running",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "stack",
			docker.LabelRole:         "web",
		},
		Ports: []uint16{8080},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	rows, _ := st.ListContainersByWorkload(w.ID)
	if len(rows) != 1 {
		t.Fatalf("expected 1 container row, got %d", len(rows))
	}
	got := rows[0]
	if got.ContainerID != "docker-abc" {
		t.Fatalf("container_id not bound: got %q", got.ContainerID)
	}
	if got.Role != "web" || got.WorkloadKind != "stack" {
		t.Fatalf("dispatch wrong: %+v", got)
	}
	if got.State != "running" || got.Port != 8080 {
		t.Fatalf("state/port wrong: %+v", got)
	}
}

func TestReconcileComposeOnlyStackContainer(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "compose-stack", ComposeProjectName: "tinyforge-compose-stack",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// Pre-existing compose container — only carries compose's own labels,
	// no tinyforge.* labels at all.
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-xyz",
		Name:  "tinyforge-compose-stack-worker-1",
		Image: "redis:7",
		State: "running",
		Labels: map[string]string{
			"com.docker.compose.project": "tinyforge-compose-stack",
			"com.docker.compose.service": "worker",
		},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	rows, _ := st.ListContainersByWorkload(w.ID)
	if len(rows) != 1 {
		t.Fatalf("expected 1 row, got %d", len(rows))
	}
	if rows[0].Role != "worker" {
		t.Fatalf("role from compose label wrong: %q", rows[0].Role)
	}
	if rows[0].ContainerID != "docker-xyz" {
		t.Fatalf("container_id not bound: %q", rows[0].ContainerID)
	}
}

func TestReconcileMarksMissingRows(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "missing-stack", ComposeProjectName: "tinyforge-missing-stack",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// Pre-existing row with a real container_id that no longer exists.
	if err := st.UpsertContainer(store.Container{
		ID: w.ID + ":web", WorkloadID: w.ID, WorkloadKind: "stack",
		Role: "web", ContainerID: "docker-gone", State: "running",
	}); err != nil {
		t.Fatalf("seed: %v", err)
	}

	// Reconciler sees nothing.
	r := New(st, &fakeDocker{}, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "missing" {
		t.Fatalf("expected state=missing, got %q", got.State)
	}
}

func TestReconcileSkipsRowsAwaitingDocker(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "pending", ComposeProjectName: "tinyforge-pending",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// A row with empty container_id (deployer placeholder, awaiting docker
	// create). Reconciler must not mark this as missing.
	if err := st.UpsertContainer(store.Container{
		ID: w.ID + ":web", WorkloadID: w.ID, WorkloadKind: "stack",
		Role: "web", ContainerID: "", State: "starting",
	}); err != nil {
		t.Fatalf("seed: %v", err)
	}

	r := New(st, &fakeDocker{}, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "starting" {
		t.Fatalf("placeholder row should keep state, got %q", got.State)
	}
}

func TestReconcileIgnoresUnmanagedContainers(t *testing.T) {
	// A container without any tinyforge or compose labels would not even be
	// returned by ListAllForReconciler in production; but the dispatch must
	// be a no-op even if a stray item slips through.
	st := newTestStore(t)
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID: "docker-foreign", Labels: map[string]string{"app": "other"},
	}}}
	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}
	rows, _ := st.ListContainers(store.ContainerFilter{})
	if len(rows) != 0 {
		t.Fatalf("foreign container should not produce rows, got %d", len(rows))
	}
}

func TestReconcileNormalizesState(t *testing.T) {
	st := newTestStore(t)
	stack, _ := st.CreateStack(store.Stack{
		Name: "norm", ComposeProjectName: "tinyforge-norm",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-1",
		Image: "nginx",
		State: "exited",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "stack",
			docker.LabelRole:         "web",
		},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "stopped" {
		t.Fatalf("docker 'exited' should normalize to 'stopped', got %q", got.State)
	}
}