//go:build linux && rootrunner

package host

import (
	"context"
	"github.com/carlosframework/platform/internal/hostbox"
	"github.com/carlosframework/platform/internal/hostguard"
	"github.com/carlosframework/platform/internal/release"
	"github.com/carlosframework/platform/internal/rootparticipation"
	"github.com/carlosframework/platform/internal/rootstate"
	"os/exec"
	"testing"
)

func lifecycleActivationDiagnostic(t *testing.T, ctx context.Context) {
	err := participationRelease.With(ctx, func(ctx context.Context) error {
		store, err := rootstate.Open(release.RootGenerationsDir, false, false)
		if err != nil {
			return err
		}
		defer store.Close()
		ledger := &release.RootGenerations{Store: store}
		rs, err := ledger.Reservations(ctx)
		t.Log("diagnostic reservations", len(rs), err)
		if err != nil {
			return err
		}
		inv, err := generationInventoryAt(ctx, rootparticipation.Namespace, "/var/lib/carlos-claims/authority/fences", "/var/lib/carlos-claims/journals.db")
		t.Log("diagnostic inventory", len(inv.Installations), len(inv.Launches), len(inv.Payloads), err)
		inv.Handovers, err = productionGenerationHandovers(ctx)
		t.Log("diagnostic handovers", len(inv.Handovers), err)
		inv.Retirements, err = productionGenerationRetirements(ctx)
		t.Log("diagnostic retirements", len(inv.Retirements), err)
		inv, err = generationLocalObligations(ctx, inv, productionGenerationCreation)
		t.Log("diagnostic obligations", err)
		_, err = productionGenerationRegistryInventory(ctx, inv)
		t.Log("diagnostic registry", err)
		if err != nil {
			t.Logf("registry snapshot: %+v", inv)
		}
		lifecycleInventoryDiagnostic(t, ctx, inv, rs)
		v := generationReconciler{read: productionLocalGenerationInventory, kernel: productionGenerationKernelCensus}
		_, err = v.reconcile(ctx, rs)
		return err
	})
	t.Log("diagnostic certificate", err)
}

func lifecycleInventoryDiagnostic(t *testing.T, ctx context.Context, inv generationInventory, rs []release.GenerationReservation) {
	physical, err := generationPhysicalPayloads(ctx, inv)
	t.Log("physical payload map", err)
	if err == nil {
		for _, p := range physical {
			t.Log("physical payload", p.Inventory.Host, p.Inventory.InstallationStamp, generationPayloadFiles(ctx, dataDir(), []hostbox.GenerationPayload{p}))
		}
	}
	boot, k, err := productionGenerationKernelCensus(context.WithValue(ctx, generationCensusReservationsKey{}, rs))
	t.Log("kernel census", boot, k, err)
	for _, v := range inv.Installations {
		t.Logf("installation %+v", v)
	}
	for _, r := range rs {
		t.Logf("reservation %+v", r)
	}
}

func lifecycleRetirementDiagnostic(t *testing.T, ctx context.Context, g *release.RootGenerations) {
	records, err := g.Reservations(ctx)
	t.Log("retirement records", err)
	ctx = context.WithValue(ctx, generationCensusReservationsKey{}, records)
	out, lockErr := exec.Command("lslocks", "--json", "--output", "PID,COMMAND,TYPE,PATH").CombinedOutput()
	t.Logf("retirement locks: %s %v", out, lockErr)
	s, err := rootstate.Open("/var/lib/carlos-claims/authority/fences", false, false)
	if err != nil {
		t.Log(err)
		return
	}
	defer s.Close()
	j, err := openGenerationLaunchInventory("/var/lib/carlos-claims/journals.db")
	if err != nil {
		t.Log(err)
		return
	}
	defer j.Close()
	v := generationRetirement{guard: hostguard.Guard{Root: hostguard.NewRootAuthority(s)}, journal: j, kernel: productionGenerationAbsence}
	for _, r := range records {
		t.Log("retirement ledger", r.Binding.Target.Host, r.Binding.Target.Stamp, r.Closed, r.Retirement)
		closed, e := v.closure(ctx, r)
		t.Log("retirement closure", r.Binding.Target.Host, r.Binding.Target.Stamp, closed, e)
		view, e := v.guard.Root.View(ctx, r.Binding.Target.Host, hostguard.Captured{Incarnation: r.Binding.Target.Incarnation, Stamp: r.Binding.Target.Stamp})
		if e == nil && closed {
			_, e = productionRetiredGenerationAbsence(ctx, r, view)
			t.Log("retirement absence", r.Binding.Target.Host, r.Binding.Target.Stamp, e)
			t.Log("retirement replacement", (generationKernel{proc: "/proc", cgroups: "/sys/fs/cgroup", contained: records}).replacedGroup(ctx, r))
		}
	}
}