package host

import (
	"bytes"
	"os"
	"testing"

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

func TestPlan14ERecoveryNoCensus(t *testing.T) {
	for _, state := range []string{"active", "failed", "inactive"} {
		for _, flag := range []bool{false, true} {
			t.Run(state+map[bool]string{false: "/flag off", true: "/flag on"}[flag], func(t *testing.T) {
				e, u, c, source, pub := signedRecoveryFixture(t)
				c.legacy = func() (bool, error) { return true, nil }
				c.legacyReady = c.ready
				if state != "active" {
					u.props.ActiveState, u.props.MainPID = state, 0
				}
				n := namedUnitRecovery{source: source, pub: pub, readLive: os.Readlink, writes: hostwrite.Config{Enabled: flag, Selector: namedRecoveryWork{}}}
				handled, err := n.recover(t.Context(), observedHost, c, func(string) string { return "5s" }, e.root.reg)
				live, liveErr := release.LiveVersion(u.opt, observedHost)
				if handled || err != nil || liveErr != nil || live != "v1" || len(u.effects) != 0 {
					t.Fatalf("no-census recovery drove an effect: handled=%v err=%v live=%s/%v effects=%v", handled, err, live, liveErr, u.effects)
				}
				disk, _ := c.attempts()
				if names, err := disk.Names(); err != nil || len(names) != 0 {
					t.Fatalf("recovery created authority: %v %v", names, err)
				}
			})
		}
	}
}

func TestPlan14ERecoveryNoCensusResume(t *testing.T) {
	for _, independent := range []bool{false, true} {
		t.Run(map[bool]string{false: "linked", true: "independent"}[independent], func(t *testing.T) {
			e, u, c, _, _ := signedRecoveryFixture(t)
			b, err := c.host(t.Context(), observedHost)
			if err != nil {
				t.Fatal(err)
			}
			disk, err := c.attempts()
			if err != nil {
				t.Fatal(err)
			}
			target := release.VersionPath(u.opt, b.Route.Account, "v2", b.Route.App)
			a, err := captureRollback(disk, b, c.now(), unitSettleTimeout(func(string) string { return "5s" }), target, c.identity, historyRollbackLink{Binding: release.HistoryBinding{Host: b.Route.Host, Account: b.Route.Account, App: b.Route.App}, Attempt: release.HistoryAttempt{ID: "linked", Source: b.Source, Version: "v2", SHA256: "failed-digest", Platform: release.AdoptPlatform(), Started: c.now(), PromotedAt: c.now()}, Independent: independent})
			if err != nil {
				t.Fatal(err)
			}
			if err := release.StageArtifact(u.opt, b.Route.Account, "v2", b.Route.App, []byte("new build")); err != nil {
				t.Fatal(err)
			}
			if err := release.PointLive(u.opt, observedHost, b.Route.Account, "v2", b.Route.App); err != nil {
				t.Fatal(err)
			}
			u.props.ActiveState, u.props.MainPID = "failed", 0
			before, err := disk.Read(rollbackJournalKey(a.Host))
			if err != nil {
				t.Fatal(err)
			}
			rt, _ := e.root.reg.Get(observedHost)
			h := seedHostRootHistory(t, *rt)
			c.history = func() (*release.RootHistoryPass, error) { return &release.RootHistoryPass{History: h}, nil }
			c.legacy = func() (bool, error) { return true, nil }
			if err := resumeHistoryRestart(t.Context(), u, u.opt, func(string) string { return "5s" }, c, hostwrite.Config{}, disk, a); err != nil {
				t.Fatal(err)
			}
			after, err := disk.Read(rollbackJournalKey(a.Host))
			if err != nil {
				t.Fatal(err)
			}
			live, err := release.LiveVersion(u.opt, observedHost)
			if err != nil || live != "v2" || len(u.effects) != 0 || !bytes.Equal(before, after) {
				t.Fatalf("resume changed effects/evidence: live=%s/%v effects=%v journalChanged=%v", live, err, u.effects, !bytes.Equal(before, after))
			}
			if independent {
				if _, err := h.Refusals(a.HistoryBinding); err == nil {
					t.Fatal("no-census observation lost pending evidence")
				}
				if _, err := c.mintRefusals(h, a.HistoryBinding); err == nil {
					t.Fatal("pending recovery granted mint")
				}
			}
		})
	}
}

func TestPlan14ERecoveryOrdinaryNoCensusRead(t *testing.T) {
	e, _, c, source, pub := signedRecoveryFixture(t)
	rt, err := e.root.reg.Get(observedHost)
	if err != nil {
		t.Fatal(err)
	}
	rt.Unit = ""
	if err := e.root.reg.Delete(rt.Host); err != nil {
		t.Fatal(err)
	}
	if err := e.root.reg.Upsert(*rt); err != nil {
		t.Fatal(err)
	}
	c.legacy = func() (bool, error) { t.Fatal("ordinary E recovery read census"); return true, nil }
	n := namedUnitRecovery{source: source, pub: pub, readLive: os.Readlink}
	if handled, err := n.recover(t.Context(), observedHost, c, func(string) string { return "5s" }, e.root.reg); handled || err != nil {
		t.Fatalf("ordinary recovery: %v %v", handled, err)
	}
}