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.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 sessionId: String

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

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

struct Report {
    let timezone: String
    let validity: Validity
    let session: Session
    let stat: Stat?
}

enum Validity {
    case inProgress
    case invalidSleepStage
    case invalidOsaStage
    case VALID
}

struct Session {
    let id: String
    let state: State
    let startTime: Date
    let endTime: Date?
    let sleepStages: [SleepStage]
    let osaStages: [OSAStage]
}

enum State {
    case open
    case closed
    case complete
}

enum SleepStage {
    case error
    case wake
    case light
    case deep
    case rem
} 

enum OSAStage {
    case stable
    case unstable
} 

struct Stat {
    let sleepEfficiency: Float
    let sleepLatency: Int?
    let sleepTime: Date?
    let wakeupLatency: Int?
    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 timeInStableBreath: Int
    let timeInUnstableBreath: Int
    let wakeRatio: Float?
    let sleepRatio: Float?
    let remRatio: Float?
    let lightRatio: Float?
    let deepRatio: Float?
    let stableBreathRatio: Float?
    let unstableBreathRatio: Float?
    let breathingPattern: BreathingPattern?
    let estimatedAhi: Float?
}

enum BreathingPattern {
    case veryStable
    case stable
    case unstable
}

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

enum State {
    case open
    case closed
    case complete
}

fun deleteReport(sessionId: String, deleteReportListener: DeleteReportListener)

interface DeleteReportListener {
    fun onSuccess(sessionId: String?)
    fun onFail(errorCode: Int, detail: String)
}