package host

import (
	"errors"
	"github.com/carlosframework/platform/internal/hostbox"
	"github.com/carlosframework/platform/internal/hostclaim"
	"github.com/carlosframework/platform/internal/park"
	"testing"
)

func TestPlan13ClaimRegionBinding(t *testing.T) {
	for _, tc := range []struct {
		roster, code, engine, home string
		bad                        bool
	}{
		{"ie", "", "ie", "ie", false}, {"uk", "uk", "uk", "", false},
		{"ca", "", "", "", true}, {"uk", "ie", "", "", true}, {"", "", "", "", true}, {"@home", "", "", "", true}, {"ie", "@home", "", "", true},
	} {
		e, h, err := claimRegionBinding(tc.roster, tc.code, "ie")
		if e != tc.engine || h != tc.home || (err != nil) != tc.bad {
			t.Fatalf("%+v: %q %q %v", tc, e, h, err)
		}
	}
}
func TestPlan13VerifyRegionalHomeNames(t *testing.T) {
	t.Parallel()
	for _, home := range []string{"region", ""} {
		identity := handoverRecoveryIdentity(t, hostbox.Actor{Box: "box", Enrollment: "enrolled", Region: "region", FleetHomeRegion: "region", ControlBucket: "control", Revision: 1, Binding: "1"})
		identity.HomeRegion = home
		actor, err := identity.Verify(t.Context())
		if err != nil {
			t.Fatal(err)
		}
		e := claimRegionalEnrollment{identity: identity, actor: actor}
		for _, region := range []string{"region", park.HomeRegion, "other", ""} {
			err = e.VerifyRegional(t.Context(), region, actor.Bucket, hostbox.RequestLimit)
			want := region == "region" || (home != "" && region == park.HomeRegion)
			if (err == nil) != want {
				t.Fatalf("home %q region %q: %v", home, region, err)
			}
		}
		if err = e.VerifyRegional(t.Context(), actor.Region, "other", hostbox.RequestLimit); !errors.Is(err, hostbox.ErrChanged) {
			t.Fatal(err)
		}
	}
}

func TestPlan13UnverifiedAliasRefused(t *testing.T) {
	t.Parallel()
	for _, fleet := range []string{"", "ie"} {
		identity := handoverRecoveryIdentity(t, hostbox.Actor{Box: "box", Enrollment: "enrolled", Region: "ca", FleetHomeRegion: fleet, Revision: 1, Binding: "1"})
		identity.HomeRegion = "ca"
		if _, err := identity.Verify(t.Context()); err == nil {
			t.Fatal("unverified home alias accepted", fleet)
		}
	}
}

func TestPlan13NamedBoxCannotAcknowledgeHomeDelete(t *testing.T) {
	t.Parallel()
	if _, _, err := claimRegionBinding("ca", "", "ie"); err == nil {
		t.Fatal("missing CARLOS_REGION granted alias")
	}
	identity := handoverRecoveryIdentity(t, hostbox.Actor{Box: "ca-box", Enrollment: "enrolled", Region: "ca", FleetHomeRegion: "ie", Revision: 1, Binding: "1"})
	p := productionClaimRegional{Identity: identity, Local: &productionClaimLocal{legacyParticipation: true, Identity: identity, Resources: ClaimRuntimeResources{Mode: "agent", DataDir: t.TempDir()}, assembly: &ClaimAssembly{}, lifetime: t.Context()}}
	for _, kind := range []string{hostclaim.KindDeleting, hostclaim.KindParking, hostclaim.KindPurging} {
		ob := hostclaim.Obligation{ID: "chore", Op: "delete", Kind: "park-replica", Owner: "region:ca", Region: "ca", Retirement: "retirement"}
		o := hostclaim.Observed{Host: "test.example", Claim: &hostclaim.Claim{Holder: &hostclaim.Holder{}, Op: hostclaim.Op{ID: "delete", Kind: kind}, Obligations: []hostclaim.Obligation{ob}}}
		if err := p.Authorize(t.Context(), o, ob); err != nil {
			t.Fatal("named control", err)
		}
		ob.Region, ob.Owner = park.HomeRegion, "region:@home"
		o.Claim.Obligations[0] = ob
		if err := p.Authorize(t.Context(), o, ob); err == nil {
			t.Fatal("acknowledged home delete", kind)
		}
		if (park.Engine{Region: "ca"}).OwnsRegion(park.HomeRegion) {
			t.Fatal("named engine owns home")
		}
	}
}

func TestPlan13MissingDesignationRunsNamedOnly(t *testing.T) {
	t.Parallel()
	for _, name := range []string{"ie", "ca"} {
		for _, code := range []string{"", name} {
			engine, home, err := claimRegionBinding(name, code, "")
			if err != nil || engine != name || home != "" {
				t.Fatalf("%q/%q: %q %q %v", name, code, engine, home, err)
			}
			p := park.Engine{Region: engine, HomeRegion: home}
			if !p.OwnsRegion(name) || p.OwnsRegion(park.HomeRegion) {
				t.Fatal("degraded ownership", p)
			}
			identity := handoverRecoveryIdentity(t, hostbox.Actor{Box: "box", Enrollment: "enrolled", Region: name, Revision: 1, Binding: "1"})
			identity.HomeRegion = home
			if _, err := identity.Verify(t.Context()); err != nil {
				t.Fatal("named runtime identity", err)
			}
		}
	}
}