Flaro/Flixy/Session/HomeLayoutSettings.swift

import Foundation
import Observation
import MediaKit
import PlexKit

/// Welche Reihen die Startseite zeigt und in welcher Reihenfolge.
///
/// Hält nur die Einstellung und ihre Speicherung. Das Anordnen selbst macht
/// `Arrangement` in MediaKit — dort ist es reine Rechnung und ohne Simulator
/// prüfbar, und genau dort liegen die kniffligen Fälle: neue Reihen vom
/// Server, verschwundene aus der gespeicherten Liste.
@MainActor
@Observable
final class HomeLayoutSettings {
    private enum Key {
        static let hidden = "flixy.home.hiddenHubs"
        static let order = "flixy.home.hubOrder"
        static let heroCount = "flixy.home.heroCount"
        static let heroSource = "flixy.home.heroSource"
        static let combinesContinueRows = "flixy.home.combinesContinueRows"
        static let hidesWatchedInLatest = "flixy.home.hidesWatchedInLatest"
    }

    /// Woraus sich der Aufmacher speist.
    enum HeroSource: String, CaseIterable, Identifiable, Sendable {
        /// Angefangenes zuerst, danach aufgefüllt.
        case continueFirst
        /// Nur Neuzugänge — für den, der den Aufmacher als Schaufenster
        /// versteht und nicht als Fortsetzung.
        case latestOnly

        var id: String { rawValue }
    }

    /// Wie viele Titel der Aufmacher durchwechselt.
    static let heroCountChoices = [1, 3, 5, 7, 10]

    private let defaults: UserDefaults
    private(set) var arrangement: Arrangement

    var heroCount: Int { didSet { defaults.set(heroCount, forKey: Key.heroCount) } }
    var heroSource: HeroSource { didSet { defaults.set(heroSource.rawValue, forKey: Key.heroSource) } }
    /// Ob „Weiterschauen" und „Als Nächstes" eine Reihe sind.
    ///
    /// Getrennt ist genauer, zusammen ist kürzer. Beides ist vertretbar, und
    /// welches richtig ist, hängt davon ab, wie viele Serien jemand parallel
    /// schaut.
    var combinesContinueRows: Bool { didSet { defaults.set(combinesContinueRows, forKey: Key.combinesContinueRows) } }
    /// Ob Gesehenes aus „Zuletzt hinzugefügt" verschwindet.
    var hidesWatchedInLatest: Bool { didSet { defaults.set(hidesWatchedInLatest, forKey: Key.hidesWatchedInLatest) } }

    init(defaults: UserDefaults = .standard) {
        self.defaults = defaults
        self.arrangement = Arrangement(
            hidden: Set(defaults.stringArray(forKey: Key.hidden) ?? []),
            order: defaults.stringArray(forKey: Key.order) ?? []
        )
        self.heroCount = defaults.object(forKey: Key.heroCount) as? Int ?? 5
        self.heroSource = defaults.string(forKey: Key.heroSource)
            .flatMap(HeroSource.init(rawValue:)) ?? .continueFirst
        self.combinesContinueRows = defaults.object(forKey: Key.combinesContinueRows) as? Bool ?? false
        self.hidesWatchedInLatest = defaults.object(forKey: Key.hidesWatchedInLatest) as? Bool ?? false
    }

    func isHidden(_ identifier: String) -> Bool {
        arrangement.hidden.contains(identifier)
    }

    func setHidden(_ hidden: Bool, for identifier: String) {
        if hidden {
            arrangement.hidden.insert(identifier)
        } else {
            arrangement.hidden.remove(identifier)
        }
        defaults.set(Array(arrangement.hidden), forKey: Key.hidden)
    }

    func setOrder(_ identifiers: [String]) {
        arrangement.order = identifiers
        defaults.set(identifiers, forKey: Key.order)
    }

    func apply(to rows: [MediaRowGroup]) -> [MediaRowGroup] {
        arrangement.apply(to: rows)
    }

    /// Die Zeilen für den Einstellungsbildschirm.
    func rows(from rows: [MediaRowGroup]) -> [HomeRow] {
        arrangement.arrangedIdentifiers(from: rows).compactMap { identifier in
            guard let row = rows.first(where: { $0.id == identifier }) else { return nil }
            return HomeRow(id: identifier, title: row.title, isHidden: isHidden(identifier))
        }
    }
}

/// Eine Reihe im Einstellungsbildschirm.
struct HomeRow: Identifiable, Hashable {
    let id: String
    let title: String
    var isHidden: Bool
}