import Foundation

struct DeviceCodeResponse: Decodable {
    let code: String
    let expiresAt: String?
    let pollIntervalSeconds: Int?
    let linkUrl: String?
    let qrPayload: String?
}

enum PollResult {
    case pending
    case expired
    case alreadyLinked
    case linked(refreshToken: String, viewerName: String)
}

struct HomePayload: Decodable {
    let continueWatching: [MediaItem]
    let spotlight: [MediaItem]?
    let shelves: [ShelfRow]
    let favorites: [MediaItem]?
}

struct ShelfRow: Decodable, Identifiable {
    let id: String
    let title: String
    let name: String?
    let kind: String?
    let slug: String?
    let items: [MediaItem]
}

struct MediaItem: Codable, Identifiable, Hashable {
    let type: String
    let id: String
    let title: String
    let subtitle: String?
    let year: Int?
    let posterUrl: String?
    let backdropUrl: String?
    let logoUrl: String?
    let mediaFileId: String?
    let seriesId: String?
    let positionMs: Int64?
    let durationMs: Int64?
    let progressId: String?
    let badge: String?
}

struct PlayResult: Decodable {
    let streamUrl: String
    let sessionId: String?
    let mediaFileId: String?
    let defaultSubtitle: DefaultSubtitle?
}

struct DefaultSubtitle: Decodable {
    let fileId: Int?
    let source: String?
    let language: String?
    let fileName: String?
    let format: String?
    let contentBase64: String
    let label: String?
}

struct ViewerProfile: Decodable, Identifiable, Hashable {
    let id: String
    let name: String
    let avatarId: String?
    let isOwner: Bool?
    let isKids: Bool?
    let hasPin: Bool?
    let showAvatar: Bool?
    let hasCustomAvatar: Bool?
    let avatarUrl: String?

    var showsAvatar: Bool { showAvatar ?? true }
    var hasCustomPhoto: Bool { hasCustomAvatar == true }
}

struct ProfilesPayload: Decodable {
    let profiles: [ViewerProfile]
    let activeProfileId: String?
    let canManage: Bool?
}

struct ClientMe: Decodable {
    struct Iptv: Decodable { let enabled: Bool? }
    struct Events: Decodable { let enabled: Bool? }
    let iptv: Iptv?
    let events: Events?
    let profile: ViewerProfile?
    let deviceId: String?

    var iptvEnabled: Bool { iptv?.enabled == true }
    var eventsEnabled: Bool { events?.enabled == true }
}

struct LinkedDevice: Decodable, Identifiable, Hashable {
    let id: String
    let name: String
    let platform: String?
    let lastSeenAt: String?
    let createdAt: String?
    let current: Bool?
}

struct DevicesPayload: Decodable {
    let devices: [LinkedDevice]
}

struct ApproveDeviceResult: Decodable {
    let ok: Bool?
    let deviceName: String?
    let platform: String?
}

struct MediaFileInfo: Decodable, Identifiable, Hashable {
    let id: String
    let label: String?
    let resolution: String?
    let videoCodec: String?
    let audioCodec: String?
    let hdrType: String?
    let nodeOnline: Bool?
    let nodeName: String?
}

struct MovieDetail: Decodable {
    let id: String
    let title: String
    let overview: String?
    let year: Int?
    let posterUrl: String?
    let backdropUrl: String?
    let logoUrl: String?
    let runtime: Int?
    let genres: [String]?
    let rating: String?
    let cast: [String]?
    let director: [String]?
    let mediaFiles: [MediaFileInfo]?
    let positionMs: Int64?
    let durationMs: Int64?
    let completed: Bool?

    var preferredMediaFileId: String? {
        mediaFiles?.first(where: { $0.nodeOnline != false })?.id ?? mediaFiles?.first?.id
    }

    var resumeMs: Int64 {
        if completed == true { return 0 }
        return max(0, positionMs ?? 0)
    }
}

struct SeriesDetail: Decodable {
    let id: String
    let title: String
    let overview: String?
    let year: Int?
    let posterUrl: String?
    let backdropUrl: String?
    let logoUrl: String?
    let genres: [String]?
    let rating: String?
    let cast: [String]?
    let director: [String]?
    let seasons: [Season]?
}

struct Season: Decodable, Identifiable {
    var id: Int { seasonNumber }
    let seasonNumber: Int
    let episodes: [Episode]?
}

struct Episode: Decodable, Identifiable {
    let id: String
    let title: String?
    let episodeNumber: Int?
    let seasonNumber: Int?
    let overview: String?
    let stillUrl: String?
    let mediaFileId: String?
    let available: Bool?
    let runtime: Int?
    let completed: Bool?
    let positionMs: Int64?
    let durationMs: Int64?

    var progressFraction: CGFloat {
        if completed == true { return 1 }
        guard let dur = durationMs, dur > 0, let pos = positionMs else { return 0 }
        return CGFloat(pos) / CGFloat(dur)
    }

    var resumeMs: Int64 {
        if completed == true { return 0 }
        return max(0, positionMs ?? 0)
    }
}

struct SearchPayload: Decodable {
    let results: [MediaItem]
}

struct BrowsePayload: Decodable {
    let id: String?
    let title: String?
    let kind: String?
    let total: Int?
    let offset: Int?
    let items: [MediaItem]
}

struct SubtitleHit: Decodable, Identifiable, Hashable {
    var id: String { "\(source ?? "x")-\(fileId)" }
    let fileId: Int
    let language: String?
    let release: String?
    let fileName: String?
    let downloadCount: Int?
    let hearingImpaired: Bool?
    let source: String?
    let uploader: String?
}

struct SubtitleSearchResult: Decodable {
    let configured: Bool?
    let imdbId: String?
    let title: String?
    let results: [SubtitleHit]
}

struct FetchedSubtitle: Decodable {
    let fileId: Int?
    let source: String?
    let fileName: String?
    let format: String?
    let contentBase64: String
}

struct IptvCategory: Decodable, Identifiable, Hashable {
    let id: String
    let name: String
    let channelCount: Int?
}

struct IptvChannel: Decodable, Identifiable, Hashable {
    var id: String { streamId }
    let streamId: String
    let name: String
    let logoUrl: String?
    let number: Int?
    let categoryId: String?
    let nowTitle: String?

    enum CodingKeys: String, CodingKey {
        case streamId, name, logoUrl, number, categoryId, nowTitle
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        streamId = try decodeFlexibleString(c, forKey: .streamId)
        name = try c.decode(String.self, forKey: .name)
        logoUrl = try c.decodeIfPresent(String.self, forKey: .logoUrl)
        number = try c.decodeIfPresent(Int.self, forKey: .number)
        categoryId = try c.decodeIfPresent(String.self, forKey: .categoryId)
        nowTitle = try c.decodeIfPresent(String.self, forKey: .nowTitle)
    }
}

struct ClearKeyEntry: Decodable, Hashable {
    let kid: String
    let key: String
}

struct DrmInfo: Decodable, Hashable {
    let type: String
    let keys: [ClearKeyEntry]

    enum CodingKeys: String, CodingKey { case type, keys }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        type = try c.decodeIfPresent(String.self, forKey: .type) ?? "clearkey"
        keys = try c.decodeIfPresent([ClearKeyEntry].self, forKey: .keys) ?? []
    }
}

struct IptvPlayInfo: Decodable {
    let streamId: String
    let name: String
    let logoUrl: String?
    let streamUrl: String
    let format: String?
    let fallbackStreamUrl: String?
    let fallbackFormat: String?
    let drm: DrmInfo?
    let watchSessionId: String?
    let live: Bool?

    enum CodingKeys: String, CodingKey {
        case streamId, name, logoUrl, streamUrl, format
        case fallbackStreamUrl, fallbackFormat, drm, watchSessionId
        case eventId, live
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        if let sid = try? decodeFlexibleString(c, forKey: .streamId) {
            streamId = sid
        } else if let eid = try c.decodeIfPresent(String.self, forKey: .eventId) {
            streamId = eid
        } else {
            streamId = ""
        }
        name = try c.decode(String.self, forKey: .name)
        logoUrl = try c.decodeIfPresent(String.self, forKey: .logoUrl)
        streamUrl = try c.decode(String.self, forKey: .streamUrl)
        format = try c.decodeIfPresent(String.self, forKey: .format)
        fallbackStreamUrl = try c.decodeIfPresent(String.self, forKey: .fallbackStreamUrl)
        fallbackFormat = try c.decodeIfPresent(String.self, forKey: .fallbackFormat)
        drm = try c.decodeIfPresent(DrmInfo.self, forKey: .drm)
        watchSessionId = try c.decodeIfPresent(String.self, forKey: .watchSessionId)
        live = try c.decodeIfPresent(Bool.self, forKey: .live)
    }

    var clearKeyEntries: [ClearKeyEntry] {
        guard let drm, drm.type.lowercased() == "clearkey", !drm.keys.isEmpty else { return [] }
        return drm.keys
    }

    var needsClearKey: Bool { !clearKeyEntries.isEmpty }
}

struct EpgProgram: Decodable, Hashable {
    let title: String
    let start: String?
    let end: String?
}

struct IptvEpg: Decodable, Hashable {
    let streamId: String
    let channelName: String
    let logoUrl: String?
    let now: EpgProgram?
    let next: EpgProgram?

    enum CodingKeys: String, CodingKey {
        case streamId, channelName, logoUrl, now, next
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        streamId = (try? decodeFlexibleString(c, forKey: .streamId)) ?? ""
        channelName = try c.decode(String.self, forKey: .channelName)
        logoUrl = try c.decodeIfPresent(String.self, forKey: .logoUrl)
        now = try c.decodeIfPresent(EpgProgram.self, forKey: .now)
        next = try c.decodeIfPresent(EpgProgram.self, forKey: .next)
    }
}

struct ScheduleEventsPayload: Decodable {
    let generatedAt: String?
    let events: [ScheduleEvent]
    let providers: [String]?

    enum CodingKeys: String, CodingKey {
        case generatedAt, events, providers
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        generatedAt = try c.decodeIfPresent(String.self, forKey: .generatedAt)
        events = try c.decodeIfPresent([ScheduleEvent].self, forKey: .events) ?? []
        providers = try c.decodeIfPresent([String].self, forKey: .providers)
    }
}

struct ScheduleEvent: Decodable, Identifiable, Hashable {
    let id: String
    let name: String
    let description: String?
    let provider: String
    let category: String?
    let eventType: String?
    let subtitle: String?
    let channel: String?
    let network: String?
    let isLive: Bool?
    let phase: String?
    let playable: Bool?
    let status: String?
    let start: String
    let stop: String
    let startLocal: String?
    let stopLocal: String?
    let sportBucket: String?
    let sportLabel: String?
    let imageLandscape: String?
    let imageBackdrop: String?
    let imagePortrait: String?
    let logoUrl: String?
    let images: [String]?
    let audioLanguages: [String]?

    var isPlayable: Bool { playable == true }
    var phaseValue: String { (phase ?? "upcoming").lowercased() }
    var resolvedSportBucket: String {
        let b = (sportBucket ?? "").trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
        return b.isEmpty ? "other" : b
    }
    var resolvedSportLabel: String {
        if let s = sportLabel?.trimmingCharacters(in: .whitespacesAndNewlines), !s.isEmpty {
            return s
        }
        return EventSport.label(for: resolvedSportBucket)
    }

    enum CodingKeys: String, CodingKey {
        case id, name, description, provider, category, eventType, subtitle
        case channel, network, isLive, phase, playable, status
        case start, stop, startLocal, stopLocal
        case sportBucket, sportLabel
        case imageLandscape, imageBackdrop, imagePortrait, logoUrl, images, audioLanguages
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        id = try c.decode(String.self, forKey: .id)
        name = try c.decode(String.self, forKey: .name)
        description = try c.decodeIfPresent(String.self, forKey: .description)
        provider = try c.decodeIfPresent(String.self, forKey: .provider) ?? "unknown"
        category = try c.decodeIfPresent(String.self, forKey: .category)
        eventType = try c.decodeIfPresent(String.self, forKey: .eventType)
        subtitle = try c.decodeIfPresent(String.self, forKey: .subtitle)
        channel = try c.decodeIfPresent(String.self, forKey: .channel)
        network = try c.decodeIfPresent(String.self, forKey: .network)
        isLive = try c.decodeIfPresent(Bool.self, forKey: .isLive)
        phase = try c.decodeIfPresent(String.self, forKey: .phase)
        playable = try c.decodeIfPresent(Bool.self, forKey: .playable)
        status = try c.decodeIfPresent(String.self, forKey: .status)
        start = try c.decodeIfPresent(String.self, forKey: .start) ?? ""
        stop = try c.decodeIfPresent(String.self, forKey: .stop) ?? ""
        startLocal = try c.decodeIfPresent(String.self, forKey: .startLocal)
        stopLocal = try c.decodeIfPresent(String.self, forKey: .stopLocal)
        sportBucket = try c.decodeIfPresent(String.self, forKey: .sportBucket)
        sportLabel = try c.decodeIfPresent(String.self, forKey: .sportLabel)
        imageLandscape = try c.decodeIfPresent(String.self, forKey: .imageLandscape)
        imageBackdrop = try c.decodeIfPresent(String.self, forKey: .imageBackdrop)
        imagePortrait = try c.decodeIfPresent(String.self, forKey: .imagePortrait)
        logoUrl = try c.decodeIfPresent(String.self, forKey: .logoUrl)
        images = try c.decodeIfPresent([String].self, forKey: .images)
        audioLanguages = try c.decodeIfPresent([String].self, forKey: .audioLanguages)
    }

    init(
        id: String,
        name: String,
        description: String?,
        provider: String,
        category: String?,
        eventType: String?,
        subtitle: String?,
        channel: String?,
        network: String?,
        isLive: Bool?,
        phase: String?,
        playable: Bool?,
        status: String?,
        start: String,
        stop: String,
        startLocal: String?,
        stopLocal: String?,
        sportBucket: String? = nil,
        sportLabel: String? = nil,
        imageLandscape: String?,
        imageBackdrop: String?,
        imagePortrait: String?,
        logoUrl: String?,
        images: [String]?,
        audioLanguages: [String]?
    ) {
        self.id = id
        self.name = name
        self.description = description
        self.provider = provider
        self.category = category
        self.eventType = eventType
        self.subtitle = subtitle
        self.channel = channel
        self.network = network
        self.isLive = isLive
        self.phase = phase
        self.playable = playable
        self.status = status
        self.start = start
        self.stop = stop
        self.startLocal = startLocal
        self.stopLocal = stopLocal
        self.sportBucket = sportBucket
        self.sportLabel = sportLabel
        self.imageLandscape = imageLandscape
        self.imageBackdrop = imageBackdrop
        self.imagePortrait = imagePortrait
        self.logoUrl = logoUrl
        self.images = images
        self.audioLanguages = audioLanguages
    }

    func withImages(
        landscape: String? = nil,
        backdrop: String? = nil,
        portrait: String? = nil,
        logo: String? = nil,
        imgs: [String]? = nil,
        channel: String? = nil,
        network: String? = nil
    ) -> ScheduleEvent {
        ScheduleEvent(
            id: id,
            name: name,
            description: description,
            provider: provider,
            category: category,
            eventType: eventType,
            subtitle: subtitle,
            channel: channel ?? self.channel,
            network: network ?? self.network,
            isLive: isLive,
            phase: phase,
            playable: playable,
            status: status,
            start: start,
            stop: stop,
            startLocal: startLocal,
            stopLocal: stopLocal,
            sportBucket: sportBucket,
            sportLabel: sportLabel,
            imageLandscape: landscape ?? imageLandscape,
            imageBackdrop: backdrop ?? imageBackdrop,
            imagePortrait: portrait ?? imagePortrait,
            logoUrl: logo ?? logoUrl,
            images: imgs ?? images,
            audioLanguages: audioLanguages
        )
    }
}

enum EventSport {
    static let order = [
        "football", "racing", "tennis", "golf", "darts", "snooker",
        "basketball", "waterpolo", "sailing", "hockey", "cycling", "other",
    ]

    static func label(for bucket: String) -> String {
        switch bucket.lowercased() {
        case "football": return "Voetbal"
        case "racing": return "Racing"
        case "tennis": return "Tennis"
        case "golf": return "Golf"
        case "darts": return "Darts"
        case "snooker": return "Snooker"
        case "basketball": return "Basketbal"
        case "waterpolo": return "Waterpolo"
        case "sailing": return "Zeilen"
        case "hockey": return "Hockey"
        case "cycling": return "Wielrennen"
        default: return "Overig"
        }
    }
}

/// API streamId kan String (`"123"` / `"custom:uuid"`) of legacy Int zijn.
func decodeFlexibleString<K: CodingKey>(_ c: KeyedDecodingContainer<K>, forKey key: K) throws -> String {
    if let s = try? c.decode(String.self, forKey: key) { return s }
    if let i = try? c.decode(Int.self, forKey: key) { return String(i) }
    if let d = try? c.decode(Double.self, forKey: key) { return String(Int(d)) }
    throw DecodingError.dataCorruptedError(forKey: key, in: c, debugDescription: "Verwacht string of int id")
}

struct ShelfPref: Codable, Identifiable, Hashable {
    var id: String { shelfId }
    let shelfId: String
    let name: String
    let slug: String?
    let kind: String?
    var visible: Bool
    var sortOrder: Int
}

struct FavoriteToggleResult: Decodable {
    let favorited: Bool
    let items: [MediaItem]?
}

struct ApiErrorBody: Decodable {
    struct ErrorObj: Decodable { let message: String? }
    let error: ErrorObj?
}

// MARK: - Event hubs (F1 / Viaplay)

struct EventHub: Decodable, Identifiable, Hashable {
    let id: String
    let label: String
    let subtitle: String?
}

struct F1Meeting: Decodable, Identifiable, Hashable {
    var id: String { meetingKey }
    let meetingKey: String
    let title: String
    let meetingNumber: Int?
    let location: String?
    let startMs: Double?
    let endMs: Double?
    let imageUrl: String?

    enum CodingKeys: String, CodingKey {
        case meetingKey, title, meetingNumber, location, startMs, endMs, imageUrl
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        meetingKey = try decodeFlexibleString(c, forKey: .meetingKey)
        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
        meetingNumber = try? c.decodeIfPresent(Int.self, forKey: .meetingNumber)
        location = try c.decodeIfPresent(String.self, forKey: .location)
        startMs = try? c.decodeIfPresent(Double.self, forKey: .startMs)
        endMs = try? c.decodeIfPresent(Double.self, forKey: .endMs)
        imageUrl = try c.decodeIfPresent(String.self, forKey: .imageUrl)
    }
}

struct F1ReplayGroup: Decodable, Identifiable, Hashable {
    var id: String { meetingKey }
    let meetingKey: String
    let title: String
    let location: String?
    let meetingNumber: Int?
    let imageUrl: String?
    let latestStart: String?
    let sessions: [ScheduleEvent]

    enum CodingKeys: String, CodingKey {
        case meetingKey, title, location, meetingNumber, imageUrl, latestStart, sessions
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        meetingKey = try decodeFlexibleString(c, forKey: .meetingKey)
        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
        location = try c.decodeIfPresent(String.self, forKey: .location)
        meetingNumber = try? c.decodeIfPresent(Int.self, forKey: .meetingNumber)
        imageUrl = try c.decodeIfPresent(String.self, forKey: .imageUrl)
        latestStart = try c.decodeIfPresent(String.self, forKey: .latestStart)
        sessions = try c.decodeIfPresent([ScheduleEvent].self, forKey: .sessions) ?? []
    }
}

struct F1HubPayload: Decodable {
    let live: [ScheduleEvent]
    let upcoming: [ScheduleEvent]
    let recentReplays: [ScheduleEvent]
    let replayGroups: [F1ReplayGroup]
    let meetings: [F1Meeting]
    let nextMeeting: F1Meeting?

    enum CodingKeys: String, CodingKey {
        case live, upcoming, recentReplays, replayGroups, meetings, nextMeeting
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
        upcoming = try c.decodeIfPresent([ScheduleEvent].self, forKey: .upcoming) ?? []
        recentReplays = try c.decodeIfPresent([ScheduleEvent].self, forKey: .recentReplays) ?? []
        replayGroups = try c.decodeIfPresent([F1ReplayGroup].self, forKey: .replayGroups) ?? []
        meetings = try c.decodeIfPresent([F1Meeting].self, forKey: .meetings) ?? []
        nextMeeting = try c.decodeIfPresent(F1Meeting.self, forKey: .nextMeeting)
    }
}

struct F1MeetingDetail: Decodable {
    let meeting: F1Meeting?
    let sessions: [ScheduleEvent]
    let replays: [ScheduleEvent]
    let upcoming: [ScheduleEvent]
    let live: [ScheduleEvent]

    enum CodingKeys: String, CodingKey {
        case meeting, sessions, replays, upcoming, live
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        meeting = try c.decodeIfPresent(F1Meeting.self, forKey: .meeting)
        sessions = try c.decodeIfPresent([ScheduleEvent].self, forKey: .sessions) ?? []
        replays = try c.decodeIfPresent([ScheduleEvent].self, forKey: .replays) ?? []
        upcoming = try c.decodeIfPresent([ScheduleEvent].self, forKey: .upcoming) ?? []
        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
    }
}

struct ViaplaySport: Decodable, Identifiable, Hashable {
    let id: String
    let label: String
    let count: Int?
}

struct ViaplayHubItem: Decodable, Identifiable, Hashable {
    let id: String
    let guid: String
    let title: String
    let subtitle: String?
    let imageUrl: String?
    let kind: String?
    let openAs: String?
    let playable: Bool?
    let durationLabel: String?
    let start: String?
    let badge: String?
    let pageUrl: String?

    var opensAsEvent: Bool { (openAs ?? "").lowercased() == "event" }
}

struct ViaplayHubRail: Decodable, Identifiable, Hashable {
    let id: String
    let title: String
    let items: [ViaplayHubItem]

    enum CodingKeys: String, CodingKey { case id, title, items }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        id = try c.decode(String.self, forKey: .id)
        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
        items = (try? c.decodeIfPresent([ViaplayHubItem].self, forKey: .items)) ?? []
    }
}

struct ViaplayHubPayload: Decodable {
    let live: [ScheduleEvent]
    let today: [ScheduleEvent]
    let weekend: [ScheduleEvent]
    let later: [ScheduleEvent]
    let catchup: [ScheduleEvent]
    let sports: [ViaplaySport]
    let events: [ScheduleEvent]
    let rails: [ViaplayHubRail]

    enum CodingKeys: String, CodingKey {
        case live, today, weekend, later, catchup, sports, events, rails
    }

    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
        today = try c.decodeIfPresent([ScheduleEvent].self, forKey: .today) ?? []
        weekend = try c.decodeIfPresent([ScheduleEvent].self, forKey: .weekend) ?? []
        later = try c.decodeIfPresent([ScheduleEvent].self, forKey: .later) ?? []
        catchup = try c.decodeIfPresent([ScheduleEvent].self, forKey: .catchup) ?? []
        sports = try c.decodeIfPresent([ViaplaySport].self, forKey: .sports) ?? []
        events = try c.decodeIfPresent([ScheduleEvent].self, forKey: .events) ?? []
        rails = try c.decodeIfPresent([ViaplayHubRail].self, forKey: .rails) ?? []
    }
}