package app

import (
	"bytes"
	"context"
	"errors"
	"path/filepath"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/narratio/internal/adapters/storage"
	"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
	"gitea.maximumdirect.net/eric/narratio/internal/config"
)

func TestExecuteRemoteSessionFallbackLoadsFromObjectStore(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot)
	fake := &storage.FakeBackend{}
	remoteKey := seedRemoteSessionConfig(t, fake, "2026-05-03", `session_id: "{{ session_id }}"
inputs:
  audio_s3:
    prefix: audio/
`)
	var storeInitCalls int
	restoreAppConfigTestGlobals(t, fake, &storeInitCalls, []string{filepath.Join(t.TempDir(), "session.yml")})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code != 0 {
		t.Fatalf("exit code = %d, want 0; stderr=%q", code, stderr.String())
	}
	if storeInitCalls != 1 {
		t.Fatalf("object store init calls = %d, want 1", storeInitCalls)
	}
	if !strings.Contains(stdout.String(), "narratio plan: workdir prepared") {
		t.Fatalf("stdout = %q, want plan output", stdout.String())
	}
	if _, ok := fake.Objects[remoteKey]; !ok {
		t.Fatalf("remote session key %q was not seeded", remoteKey)
	}
}

func TestExecuteExplicitLocalSessionPrecedenceSkipsRemote(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot)
	fake := &storage.FakeBackend{}
	var storeInitCalls int
	restoreAppConfigTestGlobals(t, fake, &storeInitCalls, []string{filepath.Join(t.TempDir(), "session.yml")})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session", sessionPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code != 0 {
		t.Fatalf("exit code = %d, want 0; stderr=%q", code, stderr.String())
	}
	if storeInitCalls != 0 {
		t.Fatalf("object store init calls = %d, want 0", storeInitCalls)
	}
}

func TestExecuteLocalSessionDiscoveryPrecedenceSkipsRemote(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot)
	fake := &storage.FakeBackend{}
	var storeInitCalls int
	restoreAppConfigTestGlobals(t, fake, &storeInitCalls, []string{sessionPath})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code != 0 {
		t.Fatalf("exit code = %d, want 0; stderr=%q", code, stderr.String())
	}
	if storeInitCalls != 0 {
		t.Fatalf("object store init calls = %d, want 0", storeInitCalls)
	}
}

func TestExecuteRemoteSessionMissingObjectFailsClearly(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot)
	fake := &storage.FakeBackend{}
	var storeInitCalls int
	missingSessionPath := filepath.Join(t.TempDir(), "session.yml")
	restoreAppConfigTestGlobals(t, fake, &storeInitCalls, []string{missingSessionPath})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code == 0 {
		t.Fatal("exit code = 0, want non-zero")
	}
	if !strings.Contains(stderr.String(), "remote session") || !strings.Contains(stderr.String(), "session.yml") || !strings.Contains(stderr.String(), "not found") {
		t.Fatalf("stderr = %q, want remote session not found context", stderr.String())
	}
	if !strings.Contains(stderr.String(), missingSessionPath) {
		t.Fatalf("stderr = %q, want local searched path", stderr.String())
	}
}

func TestExecuteRemoteSessionRequiresSessionID(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot)
	var storeInitCalls int
	restoreAppConfigTestGlobals(t, &storage.FakeBackend{}, &storeInitCalls, []string{filepath.Join(t.TempDir(), "session.yml")})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath}, &stdout, &stderr)
	if code == 0 {
		t.Fatal("exit code = 0, want non-zero")
	}
	if !strings.Contains(stderr.String(), "remote session loading requires --session-id") {
		t.Fatalf("stderr = %q, want session-id guidance", stderr.String())
	}
	if storeInitCalls != 0 {
		t.Fatalf("object store init calls = %d, want 0", storeInitCalls)
	}
}

func TestExecuteRemoteSessionStorageInitErrorFailsClearly(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot)
	origStoreFn := newObjectStoreFromConfigFn
	origSessionDefaults := append([]string(nil), config.DefaultSessionConfigSearchPaths...)
	config.DefaultSessionConfigSearchPaths = []string{filepath.Join(t.TempDir(), "session.yml")}
	newObjectStoreFromConfigFn = func(context.Context, *config.Config) (storage.ObjectStore, error) {
		return nil, errors.New("storage unavailable")
	}
	t.Cleanup(func() {
		newObjectStoreFromConfigFn = origStoreFn
		config.DefaultSessionConfigSearchPaths = origSessionDefaults
	})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code == 0 {
		t.Fatal("exit code = 0, want non-zero")
	}
	if !strings.Contains(stderr.String(), "storage unavailable") || !strings.Contains(stderr.String(), "remote session") {
		t.Fatalf("stderr = %q, want remote storage context", stderr.String())
	}
}

func TestExecuteRemoteSessionMalformedYAMLFailsStrictDecode(t *testing.T) {
	workspaceRoot := t.TempDir()
	pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot)
	fake := &storage.FakeBackend{}
	seedRemoteSessionConfig(t, fake, "2026-05-03", "session_id: 2026-05-03\nunknown: true\n")
	var storeInitCalls int
	restoreAppConfigTestGlobals(t, fake, &storeInitCalls, []string{filepath.Join(t.TempDir(), "session.yml")})

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	code := Execute([]string{"plan", "--config", pipelinePath, "--campaign", campaignPath, "--session-id", "2026-05-03"}, &stdout, &stderr)
	if code == 0 {
		t.Fatal("exit code = 0, want non-zero")
	}
	if !strings.Contains(stderr.String(), "strict decode failed") {
		t.Fatalf("stderr = %q, want strict decode context", stderr.String())
	}
}

func restoreAppConfigTestGlobals(t *testing.T, fake *storage.FakeBackend, storeInitCalls *int, sessionDefaults []string) {
	t.Helper()
	origStoreFn := newObjectStoreFromConfigFn
	origSessionDefaults := append([]string(nil), config.DefaultSessionConfigSearchPaths...)
	config.DefaultSessionConfigSearchPaths = append([]string(nil), sessionDefaults...)
	newObjectStoreFromConfigFn = func(context.Context, *config.Config) (storage.ObjectStore, error) {
		if storeInitCalls != nil {
			(*storeInitCalls)++
		}
		return fake, nil
	}
	t.Cleanup(func() {
		newObjectStoreFromConfigFn = origStoreFn
		config.DefaultSessionConfigSearchPaths = origSessionDefaults
	})
}

func seedRemoteSessionConfig(t *testing.T, fake *storage.FakeBackend, sessionID, content string) string {
	t.Helper()
	sessionPrefix := artifacts.S3SessionPrefix("dnd", "sample-campaign", sessionID)
	remoteKey := artifacts.S3SessionConfigKey(sessionPrefix)
	fake.SeedObject(storage.FakeObject{
		Key:  remoteKey,
		Data: []byte(content),
		ETag: "remote-session-etag",
	})
	return remoteKey
}