package host

import (
	"crypto/ed25519"
	"encoding/base64"
	"os"
	"path/filepath"
	"testing"

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

func signedRecoveryFixture(t *testing.T) (*proofRootEnv, *plan14RestartUnits, rootRestartChecks, *proofBindingSource, ed25519.PublicKey) {
	t.Helper()
	e, rt, u, c, _ := plan14AdoptionFixture(t)
	pub, priv, err := ed25519.GenerateKey(nil)
	if err != nil {
		t.Fatal(err)
	}
	t.Setenv("CARLOS_RELEASE_PUBKEY", base64.StdEncoding.EncodeToString(pub))
	if err := e.store.Delete(t.Context(), release.ChannelKey(rt.Account, rt.App, rt.Channel)); err != nil {
		t.Fatal(err)
	}
	for _, ver := range []string{"v1", "v2"} {
		if err := release.Promote(t.Context(), e.store, priv, rt.Account, rt.App, rt.Channel, ver); err != nil {
			t.Fatal(err)
		}
	}
	source := &proofBindingSource{signedRecovery: true, store: e.store, sys: u, optDir: u.opt, openFile: os.Open, unitDirs: []string{filepath.Dir(u.props.FragmentPath)}}
	c.resolve, c.host, c.rollback, c.prepareRollback, c.recovered = source.resolve, source.forHost, source.rollback, source.prepareRollback, source.recovered
	return e, u, c, source, pub
}

func TestPlan14SignedRestartWithoutHealthHistory(t *testing.T) {
	e, u, c, _, _ := signedRecoveryFixture(t)
	rt, err := e.root.reg.Get(observedHost)
	if err != nil {
		t.Fatal(err)
	}
	rec, _, err := provision.FindRecordByHost(t.Context(), e.store, rt.Host)
	if err != nil {
		t.Fatal(err)
	}
	rec.Pin = "v1"
	plan14PutRecord(t, e.store, *rec)
	err = checkedUnitRestart(u, u.opt, func(string) string { return "5s" }, nil, c)(*rt)
	if err != nil || len(u.effects) != 1 {
		t.Fatalf("signed restart depended on health history: %v %v", err, u.effects)
	}
}

func TestPlan14CapturedRollbackWithoutHealthHistory(t *testing.T) {
	t.Parallel()
	e, rt, u, c, _ := plan14AdoptionFixture(t)
	before, err := c.host(t.Context(), rt.Host)
	if err != nil {
		t.Fatal(err)
	}
	disk, err := c.attempts()
	if err != nil {
		t.Fatal(err)
	}
	a, err := captureRollback(disk, before, c.now(), unitSettleTimeout(func(string) string { return "5s" }), release.VersionPath(u.opt, rt.Account, "v2", rt.App), c.identity)
	if err != nil {
		t.Fatal(err)
	}
	a.Failed = true
	if err := writeRollbackState(disk, rollbackJournalKey(rt.Host), a); err != nil {
		t.Fatal(err)
	}
	source := &proofBindingSource{store: e.store, sys: u, optDir: u.opt, openFile: os.Open, unitDirs: []string{filepath.Dir(u.props.FragmentPath)}}
	c.rollback, c.prepareRollback, c.recovered = source.rollback, source.prepareRollback, source.recovered
	u.props.ActiveState, u.props.SubState, u.props.MainPID = "failed", "failed", 0
	if err := rollbackUnitRestart(e.root.reg, u, u.opt, func(string) string { return "5s" }, c)(rt.Host); err != nil {
		t.Fatal(err)
	}
	if len(u.effects) != 2 || u.exe != release.VersionPath(u.opt, rt.Account, "v1", rt.App) {
		t.Fatalf("rollback blocked: %v", u.effects)
	}
}

func TestPlan14SignedRestartRequiresTrustedLiveLink(t *testing.T) {
	e, u, c, _, _ := signedRecoveryFixture(t)
	rt, err := e.root.reg.Get(observedHost)
	if err != nil {
		t.Fatal(err)
	}
	c.readLive = func(string) (string, error) { return "", os.ErrPermission }
	if err := checkedUnitRestart(u, u.opt, func(string) string { return "5s" }, nil, c)(*rt); err == nil || len(u.effects) != 0 {
		t.Fatalf("untrusted pointer restarted: %v %v", err, u.effects)
	}
	if productionRootRestartChecks(u, u.opt).readLive == nil {
		t.Fatal("production restart has no checked pointer reader")
	}
}