package repository

import (
	"database/sql"
	"testing"

	"vidarchive/internal/config"
	"vidarchive/internal/database"
	"vidarchive/internal/models"
)

func setupTestDB(t *testing.T) *sql.DB {
	cfg := &config.Config{
		DBPath: ":memory:",
	}
	db, err := database.New(cfg)
	if err != nil {
		t.Fatalf("failed to create test db: %v", err)
	}
	return db
}

func TestPresetRepository(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	repo := NewPresetRepository(db)

	// Test Create
	preset := &models.Preset{
		Name:        "Test Preset",
		Description: "Test description",
		Format:      "best",
		Quality:     "1080",
	}
	if err := repo.Create(preset); err != nil {
		t.Fatalf("failed to create preset: %v", err)
	}
	if preset.ID == 0 {
		t.Error("expected preset ID to be set after create")
	}

	// Test GetByID
	found, err := repo.GetByID(preset.ID)
	if err != nil {
		t.Fatalf("failed to get preset by ID: %v", err)
	}
	if found.Name != "Test Preset" {
		t.Errorf("expected name 'Test Preset', got %q", found.Name)
	}

	// Test GetAll
	all, err := repo.GetAll()
	if err != nil {
		t.Fatalf("failed to get all presets: %v", err)
	}
	if len(all) < 1 {
		t.Errorf("expected at least 1 preset, got %d", len(all))
	}

	// Test Update
	preset.Name = "Updated Preset"
	if err := repo.Update(preset); err != nil {
		t.Fatalf("failed to update preset: %v", err)
	}
	updated, _ := repo.GetByID(preset.ID)
	if updated.Name != "Updated Preset" {
		t.Errorf("expected updated name 'Updated Preset', got %q", updated.Name)
	}

	// Test Delete
	if err := repo.Delete(preset.ID); err != nil {
		t.Fatalf("failed to delete preset: %v", err)
	}
	_, err = repo.GetByID(preset.ID)
	if err == nil {
		t.Error("expected error when getting deleted preset")
	}
}

func TestPresetRepositoryDefault(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	repo := NewPresetRepository(db)

	// Clear existing default from migration
	repo.ClearDefault()

	// Create default preset with unique name
	preset := &models.Preset{
		Name:      "TestDefault",
		IsDefault: true,
	}
	if err := repo.Create(preset); err != nil {
		t.Fatalf("failed to create preset: %v", err)
	}

	// Test GetDefault
	found, err := repo.GetDefault()
	if err != nil {
		t.Fatalf("failed to get default preset: %v", err)
	}
	if found.Name != "TestDefault" {
		t.Errorf("expected default preset name 'TestDefault', got %q", found.Name)
	}
	if !found.IsDefault {
		t.Error("expected preset to be default")
	}

	// Test ClearDefault
	if err := repo.ClearDefault(); err != nil {
		t.Fatalf("failed to clear default: %v", err)
	}
	_, err = repo.GetDefault()
	if err == nil {
		t.Error("expected no default preset after clearing")
	}
}

// Save must keep "default" exclusive within a single transaction: promoting a
// new default demotes the previous one, and there is never more than one.
func TestPresetRepositorySaveExclusiveDefault(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	repo := NewPresetRepository(db)
	if err := repo.ClearDefault(); err != nil { // drop the migration-seeded default
		t.Fatalf("clear default: %v", err)
	}

	a := &models.Preset{Name: "A", IsDefault: true}
	if err := repo.Save(a); err != nil {
		t.Fatalf("save A: %v", err)
	}
	if a.ID == 0 {
		t.Error("expected ID to be set by Save")
	}
	b := &models.Preset{Name: "B", IsDefault: true}
	if err := repo.Save(b); err != nil {
		t.Fatalf("save B: %v", err)
	}

	assertSoleDefault := func(want string) {
		t.Helper()
		def, err := repo.GetDefault()
		if err != nil {
			t.Fatalf("get default: %v", err)
		}
		if def.Name != want {
			t.Errorf("expected %q to be the default, got %q", want, def.Name)
		}
		all, err := repo.GetAll()
		if err != nil {
			t.Fatalf("get all: %v", err)
		}
		n := 0
		for _, p := range all {
			if p.IsDefault {
				n++
			}
		}
		if n != 1 {
			t.Errorf("expected exactly one default, got %d", n)
		}
	}

	// B was created as default last, so it wins.
	assertSoleDefault("B")

	// Updating A to default flips it back, still exclusively (a.ID is set, so Save
	// routes to an update).
	a.IsDefault = true
	if err := repo.Save(a); err != nil {
		t.Fatalf("save A update: %v", err)
	}
	assertSoleDefault("A")
}