var config: Asleep.Config?
var reports: Asleep.Reports?

if let config {
    reports = Asleep.createReports(config: config)
}

var reports: Asleep.Reports?
let sessionId: String

// Closure
reports?.report(sessionId: sessionId, completionBlock: { (report: Asleep.Model.Report?, error: Asleep.AsleepError?) in
    if let error {
        print(error)
        return
    }
    
    if let report {
    }
})

// Async
Task {
    do {
        let report = try await reports?.report(sessionId: sessionId)
    } catch {
        print(error)
    }
}

var reports: Asleep.Reports?
let fromDate: String = "2023-05-01"
let toDate: String = "2023-05-07"

// Closure
reports?.reports(fromDate: fromDate, toDate: toDate, completionBlock: { (reportSessions: [Asleep.Model.SleepSession]?, error: Asleep.AsleepError?) in
    if let error {
        print(error)
        return
    }
    
    if let reportSessions {
    }
})

// Async
Task {
    do {
        let reportSessions = try await reports?.reports(fromDate: fromDate, toDate: toDate)
    } catch {
        print(error)
    }
}

var reports: Asleep.Reports?
let fromDate: String = "2023-05-01"
let toDate: String = "2023-05-07"

// Closure
reports?.getAverageReport(fromDate: fromDate, toDate: toDate, completionBlock: { (averageReport: Asleep.Model.AverageReport?, error: Asleep.AsleepError?) in
    if let error {
        print(error)
        return
    }
    
    if let averageReport {
    }
})

// Async
Task {
    do {
        let averageReport = try await reports?.getAverageReport(fromDate: fromDate, toDate: toDate)
    } catch {
        print(error)
    }
}

var reports: Asleep.Reports?
let sessionId: String

// Closure
reports?.deleteReport(sessionId: sessionId, completionBlock: { (error: Asleep.AsleepError?) in
    if let error {
        print(error)
        return
    }
})

// Async
Task {
    do {
        try await reports?.deleteReport(sessionId: sessionId)
    } catch {
        print(error)
    }
}

var reports: Asleep.Reports?
let sessionId: String
let analysisStartTime: Date
let analysisEndTime: Date

// Closure
reports?.reanalyze(sessionId: sessionId,
                   analysisStartTime: analysisStartTime,
                   analysisEndTime: analysisEndTime,
                   completionBlock: { (sessionId: String?, error: Asleep.AsleepError?) in
    if let error {
        print(error)
        return
    }
    if let sessionId {
        // Reanalysis request completed
    }
})

// Async
Task {
    do {
        try await reports?.reanalyze(sessionId: sessionId,
                                     analysisStartTime: analysisStartTime,
                                     analysisEndTime: analysisEndTime)
    } catch {
        print(error)
    }
}

// Closure
reports?.reanalyze(sessionId: sessionId, completionBlock: { (sessionId: String?, error: Asleep.AsleepError?) in
    // ...
})

// Async
Task {
    try await reports?.reanalyze(sessionId: sessionId)
}

struct Report {
    let timezone: String
    let peculiarities: [Peculiarity]
    let missingDataRatio: Float
    let session: Session
    let stat: Stat?
    let analysis: Analysis?
}

enum Peculiarity {
    case inProgress
    case neverSlept
    case tooShortForAnalysis
    case tooLongForAnalysis
    case tooManyDefectsInSleepStages
    case noBreathingStability
    case noRealtimePolling
}

struct Session {
    let id: String
    let state: State
    let startTime: Date
    let endTime: Date?
    let unexpectedEndTime: Date?
    let createdTimezone: String
    let sleepStages: [Int]?
    let breathStages: [Int]?
    let snoringStages: [Int]?
    let sleepStageProbs: [[Float]]?
    let breathStageProbs: [[Float]]?
    let snoringStageProbs: [[Float]]?
    let measurementStartTime: Date?
    let measurementEndTime: Date?
}

enum State {
    case open
    case closed
    case complete
}

struct Stat {
    let sleepEfficiency: Float?
    let sleepLatency: Int?
    let sleepTime: Date?
    let wakeupLatency: Int?
    let wakeTime: Date?
    let lightLatency: Int?
    let deepLatency: Int?
    let remLatency: Int?
    let timeInWake: Int?
    let timeInSleepPeriod: Int?
    let timeInSleep: Int?
    let timeInBed: Int?
    let timeInRem: Int?
    let timeInLight: Int?
    let timeInDeep: Int?
    let timeInStableBreath: Int?
    let timeInUnstableBreath: Int?
    let timeInSnoring: Int?
    let timeInNoSnoring: Int?
    let wakeRatio: Float?
    let sleepRatio: Float?
    let remRatio: Float?
    let lightRatio: Float?
    let deepRatio: Float?
    let stableBreathRatio: Float?
    let unstableBreathRatio: Float?
    let snoringRatio: Float?
    let noSnoringRatio: Float?
    let unstableBreathCount: Int?
    let breathingPattern: BreathingPattern?
    let breathingIndex: Float?
    let sleepCycle: Int?
    let sleepCycleCount: Int?
    let sleepCycleTime: [Date]?
    let wasoCount: Int?
    let longestWaso: Int?
    let sleepIndex: Int?
    let snoringCount: Int?
}

struct Analysis {
    let startEpochIndex: Int
    let endEpochIndex: Int
    let epochDurations: [Int]
    let totalEpochCount: Int

    var epochCount: Int { get }
    func contains(seq: Int) -> Bool
}

struct SleepSession {
    let sessionId: String
    let state: State
    let sessionStartTime: Date
    let sessionEndTime: Date?
    let createdTimezone: String
    let unexpectedEndTime: Date?
    let lastReceivedSeqNum: Int?
    let timeInBed: Int?
}

enum State {
    case open
    case closed
    case complete
}

struct AverageReport {
    let period: Period
    let peculiarities: [Peculiarity]
    let averageStats: AverageStats?
    let neverSleptSessions: [NeverSleptSession]
    let sleptSessions: [SleptSession]
}

struct Period {
    let timezone: String
    let startDate: Date
    let endDate: Date
}

struct AverageStats {
    let startTime: String
    let endTime: String
    let sleepTime: String
    let wakeTime: String
    let sleepLatency: Int
    let wakeupLatency: Int
    let timeInBed: Int
    let timeInSleepPeriod: Int
    let timeInSleep: Int
    let timeInWake: Int
    let timeInLight: Int?
    let timeInDeep: Int?
    let timeInRem: Int?
    let timeInSnoring: Int?
    let timeInNoSnoring: Int?
    let sleepEfficiency: Double
    let wakeRatio: Double
    let sleepRatio: Double
    let lightRatio: Double?
    let deepRatio: Double?
    let remRatio: Double?
    let snoringRatio: Double?
    let noSnoringRatio: Double?
    let wasoCount: Int
    let longestWaso: Int
    let sleepCycleCount: Int?
    let snoringCount: Int?
}

struct NeverSleptSession {
    let id: String
    let startTime: Date
    let endTime: Date
    let completedTime: Date
}

struct SleptSession {
    let id: String
    let createdTimezone: String
    let startTime: Date
    let endTime: Date
    let completedTime: Date
    let sleepEfficiency: Double
    let sleepLatency: Int?
    let wakeupLatency: Int?
    let lightLatency: Int?
    let deepLatency: Int?
    let remLatency: Int?
    let sleepTime: Date?
    let wakeTime: Date?
    let timeInWake: Int
    let timeInSleepPeriod: Int
    let timeInSleep: Int
    let timeInBed: Int
    let timeInRem: Int?
    let timeInLight: Int?
    let timeInDeep: Int?
    let timeInSnoring: Int?
    let timeInNoSnoring: Int?
    let wakeRatio: Double
    let sleepRatio: Double
    let remRatio: Double?
    let lightRatio: Double?
    let snoringRatio: Double?
    let noSnoringRatio: Double?
    let sleepCycle: Int?
    let sleepCycleCount: Int?
    let wasoCount: Int?
    let longestWaso: Int?
    let snoringCount: Int?
}