package main

import (
	"bytes"
	"context"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func TestSampleRunLifecycle_HP_CFG_01(t *testing.T) {
	t.Parallel()

	root := t.TempDir()
	var output bytes.Buffer
	h := &harness{root: root, now: func() time.Time { return time.Unix(1_700_000_000, 0).UTC() }, out: &output}
	current, err := h.create("sample-run", "integration", "sample")
	if err != nil {
		t.Fatalf("create: %v", err)
	}
	if current.Phase != "created" || current.ComposeProject != "rvbox-test-sample-run" {
		t.Fatalf("manifest = %+v", current)
	}
	if err := h.transition(current, "interrupted", "interrupt", "test"); err != nil {
		t.Fatal(err)
	}
	loaded, err := h.load("sample-run")
	if err != nil || loaded.Phase != "interrupted" {
		t.Fatalf("load = (%+v, %v)", loaded, err)
	}
	if err := h.collect(loaded); err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(filepath.Join(root, "sample-run", "artifacts", "report.json")); err != nil {
		t.Fatal(err)
	}
	if err := h.transition(loaded, "reset", "reset", "test"); err != nil {
		t.Fatal(err)
	}
	if err := h.purge(loaded); err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(filepath.Join(root, "sample-run")); !os.IsNotExist(err) {
		t.Fatalf("purged run still exists: %v", err)
	}
}

func TestRunIsolationAndManifestIdentity_HP_CFG_01(t *testing.T) {
	t.Parallel()

	h := &harness{root: t.TempDir(), now: time.Now, out: &bytes.Buffer{}}
	first, err := h.create("first-run", "integration", "sample")
	if err != nil {
		t.Fatal(err)
	}
	second, err := h.create("second-run", "integration", "sample")
	if err != nil {
		t.Fatal(err)
	}
	if err := h.purge(first); err != nil {
		t.Fatal(err)
	}
	if _, err := h.load(second.RunID); err != nil {
		t.Fatalf("unrelated run was affected: %v", err)
	}

	manifestPath := h.manifestPath(second.RunID)
	data, err := os.ReadFile(manifestPath)
	if err != nil {
		t.Fatal(err)
	}
	data = bytes.Replace(data, []byte(`repository_id = 'rvbox'`), []byte(`repository_id = 'other'`), 1)
	data = bytes.Replace(data, []byte(`repository_id = "rvbox"`), []byte(`repository_id = "other"`), 1)
	if err := os.WriteFile(manifestPath, data, 0o600); err != nil {
		t.Fatal(err)
	}
	if _, err := h.load(second.RunID); err == nil {
		t.Fatal("foreign manifest accepted")
	}
}

func TestRunIDTraversalAndSymlinkPurgeRejected_HP_CFG_01(t *testing.T) {
	t.Parallel()

	for _, value := range []string{"", "../escape", "/absolute", "UPPER", strings.Repeat("a", 65)} {
		if err := validateRunID(value); err == nil {
			t.Errorf("validateRunID(%q) succeeded", value)
		}
	}
	root := t.TempDir()
	h := &harness{root: root, now: time.Now, out: &bytes.Buffer{}}
	target := t.TempDir()
	if err := os.Symlink(target, filepath.Join(root, "linked-run")); err != nil {
		t.Fatal(err)
	}
	if err := h.purge(&manifest{RunID: "linked-run"}); err == nil {
		t.Fatal("symlink purge succeeded")
	}
}

func TestIntegrationResumeValidation_HP_CFG_01(t *testing.T) {
	t.Parallel()

	h := &harness{root: t.TempDir(), now: time.Now, out: &bytes.Buffer{}}
	if err := h.integration(context.Background(), []string{"--resume", "--suite", "sample"}); err == nil {
		t.Fatal("resume without run ID succeeded")
	}
	if err := h.integration(context.Background(), []string{"--suite", "unknown"}); err == nil {
		t.Fatal("unknown suite succeeded")
	}
}

func TestBoundedSuiteLogAndFailedRunRecovery_BH_STORE_03(t *testing.T) {
	t.Parallel()

	capture := &limitedCapture{limit: 4}
	if written, err := capture.Write([]byte("123456")); err != nil || written != 6 {
		t.Fatalf("Write = (%d, %v)", written, err)
	}
	if got := string(capture.Bytes()); !strings.HasPrefix(got, "1234\n") || !strings.Contains(got, "truncated") {
		t.Fatalf("bounded output = %q", got)
	}

	h := &harness{root: t.TempDir(), now: time.Now, out: &bytes.Buffer{}}
	current, err := h.create("failed-store", "integration", "store")
	if err != nil {
		t.Fatal(err)
	}
	if err := h.transition(current, "failed", "store-failed", "injected"); err != nil {
		t.Fatal(err)
	}
	if err := h.environmentCommand("recover", []string{"--run-id", current.RunID}); err != nil {
		t.Fatalf("recover failed run: %v", err)
	}
	loaded, err := h.load(current.RunID)
	if err != nil || loaded.Phase != "ready" {
		t.Fatalf("recovered run = (%+v, %v)", loaded, err)
	}
}

func TestCoverageInventoryReferencesExistingTests_HP_CFG_01(t *testing.T) {
	t.Parallel()

	if err := validateCoverageInventory(filepath.Join("..", "coverage.toml")); err != nil {
		t.Fatalf("validateCoverageInventory(): %v", err)
	}
}