//go:build linux

package host

import (
	"context"
	"fmt"
	"github.com/carlosframework/platform/internal/hostbox"
	"github.com/carlosframework/platform/internal/hostguard"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func TestClaimKernelFindsDeletedDescriptor(t *testing.T) {
	d := t.TempDir()
	path := filepath.Join(d, "data.db")
	f, err := os.Create(path)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()
	id, err := stopIdentity(path)
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Remove(path); err != nil {
		t.Fatal(err)
	}
	proc := filepath.Join(d, "proc")
	if err := os.MkdirAll(filepath.Join(proc, "42", "fd"), 0700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(proc, "42", "stat"), []byte("42 (fixture) S "+strings.Repeat("0 ", 18)+"123 0"), 0600); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink(fmt.Sprintf("/proc/self/fd/%d", f.Fd()), filepath.Join(proc, "42", "fd", "3")); err != nil {
		t.Fatal(err)
	}
	if err := scanStopDescriptors(context.Background(), proc, []hostbox.StopFileIdentity{id}); err == nil || !strings.Contains(err.Error(), "database descriptor remains") {
		t.Fatalf("deleted descriptor evidence = %v", err)
	}
}
func TestClaimKernelRejectsIncompleteTree(t *testing.T) {
	d := t.TempDir()
	root := filepath.Join(d, "host")
	if err := os.Mkdir(root, 0700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(root, "cgroup.events"), []byte("populated 0\nfrozen 0\n"), 0600); err != nil {
		t.Fatal(err)
	}
	id, err := stopIdentity(root)
	if err != nil {
		t.Fatal(err)
	}
	groups := []hostbox.StopCgroupIdentity{{RelativePath: "host", Device: id.Device, Inode: id.Inode}}
	if _, err := scanStopCgroups(context.Background(), d, groups); err != nil {
		t.Fatal(err)
	}
	if err := os.Mkdir(filepath.Join(root, "unknown"), 0700); err != nil {
		t.Fatal(err)
	}
	if _, err := scanStopCgroups(context.Background(), d, groups); err == nil {
		t.Fatal("unknown child accepted")
	}
}

func TestClaimKernelFindsUnrecordedWALPath(t *testing.T) {
	proc := t.TempDir()
	if err := os.MkdirAll(filepath.Join(proc, "42", "fd"), 0700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(proc, "42", "stat"), []byte("42 (fixture) S "+strings.Repeat("0 ", 18)+"123 0"), 0600); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink("/owned/data.db-wal (deleted)", filepath.Join(proc, "42", "fd", "3")); err != nil {
		t.Fatal(err)
	}
	if err := scanStopDescriptors(context.Background(), proc, nil, []string{"/owned/data.db-wal"}); err == nil || !strings.Contains(err.Error(), "managed state descriptor remains") {
		t.Fatalf("unrecorded WAL = %v", err)
	}
}

type rebootJournalFixture struct{ j hostbox.StopKernelJournal }

func (j *rebootJournalFixture) ReadStopKernelJournal(context.Context, hostguard.FenceTarget) (hostbox.StopKernelJournal, error) {
	return j.j, nil
}
func (j *rebootJournalFixture) SettleRecovered(context.Context, hostguard.FenceTarget) error {
	j.j.Settled = true
	return nil
}
func TestClaimKernelPositiveRebootReconstructsEvidence(t *testing.T) {
	root, proc := t.TempDir(), t.TempDir()
	if err := os.MkdirAll(filepath.Join(proc, "sys/kernel/random"), 0700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(proc, "sys/kernel/random/boot_id"), []byte("new-boot\n"), 0600); err != nil {
		t.Fatal(err)
	}
	target := hostguard.FenceTarget{Host: "shop.example", Incarnation: "inc", Stamp: 11, Session: 13, Box: "box", Enrollment: "enroll", BootID: "old-boot", ControllerID: "old-controller", FenceID: "fence"}
	parent, err := claimContainmentParent("/sys/fs/cgroup/system.slice/carlos-edge.service", target)
	if err != nil {
		t.Fatal(err)
	}
	journal := &rebootJournalFixture{j: hostbox.StopKernelJournal{V: 1, Target: target, ControllerPID: 42, ProcessStart: "old-start", Cgroups: []hostbox.StopCgroupIdentity{{RelativePath: parent, Device: 1, Inode: 2}, {RelativePath: parent + "/role-main", Device: 1, Inode: 3, InvocationID: "main"}}}}
	kernel := LinuxStopKernel{AgentCgroup: func(context.Context) (string, error) { return "/sys/fs/cgroup/system.slice/carlos-edge.service", nil }, Journal: journal, CgroupRoot: root, ProcRoot: proc, ManagedRoots: map[string]string{"data": t.TempDir()}}
	inventory := StopInventory{Complete: true, Host: target.Host, Incarnation: target.Incarnation, InstallationStamp: target.Stamp}
	evidence, ack, err := kernel.recoverAfterReboot(t.Context(), target, inventory, journal.j, "new-boot", journal)
	if err != nil {
		t.Fatal(err)
	}
	if evidence.ObservedBootID != "new-boot" || ack.ControllerID != "old-controller" || !journal.j.Settled || len(evidence.CgroupIdentities) != 2 {
		t.Fatalf("bad reconstruction: %+v %+v", evidence, ack)
	}
	if _, _, err := kernel.recoverAfterReboot(t.Context(), target, inventory, journal.j, "old-boot", journal); err == nil {
		t.Fatal("same-boot absence accepted as reboot")
	}
	if _, err := scanStopCgroups(t.Context(), root, journal.j.Cgroups); err == nil {
		t.Fatal("same-boot missing containment accepted")
	}
	if err := os.MkdirAll(filepath.Join(root, parent), 0700); err != nil {
		t.Fatal(err)
	}
	if _, _, err := kernel.recoverAfterReboot(t.Context(), target, inventory, journal.j, "new-boot", journal); err == nil {
		t.Fatal("reused group path accepted")
	}
}