package api

import (
	"encoding/json"
	"testing"
	"time"

	"github.com/ponzischeme89/memby/server/internal/sonarr"
)

func TestBuildSonarrRowIncludesScheduleAndAddedState(t *testing.T) {
	location := time.FixedZone("NZST", 12*60*60)
	air := time.Date(2026, 7, 27, 8, 0, 0, 0, time.UTC)
	added := time.Date(2026, 7, 27, 8, 12, 0, 0, time.UTC)
	row, err := buildSonarrRow([]sonarr.Episode{{
		ID:            42,
		SeriesID:      7,
		SeasonNumber:  2,
		EpisodeNumber: 4,
		Title:         "The Crossing",
		AirDateUTC:    &air,
		HasFile:       true,
		Monitored:     true,
		EpisodeFile:   &sonarr.EpisodeFile{DateAdded: &added},
		Series: sonarr.Series{
			ID:        7,
			Title:     "Northbound",
			Monitored: true,
			Images: []sonarr.Image{
				{CoverType: "poster"},
				{CoverType: "fanart"},
			},
		},
	}}, time.Date(2026, 7, 27, 21, 0, 0, 0, location), location, nil)
	if err != nil {
		t.Fatal(err)
	}
	if row.ID != "sonarr-airing-today" || row.Kind != "schedule" || len(row.Items) != 1 {
		t.Fatalf("unexpected row: %+v", row)
	}
	var item sonarrScheduleItem
	if err := json.Unmarshal(row.Items[0], &item); err != nil {
		t.Fatal(err)
	}
	if item.ID != "sonarr:7:42" || item.MembyEpisodeCode != "S02E04" {
		t.Fatalf("unexpected identity: %+v", item)
	}
	if item.MembyAvailability != "available" || item.MembyAvailabilityText != "Added at 8:12 PM" {
		t.Fatalf("unexpected availability: %+v", item)
	}
	if item.ImageTags["Primary"] == "" || len(item.BackdropImageTags) != 1 {
		t.Fatalf("artwork was not exposed: %+v", item)
	}
}

// Sonarr's calendar is asked with unmonitored=true, because the calendar page and the
// aired banners want the whole picture. The launcher row does not: a show nobody follows
// is never coming, so it has no business being announced as airing.
func TestBuildSonarrRowDropsUnmonitoredShows(t *testing.T) {
	location := time.UTC
	now := time.Date(2026, 7, 27, 8, 0, 0, 0, location)
	air := time.Date(2026, 7, 27, 20, 0, 0, 0, location)
	episode := func(id int, series sonarr.Series) sonarr.Episode {
		utc := air
		return sonarr.Episode{
			ID: id, SeriesID: series.ID, SeasonNumber: 1, EpisodeNumber: id,
			Title: "Episode", AirDateUTC: &utc, Monitored: true, Series: series,
		}
	}
	row, err := buildSonarrRow([]sonarr.Episode{
		episode(1, sonarr.Series{ID: 1, Title: "Followed", Monitored: true}),
		episode(2, sonarr.Series{ID: 2, Title: "Dropped"}),
		// No expanded series record is no evidence either way, so the card stays.
		episode(3, sonarr.Series{}),
	}, now, location, nil)
	if err != nil {
		t.Fatal(err)
	}
	ids := make([]string, 0, len(row.Items))
	for _, raw := range row.Items {
		var item sonarrScheduleItem
		if err := json.Unmarshal(raw, &item); err != nil {
			t.Fatal(err)
		}
		ids = append(ids, item.ID)
	}
	if len(ids) != 2 || ids[0] != "sonarr:1:1" || ids[1] != "sonarr:0:3" {
		t.Fatalf("unmonitored shows were not dropped: %v", ids)
	}
}

func TestBuildSonarrRowLinksTheEmbySeries(t *testing.T) {
	location := time.UTC
	now := time.Date(2026, 7, 27, 8, 0, 0, 0, location)
	air := time.Date(2026, 7, 27, 20, 0, 0, 0, location)
	index := seriesIndex{
		"northbound":      {ID: "emby-old"},
		"northbound|2024": {ID: "emby-2024", LogoTag: "northbound-logo"},
		"harbour":         {ID: "emby-harbour"},
	}
	episode := func(title string, year int) sonarr.Episode {
		utc := air
		return sonarr.Episode{
			ID: 1, SeriesID: 1, SeasonNumber: 1, EpisodeNumber: 1, AirDateUTC: &utc,
			Series: sonarr.Series{ID: 1, Title: title, Year: year, Monitored: true},
		}
	}
	cases := map[string]struct {
		episode sonarr.Episode
		want    string
	}{
		// The year decides between a remake and its original.
		"year qualified": {episode("Northbound", 2024), "emby-2024"},
		// Sonarr and Emby disagree about a year more often than about a name.
		"year mismatch falls back to the title": {episode("Northbound", 1999), "emby-old"},
		"punctuation and case are ignored":      {episode("Harbour!", 0), "emby-harbour"},
		"not in the library":                    {episode("Unimported", 2026), ""},
	}
	for name, testCase := range cases {
		t.Run(name, func(t *testing.T) {
			row, err := buildSonarrRow([]sonarr.Episode{testCase.episode}, now, location, index)
			if err != nil {
				t.Fatal(err)
			}
			var item sonarrScheduleItem
			if err := json.Unmarshal(row.Items[0], &item); err != nil {
				t.Fatal(err)
			}
			if item.MembySeriesItemID != testCase.want {
				t.Fatalf("series id = %q, want %q", item.MembySeriesItemID, testCase.want)
			}
		})
	}
}

func TestScheduleEpisodeEventNamesPremieresAndFinales(t *testing.T) {
	tests := []struct {
		name    string
		episode sonarr.Episode
		want    string
	}{
		{"season premiere", sonarr.Episode{SeasonNumber: 3, EpisodeNumber: 1}, "Season premiere"},
		{"season finale", sonarr.Episode{SeasonNumber: 3, EpisodeNumber: 8, FinaleType: "seasonFinale"}, "Season finale"},
		{"series finale", sonarr.Episode{SeasonNumber: 5, EpisodeNumber: 10, FinaleType: "seriesFinale"}, "Series finale"},
		{"Sonarr season value", sonarr.Episode{SeasonNumber: 3, EpisodeNumber: 8, FinaleType: "season"}, "Season finale"},
		{"mid-season finale", sonarr.Episode{SeasonNumber: 3, EpisodeNumber: 5, FinaleType: "midseason"}, "Mid-season finale"},
		{"ordinary episode", sonarr.Episode{SeasonNumber: 3, EpisodeNumber: 4}, ""},
		{"special", sonarr.Episode{SeasonNumber: 0, EpisodeNumber: 1}, ""},
	}
	for _, testCase := range tests {
		t.Run(testCase.name, func(t *testing.T) {
			if got := scheduleEpisodeEvent(testCase.episode); got != testCase.want {
				t.Fatalf("event = %q, want %q", got, testCase.want)
			}
		})
	}
}

func TestScheduleItemCarriesMatchedEmbyLogo(t *testing.T) {
	episode := sonarr.Episode{
		ID: 1, SeriesID: 7, SeasonNumber: 2, EpisodeNumber: 1,
		Series: sonarr.Series{ID: 7, Title: "Northbound", Year: 2024},
	}
	item := toSonarrScheduleItem(episode, time.Now(), time.UTC, seriesIndex{
		"northbound|2024": {ID: "emby-series", LogoTag: "logo-tag"},
	})
	if item.ParentLogoItemID != "emby-series" || item.ParentLogoImageTag != "logo-tag" {
		t.Fatalf("matched logo was not carried: %+v", item)
	}
}

func TestBuildPrerollScheduleSplitsTodayAndWeek(t *testing.T) {
	location := time.FixedZone("NZST", 12*60*60)
	now := time.Date(2026, 7, 28, 10, 0, 0, 0, location)
	today := time.Date(2026, 7, 28, 20, 30, 0, 0, location).UTC()
	thursday := time.Date(2026, 7, 30, 19, 0, 0, 0, location).UTC()
	schedule := buildPrerollSchedule([]sonarr.Episode{
		{
			ID: 14, SeriesID: 7, SeasonNumber: 1, EpisodeNumber: 4, Title: "Tonight",
			AirDateUTC: &today, Series: sonarr.Series{
				ID: 7, Title: "Northbound", Images: []sonarr.Image{{CoverType: "fanart"}},
			},
		},
		{
			SeasonNumber: 2, EpisodeNumber: 1, Title: "Later",
			AirDateUTC: &thursday, HasFile: true, Series: sonarr.Series{Title: "Harbour"},
		},
	}, now, location)

	if len(schedule.Today) != 1 || schedule.Today[0].Series != "Northbound" ||
		schedule.Today[0].Schedule != "8:30 PM" || schedule.Today[0].ItemID != "sonarr:7:14" ||
		schedule.Today[0].ImageType != "backdrop" {
		t.Fatalf("unexpected today schedule: %+v", schedule.Today)
	}
	if len(schedule.ThisWeek) != 1 || schedule.ThisWeek[0].EpisodeCode != "S02E01" ||
		schedule.ThisWeek[0].Availability != "Downloaded" {
		t.Fatalf("unexpected week schedule: %+v", schedule.ThisWeek)
	}
}

func TestBuildSonarrRowCoversFiveDaysAndUsesRelativeAirLabels(t *testing.T) {
	location := time.FixedZone("NZST", 12*60*60)
	now := time.Date(2026, 7, 29, 8, 0, 0, 0, location)
	episode := func(id int, air time.Time) sonarr.Episode {
		utc := air.UTC()
		return sonarr.Episode{
			ID: id, SeriesID: id, SeasonNumber: 1, EpisodeNumber: id,
			Title: "Episode", AirDateUTC: &utc,
			Series: sonarr.Series{ID: id, Title: "Show", Monitored: true},
		}
	}
	row, err := buildSonarrRow([]sonarr.Episode{
		// Sonarr's response order is not part of its contract. Deliberately put the
		// later episode first to ensure the row is authored chronologically.
		episode(3, time.Date(2026, 8, 2, 16, 0, 0, 0, location)),
		episode(2, time.Date(2026, 7, 30, 16, 0, 0, 0, location)),
		episode(1, time.Date(2026, 7, 29, 16, 0, 0, 0, location)),
		episode(4, time.Date(2026, 8, 3, 16, 0, 0, 0, location)),
	}, now, location, nil)
	if err != nil {
		t.Fatal(err)
	}
	if row.Title != "Shows airing in the next 5 days" || len(row.Items) != 3 {
		t.Fatalf("five-day row = %+v", row)
	}
	labels := make([]string, 0, len(row.Items))
	dayLabels := make([]string, 0, len(row.Items))
	for _, raw := range row.Items {
		var item sonarrScheduleItem
		if err := json.Unmarshal(raw, &item); err != nil {
			t.Fatal(err)
		}
		labels = append(labels, item.MembyAirLabel)
		dayLabels = append(dayLabels, item.MembyAirDayLabel)
	}
	want := []string{
		"In 8 hours (4:00 PM)",
		"Tomorrow: 4:00 PM",
		"Sunday: 4:00 PM",
	}
	for i := range want {
		if labels[i] != want[i] {
			t.Fatalf("labels = %#v, want %#v", labels, want)
		}
	}
	wantDays := []string{"Today", "Tomorrow", "Sunday"}
	for i := range wantDays {
		if dayLabels[i] != wantDays[i] {
			t.Fatalf("day labels = %#v, want %#v", dayLabels, wantDays)
		}
	}
}

func TestResolveNextAiringOnlyAnswersForContinuingShowsWithAFutureAiring(t *testing.T) {
	location := time.UTC
	now := time.Date(2026, 8, 26, 12, 0, 0, 0, location)
	tomorrow := now.AddDate(0, 0, 1)
	yesterday := now.AddDate(0, 0, -1)

	catalogue := []sonarr.Series{
		{Title: "Continuing Show", Status: "continuing", NextAiring: &tomorrow},
		{Title: "Ended Show", Status: "ended", NextAiring: &tomorrow},
		{Title: "Cancelled Show", Status: "cancelled", NextAiring: &tomorrow},
		{Title: "No Schedule Show", Status: "continuing", NextAiring: nil},
		{Title: "Already Aired Show", Status: "continuing", NextAiring: &yesterday},
	}

	if _, info, ok := resolveNextAiring(catalogue, "Continuing Show", now, location); !ok {
		t.Fatal("expected a continuing show with a future airing to resolve")
	} else if info.DayLabel != "Tomorrow" {
		t.Fatalf("day label = %q, want Tomorrow", info.DayLabel)
	}

	cases := []string{
		"Ended Show", "Cancelled Show", "No Schedule Show", "Already Aired Show", "Unknown Show",
	}
	for _, name := range cases {
		if _, _, ok := resolveNextAiring(catalogue, name, now, location); ok {
			t.Fatalf("%q should not have produced a next-airing answer", name)
		}
	}

	if _, _, ok := resolveNextAiring(catalogue, "  ", now, location); ok {
		t.Fatal("a blank series name should never resolve")
	}
}

func TestResolveNextAiringWordingMatchesTheScheduleRow(t *testing.T) {
	location := time.FixedZone("NZST", 12*60*60)
	now := time.Date(2026, 7, 27, 8, 0, 0, 0, location)
	air := now.Add(8 * time.Hour)
	catalogue := []sonarr.Series{
		{Title: "Northbound", Status: "continuing", NextAiring: &air},
	}

	_, info, ok := resolveNextAiring(catalogue, "Northbound", now, location)
	if !ok {
		t.Fatal("expected a resolved answer")
	}
	wantLabel := scheduleAirLabel(air, now, location)
	wantDayLabel := scheduleAirDayLabel(air, now, location)
	if info.Label != wantLabel || info.DayLabel != wantDayLabel {
		t.Fatalf("wording drifted from the schedule row: got %+v, want label=%q day=%q",
			info, wantLabel, wantDayLabel)
	}
}