import Foundation

enum StudyMode: String, Codable, CaseIterable, Hashable {
    case singleVideo = "single_video"
    case singleAudio = "single_audio"
    case singlePdf = "single_pdf"
    case videoPdf = "video_pdf"
    case pdfAudio = "pdf_audio"
    case dualVideo = "dual_video"
    case dualPdf = "dual_pdf"

    var label: String {
        switch self {
        case .singleVideo: return "video"
        case .singleAudio: return "audio"
        case .singlePdf: return "pdf"
        case .videoPdf: return "video + pdf"
        case .pdfAudio: return "pdf + audio"
        case .dualVideo: return "dual video"
        case .dualPdf: return "dual pdf"
        }
    }

    var isCombo: Bool {
        switch self {
        case .videoPdf, .pdfAudio, .dualVideo, .dualPdf:
            return true
        default:
            return false
        }
    }

    /// Modes with full Study UI in MVP.
    var isMVPSupported: Bool {
        switch self {
        case .singleVideo, .singleAudio, .singlePdf, .videoPdf, .pdfAudio:
            return true
        case .dualVideo, .dualPdf:
            return false
        }
    }
}

enum SplitOrientation: String, Codable, CaseIterable, Hashable {
    /// Landscape / width ≥ height → side by side.
    case horizontal
    /// Portrait / height > width → stacked.
    case vertical
}

enum AlbumMode: String, Codable, CaseIterable, Hashable {
    case playlist
    case combo

    var label: String {
        switch self {
        case .playlist: return "专辑"
        case .combo: return "课程"
        }
    }
}

enum PlaylistMediaKind: String, Codable, Hashable {
    case video
    case audio
    case pdf

    init?(resourceKind: ResourceKind) {
        switch resourceKind {
        case .video: self = .video
        case .audio: self = .audio
        case .pdf: self = .pdf
        case .other: return nil
        }
    }

    var resourceKind: ResourceKind {
        switch self {
        case .video: return .video
        case .audio: return .audio
        case .pdf: return .pdf
        }
    }
}

struct SessionResources: Codable, Hashable {
    var video: String?
    var video2: String?
    var audio: String?
    var pdf: String?
    var pdf2: String?
}

enum AlbumItem: Codable, Hashable {
    case single(resourceId: String)
    case combo(studyMode: StudyMode, resourceIds: SessionResources)

    enum CodingKeys: String, CodingKey {
        case type
        case resourceId
        case studyMode
        case resourceIds
    }

    enum ItemType: String, Codable {
        case single
        case combo
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let type = try container.decode(ItemType.self, forKey: .type)
        switch type {
        case .single:
            let id = try container.decode(String.self, forKey: .resourceId)
            self = .single(resourceId: id)
        case .combo:
            let mode = try container.decode(StudyMode.self, forKey: .studyMode)
            let ids = try container.decode(SessionResources.self, forKey: .resourceIds)
            self = .combo(studyMode: mode, resourceIds: ids)
        }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .single(let resourceId):
            try container.encode(ItemType.single, forKey: .type)
            try container.encode(resourceId, forKey: .resourceId)
        case .combo(let studyMode, let resourceIds):
            try container.encode(ItemType.combo, forKey: .type)
            try container.encode(studyMode, forKey: .studyMode)
            try container.encode(resourceIds, forKey: .resourceIds)
        }
    }
}