package database

import (
	"database/sql"
	"errors"
	"testing"
)

// insertTestArtist inserts a minimal artist_settings row for use in tests that need FK satisfaction.
func insertTestArtist(db *DB, id string) error {
	_, err := db.Conn().Exec(
		"INSERT OR IGNORE INTO artist_settings (id, name) VALUES (?, ?)",
		id, "Test Artist "+id,
	)
	return err
}

// TestGetExternalRelease_Found verifies retrieving an existing release.
func TestGetExternalRelease_Found(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	_, err = db.Conn().Exec(
		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored) VALUES (?, ?, ?, ?, ?, ?)",
		"rgid-1", "artist-1", "Test Album", "album", "2024-01-01", false,
	)
	if err != nil {
		t.Fatalf("insert: %v", err)
	}

	r, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}

	if r.RGID != "rgid-1" {
		t.Errorf("expected RGID 'rgid-1', got %q", r.RGID)
	}
	if r.ArtistID != "artist-1" {
		t.Errorf("expected ArtistID 'artist-1', got %q", r.ArtistID)
	}
	if r.Title != "Test Album" {
		t.Errorf("expected Title 'Test Album', got %q", r.Title)
	}
	if r.Type != "album" {
		t.Errorf("expected Type 'album', got %q", r.Type)
	}
	if r.ReleaseDate != "2024-01-01" {
		t.Errorf("expected ReleaseDate '2024-01-01', got %q", r.ReleaseDate)
	}
	if r.IsIgnored {
		t.Error("expected IsIgnored false")
	}
}

// TestGetExternalRelease_NotFound verifies that a missing release returns an error
// that wraps sql.ErrNoRows.
func TestGetExternalRelease_NotFound(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	_, err = GetExternalRelease(db, "nonexistent")
	if !errors.Is(err, sql.ErrNoRows) {
		t.Errorf("expected error wrapping sql.ErrNoRows, got %v", err)
	}
}

// TestSaveExternalRelease_Insert verifies inserting a new release.
func TestSaveExternalRelease_Insert(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "New Album",
		Type:        "album",
		ReleaseDate: "2024-06-15",
		IsIgnored:   false,
	}

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.Title != "New Album" {
		t.Errorf("expected Title 'New Album', got %q", got.Title)
	}
	if got.ReleaseDate != "2024-06-15" {
		t.Errorf("expected ReleaseDate '2024-06-15', got %q", got.ReleaseDate)
	}
}

// TestSaveExternalRelease_Update verifies that SaveExternalRelease replaces an existing row.
func TestSaveExternalRelease_Update(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}

	// Insert initial row.
	r1 := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "Original Title",
		Type:        "album",
		ReleaseDate: "2024-01-01",
		IsIgnored:   false,
	}
	if err := SaveExternalRelease(db, r1); err != nil {
		t.Fatalf("first SaveExternalRelease() error: %v", err)
	}

	// Update the row.
	r2 := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "Updated Title",
		Type:        "single",
		ReleaseDate: "2024-12-25",
		IsIgnored:   true,
	}
	if err := SaveExternalRelease(db, r2); err != nil {
		t.Fatalf("second SaveExternalRelease() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.Title != "Updated Title" {
		t.Errorf("expected Title 'Updated Title', got %q", got.Title)
	}
	if got.Type != "single" {
		t.Errorf("expected Type 'single', got %q", got.Type)
	}
	if got.ReleaseDate != "2024-12-25" {
		t.Errorf("expected ReleaseDate '2024-12-25', got %q", got.ReleaseDate)
	}
	if !got.IsIgnored {
		t.Error("expected IsIgnored true")
	}
}

// TestGetExternalReleasesByArtist_Empty verifies empty result for unknown artist.
func TestGetExternalReleasesByArtist_Empty(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	results, err := GetExternalReleasesByArtist(db, "unknown-artist")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 0 {
		t.Errorf("expected 0 results, got %d", len(results))
	}
}

// TestGetExternalReleasesByArtist_Populated verifies filtering by artist_id.
func TestGetExternalReleasesByArtist_Populated(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	releases := []ExternalRelease{
		{RGID: "rg1", ArtistID: "artist-a", Title: "Album A1", Type: "album", ReleaseDate: "2024-01-01"},
		{RGID: "rg2", ArtistID: "artist-a", Title: "Album A2", Type: "album", ReleaseDate: "2024-06-01"},
		{RGID: "rg3", ArtistID: "artist-b", Title: "Album B1", Type: "single", ReleaseDate: "2024-03-01"},
	}

	if err := insertTestArtist(db, "artist-a"); err != nil {
		t.Fatalf("insertTestArtist(artist-a): %v", err)
	}
	if err := insertTestArtist(db, "artist-b"); err != nil {
		t.Fatalf("insertTestArtist(artist-b): %v", err)
	}
	for _, r := range releases {
		if err := SaveExternalRelease(db, &r); err != nil {
			t.Fatalf("SaveExternalRelease(%s) error: %v", r.RGID, err)
		}
	}

	// Query for artist-a.
	results, err := GetExternalReleasesByArtist(db, "artist-a")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 2 {
		t.Fatalf("expected 2 results for artist-a, got %d", len(results))
	}

	// Verify all belong to artist-a.
	for _, r := range results {
		if r.ArtistID != "artist-a" {
			t.Errorf("expected ArtistID 'artist-a', got %q", r.ArtistID)
		}
	}

	// Query for artist-b.
	results, err = GetExternalReleasesByArtist(db, "artist-b")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 1 {
		t.Fatalf("expected 1 result for artist-b, got %d", len(results))
	}
	if results[0].Title != "Album B1" {
		t.Errorf("expected Title 'Album B1', got %q", results[0].Title)
	}
}

// TestGetIgnoredReleases_Empty verifies empty result when no ignored releases.
func TestGetIgnoredReleases_Empty(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	results, err := GetIgnoredReleases(db)
	if err != nil {
		t.Fatalf("GetIgnoredReleases() error: %v", err)
	}
	if len(results) != 0 {
		t.Errorf("expected 0 results, got %d", len(results))
	}
}

// TestGetIgnoredReleases_Populated verifies only ignored releases are returned.
func TestGetIgnoredReleases_Populated(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	releases := []ExternalRelease{
		{RGID: "rg1", ArtistID: "a1", Title: "Ignored Album", IsIgnored: true},
		{RGID: "rg2", ArtistID: "a1", Title: "Normal Album", IsIgnored: false},
		{RGID: "rg3", ArtistID: "a2", Title: "Another Ignored", IsIgnored: true},
	}

	if err := insertTestArtist(db, "a1"); err != nil {
		t.Fatalf("insertTestArtist(a1): %v", err)
	}
	if err := insertTestArtist(db, "a2"); err != nil {
		t.Fatalf("insertTestArtist(a2): %v", err)
	}
	for _, r := range releases {
		if err := SaveExternalRelease(db, &r); err != nil {
			t.Fatalf("SaveExternalRelease(%s) error: %v", r.RGID, err)
		}
	}

	results, err := GetIgnoredReleases(db)
	if err != nil {
		t.Fatalf("GetIgnoredReleases() error: %v", err)
	}
	if len(results) != 2 {
		t.Fatalf("expected 2 ignored releases, got %d", len(results))
	}

	// Verify all returned are ignored.
	for _, r := range results {
		if !r.IsIgnored {
			t.Errorf("expected IsIgnored=true for %s, got false", r.RGID)
		}
	}
}

// TestSetReleaseIgnored_SetTrue verifies setting is_ignored to true.
func TestSetReleaseIgnored_SetTrue(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:      "rgid-1",
		ArtistID:  "artist-1",
		Title:     "Test Album",
		IsIgnored: false,
	}
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	if err := SetReleaseIgnored(db, "rgid-1", true); err != nil {
		t.Fatalf("SetReleaseIgnored() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if !got.IsIgnored {
		t.Error("expected IsIgnored true after SetReleaseIgnored(true)")
	}
}

// TestSetReleaseIgnored_SetFalse verifies setting is_ignored back to false.
func TestSetReleaseIgnored_SetFalse(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:      "rgid-1",
		ArtistID:  "artist-1",
		Title:     "Test Album",
		IsIgnored: true,
	}
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	if err := SetReleaseIgnored(db, "rgid-1", false); err != nil {
		t.Fatalf("SetReleaseIgnored() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.IsIgnored {
		t.Error("expected IsIgnored false after SetReleaseIgnored(false)")
	}
}

// TestSetReleaseIgnored_NotFound verifies error for nonexistent RGID.
func TestSetReleaseIgnored_NotFound(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	err = SetReleaseIgnored(db, "nonexistent", true)
	if err == nil {
		t.Error("expected error for nonexistent RGID, got nil")
	}
}