//go:build linux

package host

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

	"golang.org/x/sys/unix"
)

func TestServingParkRebootCommitResumes(t *testing.T) {
	for _, phase := range []string{"rename-reply", "parked", "retagged", "complete", "source-gone"} {
		t.Run(phase, func(t *testing.T) {
			f, original := servingRebootPreparationFixture(t, phase)
			id := original.Authorization.ID
			before, err := f.disk.Read("retirement-" + id + ".json")
			if err != nil {
				t.Fatal(err)
			}
			if err := f.p.commitServingReboot(t.Context(), id); err != nil {
				t.Fatal(err)
			}
			after, _ := f.disk.Read("retirement-" + id + ".json")
			if string(before) != string(after) {
				t.Fatal("commit rewrote historical retirement")
			}
			fs := f.p.ledger.fs.(*servingParkFS)
			if err := fs.recoverRecordedNamespace(t.Context()); err != nil {
				t.Fatal(err)
			}
			r, err := f.p.ledger.read(id)
			if err != nil || r.Source.BootID != servingOtherBoot {
				t.Fatal("current authority", err)
			}
			if r.ParkedAt != original.ParkedAt || r.ReapAfter != original.ReapAfter {
				t.Fatal("retention changed")
			}
			if r.Complete {
				f.f.now = r.ReapAfter
				if err := f.p.ledger.reapLocked(t.Context(), id); err != nil {
					t.Fatal("reap", err)
				}
			} else {
				f.tags(f.current.Stamp)
				if err := f.p.recoverServingPark(t.Context(), r); err != nil {
					t.Fatal("resume", err)
				}
			}
			raw, err := f.p.ledger.readHistorical(id)
			if err != nil || raw.Source.BootID != original.Source.BootID || raw.Authorization != original.Authorization {
				t.Fatal("history changed", err)
			}
		})
	}
}

func TestServingParkRebootCommitLostWrite(t *testing.T) {
	for _, before := range []bool{true, false} {
		for at := 1; at <= 3; at++ {
			f, r := servingRebootPreparationFixture(t, "complete")
			fault := &servingParkFaultStore{Store: f.disk, failAt: at, before: before}
			f.p.ledger.state = fault
			fs := f.p.ledger.fs.(*servingParkFS)
			fs.state = fault
			err := f.p.commitServingReboot(t.Context(), r.Authorization.ID)
			if !errors.Is(err, os.ErrPermission) {
				t.Fatalf("%v/%d: %v", before, at, err)
			}
			f.p.ledger.state = f.disk
			fs.state = f.disk
			if err := f.p.commitServingReboot(t.Context(), r.Authorization.ID); err != nil {
				t.Fatal("retry", err)
			}
			current, err := f.p.ledger.read(r.Authorization.ID)
			if err != nil {
				t.Fatal(err)
			}
			if err := fs.CheckParked(&current); err != nil {
				t.Fatal(err)
			}
		}
	}
}

func TestServingParkRebootCommitRefusesChangedEvidence(t *testing.T) {
	for _, fault := range []string{"file", "slot", "claim", "census"} {
		t.Run(fault, func(t *testing.T) {
			f, r := servingRebootPreparationFixture(t, "parked")
			if err := f.p.prepareServingReboot(t.Context(), r.Authorization.ID); err != nil {
				t.Fatal(err)
			}
			switch fault {
			case "file":
				fs := f.p.ledger.fs.(*servingParkFS)
				fs.handle = func(*os.File) (servingParkPersistentDirectory, error) {
					return servingParkPersistentDirectory{}, unix.EIO
				}
			case "slot":
				s, _ := f.p.ledger.slot(r.Authorization)
				s.ID = ""
				if err := f.p.ledger.write("slot-"+servingParkKey(s.Box, s.Host)+".json", s); err != nil {
					t.Fatal(err)
				}
			case "claim":
				f.tags(f.current.Stamp)
			case "census":
				f.p.root.RequireNewWork = func(_ context.Context) error { return unix.EPERM }
			}
			before := servingBootSnapshot(t, f.disk.dir)
			if err := f.p.commitServingReboot(t.Context(), r.Authorization.ID); err == nil {
				t.Fatal("accepted changed evidence")
			}
			if !reflect.DeepEqual(before, servingBootSnapshot(t, f.disk.dir)) {
				t.Fatal("refusal wrote authority")
			}
		})
	}
}

func TestServingParkRebootCommitSecondBoot(t *testing.T) {
	f, r := servingRebootPreparationFixture(t, "complete")
	id := r.Authorization.ID
	if err := f.p.commitServingReboot(t.Context(), id); err != nil {
		t.Fatal(err)
	}
	fs := f.p.ledger.fs.(*servingParkFS)
	nextBoot := "11234567-89ab-4cde-8fab-0123456789ab"
	fs.boot = func() (string, error) { return nextBoot, nil }
	if err := f.p.commitServingReboot(t.Context(), id); err != nil {
		t.Fatal("second boot", err)
	}
	current, err := f.p.ledger.read(id)
	if err != nil || current.Source.BootID != nextBoot {
		t.Fatal(err)
	}
	if err := fs.CheckParked(&current); err != nil {
		t.Fatal(err)
	}
	historical, err := f.p.ledger.readHistorical(id)
	if err != nil || !reflect.DeepEqual(historical, r) {
		t.Fatal("history changed", err)
	}
}

func TestServingParkRebootStartupCommits(t *testing.T) {
	f, r := servingRebootPreparationFixture(t, "retagged")
	page, err := f.p.recoverServingParks(t.Context(), "", servingParkRecoveryLimit)
	if err != nil {
		t.Fatal(err)
	}
	for _, result := range page.Results {
		if result.Err != nil {
			t.Fatal(result)
		}
	}
	current, err := f.p.ledger.read(r.Authorization.ID)
	if err != nil || !current.Complete || current.Source.BootID != servingOtherBoot {
		t.Fatal(current, err)
	}
}

func TestServingParkRebootBindingCollectionCrash(t *testing.T) {
	f, old := servingRebootPreparationFixture(t, "complete")
	id := old.Authorization.ID
	if err := f.p.commitServingReboot(t.Context(), id); err != nil {
		t.Fatal(err)
	}
	current, err := f.p.ledger.read(id)
	if err != nil {
		t.Fatal(err)
	}
	f.f.now = current.ReapAfter
	if err := f.p.ledger.reapLocked(t.Context(), id); err != nil {
		t.Fatal(err)
	}
	current, err = f.p.ledger.read(id)
	if err != nil {
		t.Fatal(err)
	}
	slot, err := f.p.ledger.slot(current.Authorization)
	if err != nil {
		t.Fatal(err)
	}
	// The fixture advances the slot reference; no payload is deleted by this.
	slot.ID = ""
	slot.Pending = ""
	slot.Last = strings.Repeat("b", 64)
	collect := func() error {
		return f.p.ledger.withNamespace(t.Context(), func() error { return f.p.ledger.collectClosedLocked(t.Context(), &current, slot) })
	}
	if err := collect(); err != nil {
		t.Fatal(err)
	}
	current, err = f.p.ledger.read(id)
	if err != nil {
		t.Fatal(err)
	}
	f.f.now = current.CollectAfter
	fault := &servingCollectionFaultStore{Store: f.disk}
	fault.remove = func(name string) error {
		if err := f.disk.Remove(name); err != nil {
			return err
		}
		if name == "retirement-"+id+".json" {
			return unix.EIO
		}
		return nil
	}
	f.p.ledger.state = fault
	if err := collect(); !errors.Is(err, unix.EIO) {
		t.Fatal(err)
	}
	f.p.ledger.state = f.disk
	if err := f.p.ledger.maintainParks(t.Context(), func() error { return nil }); err != nil {
		t.Fatal(err)
	}
	for _, name := range []string{"current-retirement-" + id + ".json", servingRebootPreparationName(id, servingOtherBoot)} {
		if _, err := f.disk.Read(name); !errors.Is(err, os.ErrNotExist) {
			t.Fatal("reboot adjunct survived", name, err)
		}
	}
	if _, err := f.disk.Read("current-namespace.json"); err != nil {
		t.Fatal("collected namespace binding", err)
	}
}