package main

// main_test.go — run() wiring: flag errors, missing token, db dir creation,
// listen, graceful SIGTERM shutdown.

import (
	"fmt"
	"net"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"syscall"
	"testing"
	"time"
)

func freeTestAddr(t *testing.T) string {
	t.Helper()
	ls, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("probe listener: %v", err)
	}
	defer ls.Close()
	return fmt.Sprintf("127.0.0.1:%d", ls.Addr().(*net.TCPAddr).Port)
}

func TestRunFlagError(t *testing.T) {
	if err := run([]string{"--nope"}); err == nil {
		t.Fatal("unknown flag must error")
	}
}

func TestRunRequiresToken(t *testing.T) {
	t.Setenv(envToken, "")
	if err := run(nil); err == nil || err.Error() != "LVMH_TOKEN must be set" {
		t.Fatalf("run without token = %v", err)
	}
}

func TestRunBadDBPath(t *testing.T) {
	t.Setenv(envToken, "s3cret")
	occupied := filepath.Join(t.TempDir(), "file.db")
	if err := os.WriteFile(occupied, nil, 0o644); err != nil {
		t.Fatalf("write: %v", err)
	}
	if err := run([]string{"--db", filepath.Join(occupied, "sub", "lvmh.db")}); err == nil {
		t.Fatal("run with db under a file must fail")
	}
}

func TestRunListenAndServeShutdown(t *testing.T) {
	addr := freeTestAddr(t)
	dir := t.TempDir()
	db := filepath.Join(dir, "nested", "lvmh.db")
	t.Setenv(envToken, "s3cret")
	t.Setenv(envDB, db)

	errCh := make(chan error, 1)
	go func() { errCh <- run([]string{"--addr", addr, "--webdist", filepath.Join(dir, "absent")}) }()

	// server comes up: /api answers 401 without a token
	deadline := time.Now().Add(5 * time.Second)
	responded := false
	for time.Now().Before(deadline) {
		if resp, err := http.Get("http://" + addr + "/api/sessions"); err == nil {
			resp.Body.Close()
			responded = resp.StatusCode == 401
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if !responded {
		t.Fatal("daemon never answered /api/sessions with 401")
	}
	if _, err := os.Stat(db); err != nil {
		t.Fatalf("db not created at %s: %v", db, err)
	}

	// SIGTERM → graceful shutdown, run returns nil
	if err := syscall.Kill(syscall.Getpid(), syscall.SIGTERM); err != nil {
		t.Fatalf("kill: %v", err)
	}
	select {
	case err := <-errCh:
		if err != nil {
			t.Fatalf("run returned %v, want nil", err)
		}
	case <-time.After(10 * time.Second):
		t.Fatal("run did not return after SIGTERM")
	}
}

func TestRunListenFailure(t *testing.T) {
	t.Setenv(envToken, "s3cret")
	ls, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("occupy listener: %v", err)
	}
	defer ls.Close()
	port := ls.Addr().(*net.TCPAddr).Port
	db := filepath.Join(t.TempDir(), "lvmh.db")
	done := make(chan error, 1)
	go func() { done <- run([]string{"--addr", fmt.Sprintf("127.0.0.1:%d", port), "--db", db}) }()
	select {
	case err := <-done:
		if err == nil || !strings.Contains(err.Error(), "listen") {
			t.Fatalf("run on occupied port = %v, want listen error", err)
		}
	case <-time.After(10 * time.Second):
		t.Fatal("run never returned on listen failure")
	}
}

func TestRunOpenStoreFailure(t *testing.T) {
	t.Setenv(envToken, "s3cret")
	// --db pointing at an existing directory: schema exec fails
	if err := run([]string{"--db", t.TempDir(), "--addr", "127.0.0.1:0"}); err == nil || !strings.Contains(err.Error(), "open store") {
		t.Fatalf("run with directory db = %v, want open store error", err)
	}
}