package catalog

import (
	"context"
	"errors"
	"fmt"
	"slices"
	"strings"
	"time"

	"github.com/google/uuid"
)

type sectionSeed struct {
	Kind     string
	Title    string
	Subtitle string
	ItemIDs  []int
}

type Repository interface {
	Discover(ctx context.Context, params DiscoverParams) ([]DiscoverSection, error)
	SectionItems(ctx context.Context, kind string, limit int) ([]MediaItem, error)
	SearchMedia(ctx context.Context, params SearchParams) ([]MediaItem, error)
	ListWatchLater(ctx context.Context, userID uuid.UUID) ([]MediaItem, error)
	AddWatchLater(ctx context.Context, userID uuid.UUID, mediaID int) error
	RemoveWatchLater(ctx context.Context, userID uuid.UUID, mediaID int) error
	ListContinueWatching(ctx context.Context, userID uuid.UUID, limit int) ([]ContinueWatchingItem, error)
	UpsertProgress(ctx context.Context, userID uuid.UUID, input ProgressUpdateInput) error
}

type GameLookup interface {
	SearchGames(ctx context.Context, query string, limit int) ([]MediaItem, error)
}

var (
	ErrInvalidInput  = errors.New("invalid input")
	ErrMediaNotFound = errors.New("media not found")
)

type Service struct {
	repo             Repository
	gameLookup       GameLookup
	media            map[int]MediaItem
	allMedia         []MediaItem
	sections         []sectionSeed
	dashboard        DashboardPayload
	continueWatching []ContinueWatchingItem
}

func NewService(repo ...Repository) *Service {
	var selected Repository
	if len(repo) > 0 {
		selected = repo[0]
	}

	allMedia := []MediaItem{
		newMedia(1, MediaProviderTMDB, 10001, "Neon Divide", MediaTypeMovie, []string{"Sci-Fi", "Thriller"}, nil, "2025-05-14", 8.5, 118),
		newMedia(2, MediaProviderTMDB, 10002, "Last Light Harbor", MediaTypeShow, []string{"Drama", "Mystery"}, nil, "2024-09-02", 8.1, 52),
		newMedia(3, MediaProviderTMDB, 10003, "Orbitline", MediaTypeMovie, []string{"Sci-Fi", "Adventure"}, nil, "2025-02-21", 7.9, 131),
		newMedia(4, MediaProviderTMDB, 10004, "Static Bloom", MediaTypeShow, []string{"Comedy", "Drama"}, nil, "2023-11-12", 7.8, 42),
		newMedia(5, MediaProviderTMDB, 10005, "Kingdom Ash", MediaTypeMovie, []string{"Fantasy", "Action"}, nil, "2024-12-08", 8.7, 143),
		newMedia(6, MediaProviderTMDB, 10006, "Pulse District", MediaTypeShow, []string{"Crime", "Thriller"}, nil, "2025-03-18", 8.0, 48),
		newMedia(7, MediaProviderTMDB, 10007, "The Glass Relay", MediaTypeMovie, []string{"Action", "Thriller"}, nil, "2024-07-01", 7.6, 109),
		newMedia(8, MediaProviderTMDB, 10008, "Summer in Vanta", MediaTypeShow, []string{"Romance", "Drama"}, nil, "2025-06-30", 7.5, 44),
		newMedia(9, MediaProviderTMDB, 10009, "Zero Meridian", MediaTypeMovie, []string{"Sci-Fi", "Action"}, nil, "2026-01-10", 8.9, 127),
		newMedia(10, MediaProviderTMDB, 10010, "Northline 13", MediaTypeShow, []string{"Mystery", "Crime"}, nil, "2025-10-19", 8.3, 50),
		newMedia(11, MediaProviderTMDB, 10011, "Paper Falcons", MediaTypeMovie, []string{"Adventure", "Family"}, nil, "2024-03-05", 7.4, 101),
		newMedia(12, MediaProviderTMDB, 10012, "Hollow Anthem", MediaTypeMovie, []string{"Drama", "Music"}, nil, "2025-08-22", 8.2, 114),
		newMedia(13, MediaProviderTMDB, 10013, "Riptide Avenue", MediaTypeShow, []string{"Action", "Drama"}, nil, "2023-04-09", 7.7, 55),
		newMedia(14, MediaProviderTMDB, 10014, "Night Air Index", MediaTypeMovie, []string{"Mystery", "Thriller"}, nil, "2026-04-03", 8.4, 122),
		newMedia(15, MediaProviderTMDB, 10015, "Shoreline Math", MediaTypeShow, []string{"Comedy", "Family"}, nil, "2024-06-17", 7.3, 37),
		newMedia(16, MediaProviderTMDB, 10016, "Arcadia Wire", MediaTypeMovie, []string{"Fantasy", "Drama"}, nil, "2025-12-02", 8.6, 136),
		newMedia(17, MediaProviderTMDB, 10017, "Abyss Echo", MediaTypeShow, []string{"Sci-Fi", "Mystery"}, nil, "2025-01-27", 8.8, 53),
		newMedia(18, MediaProviderTMDB, 10018, "Delta Murmur", MediaTypeMovie, []string{"Horror", "Thriller"}, nil, "2024-10-29", 7.2, 96),
		newMedia(19, MediaProviderTMDB, 10019, "Pine Weather", MediaTypeShow, []string{"Drama", "Romance"}, nil, "2025-04-11", 7.9, 46),
		newMedia(20, MediaProviderTMDB, 10020, "Copper Atlas", MediaTypeMovie, []string{"Adventure", "Action"}, nil, "2025-09-09", 8.0, 111),
		newMedia(21, MediaProviderTMDB, 10021, "Moonset Terminal", MediaTypeMovie, []string{"Sci-Fi", "Drama"}, nil, "2026-02-14", 8.4, 124),
		newMedia(22, MediaProviderTMDB, 10022, "Marble Sea", MediaTypeShow, []string{"Fantasy", "Adventure"}, nil, "2024-01-22", 7.6, 49),
		newMedia(23, MediaProviderTMDB, 10023, "Tangent Room", MediaTypeMovie, []string{"Mystery", "Drama"}, nil, "2025-11-03", 8.1, 119),
		newMedia(24, MediaProviderTMDB, 10024, "Signal Orchard", MediaTypeShow, []string{"Thriller", "Drama"}, nil, "2025-07-18", 8.2, 51),
		newMedia(25, MediaProviderIGDB, 20025, "Star Circuit Zero", MediaTypeGame, []string{"Action", "Racing"}, []string{"PC", "PS5", "Xbox Series X|S"}, "2026-09-18", 8.8, 900),
		newMedia(26, MediaProviderIGDB, 20026, "Verdant Protocol", MediaTypeGame, []string{"Strategy", "Simulation"}, []string{"PC"}, "2026-11-06", 8.4, 1260),
		newMedia(27, MediaProviderIGDB, 20027, "Mythic Drift", MediaTypeGame, []string{"Racing", "Adventure"}, []string{"PS5", "Xbox Series X|S"}, "2026-07-24", 8.2, 720),
		newMedia(28, MediaProviderIGDB, 20028, "Ashen Vale", MediaTypeGame, []string{"RPG", "Adventure"}, []string{"PC", "PS5"}, "2026-05-15", 9.0, 1680),
		newMedia(29, MediaProviderIGDB, 20029, "Signal Breaker", MediaTypeGame, []string{"Shooter", "Sci-Fi"}, []string{"PC", "Xbox Series X|S"}, "2026-02-28", 8.1, 840),
		newMedia(30, MediaProviderIGDB, 20030, "Luma Forge", MediaTypeGame, []string{"Indie", "Puzzle"}, []string{"Nintendo Switch", "PC"}, "2026-01-16", 8.3, 360),
		newMedia(31, MediaProviderIGDB, 20031, "Citadel Dawn", MediaTypeGame, []string{"Strategy", "RPG"}, []string{"PC"}, "2026-03-05", 8.6, 1500),
		newMedia(32, MediaProviderIGDB, 20032, "Harbor Tactics", MediaTypeGame, []string{"Strategy", "Simulation"}, []string{"PC"}, "2025-11-21", 7.8, 1080),
		newMedia(33, MediaProviderIGDB, 20033, "Ghostline Kyoto", MediaTypeGame, []string{"Action", "Adventure"}, []string{"PS5", "PC"}, "2026-02-14", 8.7, 1020),
		newMedia(34, MediaProviderIGDB, 20034, "Snowfall County", MediaTypeGame, []string{"Simulation", "Adventure"}, []string{"Nintendo Switch", "PC"}, "2025-12-12", 7.9, 540),
		newMedia(35, MediaProviderIGDB, 20035, "Titan Relay", MediaTypeGame, []string{"Shooter", "Action"}, []string{"PC", "PS5"}, "2026-04-22", 8.5, 780),
		newMedia(36, MediaProviderIGDB, 20036, "Wild Circuit Stories", MediaTypeGame, []string{"Racing", "Indie"}, []string{"Nintendo Switch", "Xbox Series X|S"}, "2026-08-07", 8.0, 420),
	}

	mediaByID := make(map[int]MediaItem, len(allMedia))
	for _, item := range allMedia {
		mediaByID[item.ID] = item
	}

	sections := []sectionSeed{
		{Kind: "trending", Title: "Trending", Subtitle: "Hot picks across screens and launchers", ItemIDs: []int{9, 25, 33, 21, 6, 17, 28, 23}},
		{Kind: "popular", Title: "Popular", Subtitle: "High-signal releases people keep returning to", ItemIDs: []int{1, 2, 33, 5, 28, 8, 10, 31}},
		{Kind: "top-rated", Title: "Top Rated", Subtitle: "Highest community ratings across all media", ItemIDs: []int{9, 17, 25, 5, 33, 16, 28, 21}},
		{Kind: "upcoming", Title: "Upcoming", Subtitle: "Near-term drops on your radar", ItemIDs: []int{21, 25, 26, 14, 27, 23, 35, 36}},
		{Kind: "now-playing", Title: "Now Playing", Subtitle: "Freshly added movies, episodes, and game launches", ItemIDs: []int{3, 6, 12, 29, 33, 30, 2, 17}},
		{Kind: "airing-today", Title: "Airing Today", Subtitle: "Episodes and drops available now", ItemIDs: []int{6, 10, 17, 19, 24, 22, 4, 15}},
		{Kind: "recently-released-games", Title: "Recently Released Games", Subtitle: "New launches worth checking this month", ItemIDs: []int{33, 31, 29, 30, 34, 32}},
		{Kind: "most-anticipated-games", Title: "Most Anticipated Games", Subtitle: "Upcoming releases with strong momentum", ItemIDs: []int{25, 26, 27, 28, 35, 36, 31, 29}},
		{Kind: "indie-highlights", Title: "Indie Highlights", Subtitle: "Smaller teams shipping sharper ideas", ItemIDs: []int{30, 36, 34, 32, 28, 26}},
	}

	dashboard := DashboardPayload{
		WatchLater:  mustPick(mediaByID, []int{25, 9, 14, 33, 21, 28}),
		GameBacklog: mustPick(mediaByID, []int{25, 33, 28, 31}),
		ActiveDownloads: []DownloadJob{
			{ID: "dl-1024", Title: "Zero Meridian (2160p HDR)", Status: "downloading", ProgressPercent: 47, DownloadSpeedMbps: 23.8, EtaMinutes: 19, SourceType: "magnet"},
			{ID: "dl-1025", Title: "Star Circuit Zero preload", Status: "queued", ProgressPercent: 0, DownloadSpeedMbps: 0, EtaMinutes: 34, SourceType: "http"},
			{ID: "dl-1026", Title: "Arcadia Wire (1080p)", Status: "stalled", ProgressPercent: 74, DownloadSpeedMbps: 0.2, EtaMinutes: 120, SourceType: "torrent"},
		},
		Recommendations: []RecommendationItem{
			{ID: 28, Reason: "Because your queue trends toward expansive fantasy worlds", Score: 93, Media: mustGet(mediaByID, 28)},
			{ID: 24, Reason: "Because you finish serial thrillers quickly", Score: 89, Media: mustGet(mediaByID, 24)},
			{ID: 33, Reason: "Because cinematic action games align with your recent picks", Score: 91, Media: mustGet(mediaByID, 33)},
			{ID: 1, Reason: "Because your recent watches trend sci-fi", Score: 88, Media: mustGet(mediaByID, 1)},
		},
		Trending:        mustPick(mediaByID, []int{9, 25, 33, 21, 16, 14}),
		Upcoming:        mustPick(mediaByID, []int{21, 25, 26, 14, 35}),
		RecentlyWatched: mustPick(mediaByID, []int{2, 6, 17, 33, 29}),
	}

	continueWatching := []ContinueWatchingItem{
		{Item: mustGet(mediaByID, 2), Progress: EpisodeProgress{ItemID: 2, SeasonNumber: 1, EpisodeNumber: 7, ProgressPercent: 63, LastWatchedAt: "2026-03-09T21:40:00Z"}},
		{Item: mustGet(mediaByID, 17), Progress: EpisodeProgress{ItemID: 17, SeasonNumber: 2, EpisodeNumber: 2, ProgressPercent: 28, LastWatchedAt: "2026-03-08T23:16:00Z"}},
		{Item: mustGet(mediaByID, 6), Progress: EpisodeProgress{ItemID: 6, SeasonNumber: 1, EpisodeNumber: 11, ProgressPercent: 82, LastWatchedAt: "2026-03-07T18:10:00Z"}},
	}

	return &Service{
		repo:             selected,
		media:            mediaByID,
		allMedia:         slices.Clone(allMedia),
		sections:         slices.Clone(sections),
		dashboard:        dashboard,
		continueWatching: slices.Clone(continueWatching),
	}
}

func (s *Service) SetGameLookup(lookup GameLookup) {
	s.gameLookup = lookup
}

func (s *Service) Dashboard() DashboardPayload {
	if s.repo != nil {
		ctx := context.Background()

		watchLater, err := s.repo.SectionItems(ctx, "top-rated", 5)
		if err == nil {
			gameBacklog, gameBacklogErr := s.repo.SectionItems(ctx, "most-anticipated-games", 4)
			trending, trendingErr := s.repo.SectionItems(ctx, "trending", 6)
			upcoming, upcomingErr := s.repo.SectionItems(ctx, "upcoming", 5)
			recentlyWatched, recentlyErr := s.repo.SectionItems(ctx, "now-playing", 5)

			if gameBacklogErr == nil && trendingErr == nil && upcomingErr == nil && recentlyErr == nil {
				payload := DashboardPayload{
					WatchLater:      cloneMediaItems(watchLater),
					GameBacklog:     cloneMediaItems(gameBacklog),
					ActiveDownloads: slices.Clone(s.dashboard.ActiveDownloads),
					Recommendations: slices.Clone(s.dashboard.Recommendations),
					Trending:        cloneMediaItems(trending),
					Upcoming:        cloneMediaItems(upcoming),
					RecentlyWatched: cloneMediaItems(recentlyWatched),
				}
				return payload
			}
		}
	}

	return DashboardPayload{
		WatchLater:      slices.Clone(s.dashboard.WatchLater),
		GameBacklog:     slices.Clone(s.dashboard.GameBacklog),
		ActiveDownloads: slices.Clone(s.dashboard.ActiveDownloads),
		Recommendations: slices.Clone(s.dashboard.Recommendations),
		Trending:        slices.Clone(s.dashboard.Trending),
		Upcoming:        slices.Clone(s.dashboard.Upcoming),
		RecentlyWatched: slices.Clone(s.dashboard.RecentlyWatched),
	}
}

func (s *Service) WatchLater(userID uuid.UUID) ([]MediaItem, error) {
	if userID == uuid.Nil {
		return nil, ErrInvalidInput
	}

	if s.repo != nil {
		items, err := s.repo.ListWatchLater(context.Background(), userID)
		if err == nil {
			return cloneMediaItems(items), nil
		}
	}

	return cloneMediaItems(s.dashboard.WatchLater), nil
}

func (s *Service) AddWatchLater(userID uuid.UUID, mediaID int) ([]MediaItem, error) {
	if userID == uuid.Nil || mediaID < 1 {
		return nil, ErrInvalidInput
	}

	if s.repo != nil {
		if err := s.repo.AddWatchLater(context.Background(), userID, mediaID); err != nil {
			if errors.Is(err, ErrMediaNotFound) {
				return nil, ErrMediaNotFound
			}

			return nil, err
		}

		items, err := s.repo.ListWatchLater(context.Background(), userID)
		if err != nil {
			return nil, err
		}
		return cloneMediaItems(items), nil
	}

	updated, err := addToWatchLater(s.dashboard.WatchLater, s.media, mediaID)
	if err != nil {
		return nil, err
	}
	s.dashboard.WatchLater = updated
	return cloneMediaItems(s.dashboard.WatchLater), nil
}

func (s *Service) RemoveWatchLater(userID uuid.UUID, mediaID int) ([]MediaItem, error) {
	if userID == uuid.Nil || mediaID < 1 {
		return nil, ErrInvalidInput
	}

	if s.repo != nil {
		if err := s.repo.RemoveWatchLater(context.Background(), userID, mediaID); err != nil {
			return nil, err
		}

		items, err := s.repo.ListWatchLater(context.Background(), userID)
		if err != nil {
			return nil, err
		}
		return cloneMediaItems(items), nil
	}

	s.dashboard.WatchLater = removeFromWatchLater(s.dashboard.WatchLater, mediaID)
	return cloneMediaItems(s.dashboard.WatchLater), nil
}

func (s *Service) ContinueWatching(userID uuid.UUID) ([]ContinueWatchingItem, error) {
	if userID == uuid.Nil {
		return nil, ErrInvalidInput
	}

	if s.repo != nil {
		items, err := s.repo.ListContinueWatching(context.Background(), userID, 12)
		if err != nil {
			return nil, err
		}
		return cloneContinueWatching(items), nil
	}

	return cloneContinueWatching(s.continueWatching), nil
}

func (s *Service) UpdateProgress(userID uuid.UUID, input ProgressUpdateInput) ([]ContinueWatchingItem, error) {
	if userID == uuid.Nil || input.MediaID < 1 {
		return nil, ErrInvalidInput
	}

	normalized := normalizeProgressInput(input)
	if normalized.ProgressPercent < 0 || normalized.ProgressPercent > 100 {
		return nil, ErrInvalidInput
	}

	if s.repo != nil {
		if err := s.repo.UpsertProgress(context.Background(), userID, normalized); err != nil {
			if errors.Is(err, ErrMediaNotFound) {
				return nil, ErrMediaNotFound
			}
			return nil, err
		}

		items, err := s.repo.ListContinueWatching(context.Background(), userID, 12)
		if err != nil {
			return nil, err
		}
		return cloneContinueWatching(items), nil
	}

	updated, err := upsertContinueWatchingInMemory(s.continueWatching, s.media, normalized)
	if err != nil {
		return nil, err
	}

	s.continueWatching = updated
	return cloneContinueWatching(s.continueWatching), nil
}

func (s *Service) Discover(params DiscoverParams) []DiscoverSection {
	sanitized := sanitizeDiscoverParams(params)

	if s.repo != nil {
		sections, err := s.repo.Discover(context.Background(), sanitized)
		if err == nil {
			return withGenreInSectionTitle(sections, sanitized.Genre)
		}
	}

	sections := make([]DiscoverSection, 0, len(s.sections))

	for _, section := range s.sections {
		candidates := mustPick(s.media, section.ItemIDs)
		filtered := filterMedia(candidates, sanitized.Query, sanitized.Genre, sanitized.MediaType)
		paged := page(filtered, sanitized.Page, sanitized.PageSize)
		if len(paged) == 0 {
			continue
		}

		title := section.Title
		if sanitized.Genre != "" {
			title = fmt.Sprintf("%s · %s", title, sanitized.Genre)
		}

		sections = append(sections, DiscoverSection{
			Kind:     section.Kind,
			Title:    title,
			Subtitle: section.Subtitle,
			Items:    paged,
		})
	}

	return sections
}

func (s *Service) Search(params SearchParams) []SearchResult {
	query := strings.TrimSpace(strings.ToLower(params.Query))
	if query == "" {
		return []SearchResult{}
	}

	if s.repo != nil {
		filtered, err := s.repo.SearchMedia(context.Background(), params)
		if err == nil {
			return buildSearchResults(filtered, query)
		}
	}

	filtered := filterMedia(s.allMedia, query, strings.TrimSpace(params.Genre), strings.TrimSpace(params.MediaType))
	if s.gameLookup != nil && shouldIncludeGameLookup(params.MediaType) {
		remote, err := s.gameLookup.SearchGames(context.Background(), params.Query, 12)
		if err == nil {
			filtered = mergeMediaItems(
				filtered,
				filterMedia(remote, query, strings.TrimSpace(params.Genre), string(MediaTypeGame)),
			)
		}
	}

	return buildSearchResults(filtered, query)
}

func buildSearchResults(items []MediaItem, query string) []SearchResult {
	results := make([]SearchResult, 0, len(items))
	for _, item := range items {
		subtitle := fmt.Sprintf("%s · %s", strings.Join(item.Genres, " • "), releaseYear(item.ReleaseDate))
		if item.Type == MediaTypeGame && len(item.Platforms) > 0 {
			subtitle = fmt.Sprintf("%s · %s · %s", strings.Join(item.Genres, " • "), strings.Join(item.Platforms, " • "), releaseYear(item.ReleaseDate))
		}

		results = append(results, SearchResult{
			ID:        item.ID,
			MediaType: string(item.Type),
			Title:     item.Title,
			Subtitle:  subtitle,
			Genres:    slices.Clone(item.Genres),
			Score:     score(item.Title, query, item.Rating),
		})
	}

	slices.SortFunc(results, func(left SearchResult, right SearchResult) int {
		return right.Score - left.Score
	})

	if len(results) > 12 {
		return slices.Clone(results[:12])
	}

	return results
}

func releaseYear(releaseDate string) string {
	if len(releaseDate) >= 4 {
		return releaseDate[:4]
	}

	return releaseDate
}

func shouldIncludeGameLookup(mediaType string) bool {
	cleanType := strings.ToLower(strings.TrimSpace(mediaType))
	return cleanType == "" || cleanType == "all" || cleanType == string(MediaTypeGame)
}

func mergeMediaItems(existing []MediaItem, incoming []MediaItem) []MediaItem {
	if len(incoming) == 0 {
		return existing
	}

	seen := make(map[string]struct{}, len(existing)+len(incoming))
	merged := make([]MediaItem, 0, len(existing)+len(incoming))

	for _, item := range existing {
		key := fmt.Sprintf("%s:%d", item.Provider, item.ProviderID)
		seen[key] = struct{}{}
		merged = append(merged, item)
	}

	for _, item := range incoming {
		key := fmt.Sprintf("%s:%d", item.Provider, item.ProviderID)
		if _, exists := seen[key]; exists {
			continue
		}

		seen[key] = struct{}{}
		merged = append(merged, item)
	}

	return merged
}

func withGenreInSectionTitle(sections []DiscoverSection, genre string) []DiscoverSection {
	cleanGenre := strings.TrimSpace(genre)
	if cleanGenre == "" {
		return sections
	}

	updated := make([]DiscoverSection, 0, len(sections))
	for _, section := range sections {
		updated = append(updated, DiscoverSection{
			Kind:     section.Kind,
			Title:    fmt.Sprintf("%s · %s", section.Title, cleanGenre),
			Subtitle: section.Subtitle,
			Items:    cloneMediaItems(section.Items),
		})
	}

	return updated
}

func cloneMediaItems(items []MediaItem) []MediaItem {
	if len(items) == 0 {
		return []MediaItem{}
	}

	cloned := make([]MediaItem, 0, len(items))
	for _, item := range items {
		cloned = append(cloned, MediaItem{
			ID:             item.ID,
			Provider:       item.Provider,
			ProviderID:     item.ProviderID,
			Title:          item.Title,
			Overview:       item.Overview,
			Type:           item.Type,
			ReleaseDate:    item.ReleaseDate,
			Genres:         cloneStringSlice(item.Genres),
			Platforms:      cloneStringSlice(item.Platforms),
			Rating:         item.Rating,
			RuntimeMinutes: item.RuntimeMinutes,
			ArtworkKey:     item.ArtworkKey,
		})
	}

	return cloned
}

func cloneContinueWatching(items []ContinueWatchingItem) []ContinueWatchingItem {
	if len(items) == 0 {
		return []ContinueWatchingItem{}
	}

	cloned := make([]ContinueWatchingItem, 0, len(items))
	for _, item := range items {
		cloned = append(cloned, ContinueWatchingItem{
			Item: MediaItem{
				ID:             item.Item.ID,
				Provider:       item.Item.Provider,
				ProviderID:     item.Item.ProviderID,
				Title:          item.Item.Title,
				Overview:       item.Item.Overview,
				Type:           item.Item.Type,
				ReleaseDate:    item.Item.ReleaseDate,
				Genres:         cloneStringSlice(item.Item.Genres),
				Platforms:      cloneStringSlice(item.Item.Platforms),
				Rating:         item.Item.Rating,
				RuntimeMinutes: item.Item.RuntimeMinutes,
				ArtworkKey:     item.Item.ArtworkKey,
			},
			Progress: EpisodeProgress{
				ItemID:          item.Progress.ItemID,
				SeasonNumber:    item.Progress.SeasonNumber,
				EpisodeNumber:   item.Progress.EpisodeNumber,
				ProgressPercent: item.Progress.ProgressPercent,
				LastWatchedAt:   item.Progress.LastWatchedAt,
			},
		})
	}

	return cloned
}

func normalizeProgressInput(input ProgressUpdateInput) ProgressUpdateInput {
	season := input.SeasonNumber
	if season < 1 {
		season = 1
	}

	episode := input.EpisodeNumber
	if episode < 1 {
		episode = 1
	}

	return ProgressUpdateInput{
		MediaID:         input.MediaID,
		SeasonNumber:    season,
		EpisodeNumber:   episode,
		ProgressPercent: input.ProgressPercent,
	}
}

func upsertContinueWatchingInMemory(
	existing []ContinueWatchingItem,
	catalogMap map[int]MediaItem,
	input ProgressUpdateInput,
) ([]ContinueWatchingItem, error) {
	next := make([]ContinueWatchingItem, 0, len(existing)+1)

	for _, entry := range existing {
		if entry.Item.ID == input.MediaID &&
			entry.Progress.SeasonNumber == input.SeasonNumber &&
			entry.Progress.EpisodeNumber == input.EpisodeNumber {
			continue
		}

		next = append(next, entry)
	}

	if input.ProgressPercent <= 0 || input.ProgressPercent >= 100 {
		return next, nil
	}

	media, ok := catalogMap[input.MediaID]
	if !ok {
		return nil, ErrMediaNotFound
	}

	newEntry := ContinueWatchingItem{
		Item: media,
		Progress: EpisodeProgress{
			ItemID:          input.MediaID,
			SeasonNumber:    input.SeasonNumber,
			EpisodeNumber:   input.EpisodeNumber,
			ProgressPercent: input.ProgressPercent,
			LastWatchedAt:   time.Now().UTC().Format(time.RFC3339),
		},
	}

	next = append([]ContinueWatchingItem{newEntry}, next...)
	if len(next) > 12 {
		return next[:12], nil
	}

	return next, nil
}

func addToWatchLater(existing []MediaItem, catalogMap map[int]MediaItem, mediaID int) ([]MediaItem, error) {
	for _, item := range existing {
		if item.ID == mediaID {
			return existing, nil
		}
	}

	media, ok := catalogMap[mediaID]
	if !ok {
		return nil, ErrMediaNotFound
	}

	next := make([]MediaItem, 0, len(existing)+1)
	next = append(next, media)
	next = append(next, cloneMediaItems(existing)...)
	return next, nil
}

func removeFromWatchLater(existing []MediaItem, mediaID int) []MediaItem {
	next := make([]MediaItem, 0, len(existing))
	for _, item := range existing {
		if item.ID == mediaID {
			continue
		}
		next = append(next, item)
	}

	return next
}

func sanitizeDiscoverParams(params DiscoverParams) DiscoverParams {
	page := params.Page
	if page < 1 {
		page = 1
	}

	pageSize := params.PageSize
	if pageSize < 1 {
		pageSize = 6
	}

	return DiscoverParams{
		Page:      page,
		PageSize:  pageSize,
		Query:     strings.TrimSpace(params.Query),
		Genre:     strings.TrimSpace(params.Genre),
		MediaType: strings.TrimSpace(params.MediaType),
	}
}

func filterMedia(items []MediaItem, query string, genre string, mediaType string) []MediaItem {
	queryLower := strings.ToLower(strings.TrimSpace(query))
	genreLower := strings.ToLower(strings.TrimSpace(genre))
	mediaTypeLower := strings.ToLower(strings.TrimSpace(mediaType))

	result := make([]MediaItem, 0, len(items))
	for _, item := range items {
		if mediaTypeLower != "" && mediaTypeLower != "all" && mediaTypeLower != string(item.Type) {
			continue
		}

		if genreLower != "" && !hasGenre(item, genreLower) {
			continue
		}

		if queryLower != "" && !matchesQuery(item, queryLower) {
			continue
		}

		result = append(result, item)
	}

	return result
}

func hasGenre(item MediaItem, genre string) bool {
	for _, existing := range item.Genres {
		if strings.ToLower(existing) == genre {
			return true
		}
	}
	return false
}

func matchesQuery(item MediaItem, query string) bool {
	if strings.Contains(strings.ToLower(item.Title), query) {
		return true
	}

	if strings.Contains(strings.ToLower(item.Overview), query) {
		return true
	}

	for _, genre := range item.Genres {
		if strings.Contains(strings.ToLower(genre), query) {
			return true
		}
	}

	return false
}

func page(items []MediaItem, pageNumber int, pageSize int) []MediaItem {
	start := (pageNumber - 1) * pageSize
	if start >= len(items) {
		return []MediaItem{}
	}

	end := start + pageSize
	if end > len(items) {
		end = len(items)
	}

	return slices.Clone(items[start:end])
}

func cloneStringSlice(values []string) []string {
	if len(values) == 0 {
		return []string{}
	}

	return slices.Clone(values)
}

func score(title string, query string, rating float64) int {
	cleanTitle := strings.ToLower(strings.TrimSpace(title))
	if cleanTitle == query {
		return min(100, int(70+rating*3))
	}

	if strings.HasPrefix(cleanTitle, query) {
		return min(98, int(60+rating*3))
	}

	return min(95, int(45+rating*4))
}

func min(a int, b int) int {
	if a < b {
		return a
	}
	return b
}

func mustPick(media map[int]MediaItem, ids []int) []MediaItem {
	items := make([]MediaItem, 0, len(ids))
	for _, id := range ids {
		items = append(items, mustGet(media, id))
	}
	return items
}

func mustGet(media map[int]MediaItem, id int) MediaItem {
	item, ok := media[id]
	if !ok {
		panic(fmt.Sprintf("missing media item %d", id))
	}
	return item
}

func newMedia(
	id int,
	provider MediaProvider,
	providerID int,
	title string,
	mediaType MediaType,
	genres []string,
	platforms []string,
	releaseDate string,
	rating float64,
	runtimeMinutes int,
) MediaItem {
	overview := fmt.Sprintf("%s is a premium catalog title in your Seen library.", title)
	if mediaType == MediaTypeGame {
		overview = fmt.Sprintf("%s is a high-signal game release tracked through your IGDB-powered backlog.", title)
	}

	return MediaItem{
		ID:             id,
		Provider:       provider,
		ProviderID:     providerID,
		Title:          title,
		Overview:       overview,
		Type:           mediaType,
		ReleaseDate:    releaseDate,
		Genres:         cloneStringSlice(genres),
		Platforms:      cloneStringSlice(platforms),
		Rating:         rating,
		RuntimeMinutes: runtimeMinutes,
		ArtworkKey:     fmt.Sprintf("%s-%d", title, id),
	}
}