package provision

import (
	"context"
	"errors"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/release"
)

func TestSidecarHostAndValidation(t *testing.T) {
	got := SidecarHost("bot-acme", "eleven", "bdm")
	if want := "bot-acme.eleven.bdm.sidecar.internal"; got != want {
		t.Fatalf("SidecarHost = %q, want %q", got, want)
	}
	if !ValidSidecarHost(got, "eleven", "bdm") {
		t.Fatal("its own SidecarHost output must validate")
	}
	for _, bad := range []string{
		"bot-acme.other.bdm.sidecar.internal",  // wrong app
		"bot-acme.eleven.bad.sidecar.internal", // wrong sqid
		"bot-acme.eleven.bdm.example.com",      // wrong suffix
		"a.b.bot.eleven.bdm.sidecar.internal",  // more than one label
	} {
		if ValidSidecarHost(bad, "eleven", "bdm") {
			t.Fatalf("ValidSidecarHost(%q) = true, want false", bad)
		}
	}
	for _, bad := range []string{"", "-lead", "trail-", "UPPER", "has.dot", "has/slash", "..", strings.Repeat("a", 64)} {
		if ValidSidecarName(bad) {
			t.Fatalf("ValidSidecarName(%q) = true — the name becomes a bucket key AND a filesystem path segment", bad)
		}
	}
}

func TestParseSidecarKey(t *testing.T) {
	known := map[string]bool{"bdm": true}
	acct, app, name, ok := ParseSidecarKey("apps/bdm/eleven/sidecars/bot-acme.json", known)
	if !ok || acct != "bdm" || app != "eleven" || name != "bot-acme" {
		t.Fatalf("ParseSidecarKey = %q/%q/%q ok=%v", acct, app, name, ok)
	}
	for _, bad := range []string{
		"apps/bdm/eleven/sidecars.json",          // the manifest, not a record
		"apps/bdm/eleven/sidecars/nested/x.json", // nested
		"apps/bdm/eleven/sidecars/.json",         // empty name
		"apps/unknown/eleven/sidecars/bot.json",  // account not materialized
		"apps/bdm/channels/sidecars/bot.json",    // release-plane collision
		"apps/bdm/eleven/instances/bot.json",     // the other family
	} {
		if _, _, _, ok := ParseSidecarKey(bad, known); ok {
			t.Fatalf("ParseSidecarKey(%q) parsed, want refusal", bad)
		}
	}
}

func TestCreateSidecarRecordIsCreateOnly(t *testing.T) {
	ctx := context.Background()
	s := dirStore(t) // the helper reconcile_test.go already uses
	rec := SidecarRecord{
		Schema: 1, Name: "bot-acme", Host: SidecarHost("bot-acme", "eleven", "bdm"),
		App: "eleven", Account: "bdm", Channel: "stable",
	}
	if err := CreateSidecarRecord(ctx, s, rec); err != nil {
		t.Fatalf("first create: %v", err)
	}
	err := CreateSidecarRecord(ctx, s, rec)
	if !errors.Is(err, release.ErrCASConflict) {
		t.Fatalf("second create err = %v, want ErrCASConflict — a lost race must never silently overwrite", err)
	}
}

func TestCreateSidecarRecordRoundTripsCreatedAt(t *testing.T) {
	ctx := context.Background()
	s := dirStore(t)
	want := time.Date(2026, 8, 17, 23, 0, 0, 0, time.UTC)
	rec := SidecarRecord{
		Schema: 1, Name: "bot-acme", Host: SidecarHost("bot-acme", "eleven", "bdm"),
		App: "eleven", Account: "bdm", Channel: "stable", CreatedAt: want,
	}
	if err := CreateSidecarRecord(ctx, s, rec); err != nil {
		t.Fatalf("create: %v", err)
	}
	got, err := GetSidecarRecord(ctx, s, "bdm", "eleven", "bot-acme")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	// .Equal, not ==: a struct comparison would fail on the monotonic-clock
	// reading time.Now() carries and json round-trips never preserve, and
	// .UTC() side-steps any location difference too — the store only owes
	// us the same instant back, not the same in-memory representation of it.
	if !got.CreatedAt.Equal(want) {
		t.Fatalf("CreatedAt round-trip = %v, want %v", got.CreatedAt, want)
	}
	if got.CreatedAt.UTC().Format(time.RFC3339) != "2026-08-17T23:00:00Z" {
		t.Fatalf("CreatedAt wire format = %v, want RFC3339 like the spec's example", got.CreatedAt.UTC().Format(time.RFC3339))
	}
}

func TestGetSidecarRecordRefusesRecordThatLiesAboutItsPath(t *testing.T) {
	ctx := context.Background()
	s := dirStore(t)
	body := []byte(`{"schema":1,"name":"bot-acme","app":"OTHER","account":"bdm"}`)
	if _, err := s.Put(ctx, SidecarRecordKey("bdm", "eleven", "bot-acme"), body, ""); err != nil {
		t.Fatalf("seed: %v", err)
	}
	if _, err := GetSidecarRecord(ctx, s, "bdm", "eleven", "bot-acme"); err == nil {
		t.Fatal("a record disagreeing with its own key path must be refused, never guessed at")
	}
}

func TestSidecarManifestDefaults(t *testing.T) {
	var m SidecarManifest
	if m.IdleOrDefault() != 5*time.Minute {
		t.Fatalf("idle default = %v, want 5m", m.IdleOrDefault())
	}
	if m.MaxRunOrDefault() != time.Hour {
		t.Fatalf("max_run default = %v, want 1h", m.MaxRunOrDefault())
	}
	if !m.HibernateOrDefault() {
		t.Fatal("hibernate must default true")
	}
	if m.PlacementOrDefault() != "any" {
		t.Fatalf("placement default = %q, want any", m.PlacementOrDefault())
	}
	no := false
	m2 := SidecarManifest{Hibernate: &no}
	if m2.HibernateOrDefault() {
		t.Fatal("an explicit false must win — tri-state, like instances' Hibernate")
	}
}

func TestSidecarManifestSchemaNewerIsRefused(t *testing.T) {
	ctx := context.Background()
	s := dirStore(t)
	if _, err := s.Put(ctx, SidecarManifestKey("bdm", "eleven"), []byte(`{"schema":2}`), ""); err != nil {
		t.Fatalf("seed: %v", err)
	}
	if _, err := GetSidecarManifest(ctx, s, "bdm", "eleven"); err == nil {
		t.Fatal("a schema newer than this binary understands must be refused, not silently truncated")
	}
}

func TestSidecarManifestAbsenceIsNotExist(t *testing.T) {
	_, err := GetSidecarManifest(context.Background(), dirStore(t), "bdm", "eleven")
	if !errors.Is(err, os.ErrNotExist) {
		t.Fatalf("absence err = %v, want os.ErrNotExist — absence means the feature does not exist for that app", err)
	}
}

func TestValidateSidecarShape(t *testing.T) {
	ok := SidecarRecord{Schema: 1, Name: "bot", Host: SidecarHost("bot", "eleven", "bdm"),
		App: "eleven", Account: "bdm", Channel: "stable", Placement: "no-inbound"}
	if err := ValidateSidecarShape(ok); err != nil {
		t.Fatalf("valid record refused: %v", err)
	}
	bad := ok
	bad.Placement = "sideways"
	if err := ValidateSidecarShape(bad); err == nil {
		t.Fatal("placement vocabulary must be closed")
	}
}