package com.xty.network.model

import java.io.Serializable
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Date
import java.util.Locale

/* val hrData: Int,
 val time: String,*/
data class SleepCompareBean(

    var sleepMap:  Value,
    var sleepCompareMap : Value,
    var comprehensiveContent : String,

): Serializable {
    
    data class Model(
        // 周月年
        var date: String,//时间
        val deep: String,//深睡时长
        val light: String,//浅睡时长
        var days: Int // 0 无数据  1有数据
    )
    data class ModelDayItem(
    //--------------------- 日--------
        val sleepLen: Int, //时长
        val sleepStartTime: Long,  //开始时间
        val sleepType: Int,  //999 代表清醒状态
    ) : Serializable
    data class ModelDay(
        //--------------------- 日--------
        val deepSleepCount: Int ,// 5,
        val lightSleepCount: Int ,// 7,
        val soberSleepCount: Int ,// 1,
        val startTime: Int ,// 1687627983,
        val lightSleepTotal: Int ,// 251,
        val endTime: Int ,// 1687648380,
        val deepSleepTotal: Int ,// 80,
    )


    data class Value(
        //周月年

        var list: MutableList<Model>,
        val avg : String ,// 397,平均睡眠时长
        val min : String ,// 392,最小睡眠时长
        val lightAvg : String ,// 292,平均浅睡时长
        val max : String ,// 402,最大时长
        val count : String ,// 2,累计天数
        val deepAvg : String ,// 105 平均深睡时长
        val  sleepLackCount	: String,//	睡眠不足次数
        val  sleepMuchCount	: String, //睡眠太足次数
       //----------------日------------
        var value: MutableList<ModelDayItem>,
        val model : ModelDay ,//

    )

    fun fillMissingData(dataList: MutableList<Model>, startDate: String, endDate: String): MutableList< Model> {
        val filledDataList = mutableListOf< Model>()

        val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())

        // 解析开始日期和结束日期
        val start = dateFormat.parse(startDate) ?: return filledDataList
        val end = dateFormat.parse(endDate) ?: return filledDataList

        // 初始化日期范围
        val calendar = Calendar.getInstance()
        calendar.time = start

        // 循环遍历日期范围，直到结束日期
        while (!calendar.time.after(end)) {
            val currentDate = calendar.time
            val formattedDate = dateFormat.format(currentDate)

            // 查找数据集合中是否存在当前日期的数据
            val matchingData = dataList.find { it.date   == formattedDate    }

            // 如果存在匹配的数据，则添加到补全后的列表中
            if (matchingData != null) {
                filledDataList.add(matchingData)
            } else {
                // 不存在匹配的数据，则添加一个值为0的数据
                filledDataList.add( Model(formattedDate,  "0","0",0))
            }

            // 增加一天
            calendar.add(Calendar.DAY_OF_YEAR, 1)
        }

        return filledDataList
    }
    fun fillMissingData(dataList: MutableList< Model>, month: String): MutableList< Model> {
        val filledDataList = mutableListOf< Model>()

        val dateFormat = SimpleDateFormat("MM-dd", Locale.getDefault())

        val calendar = Calendar.getInstance()

        // 设置日历实例的年份和月份
        val yearMonthFormat = SimpleDateFormat("yyyy-MM", Locale.getDefault())
        calendar.time = yearMonthFormat.parse(month) ?: return filledDataList

        // 获取指定月份的天数
        val maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH)

        // 循环遍历整个月份的每一天
        for (day in 1..maxDay) {
            calendar.set(Calendar.DAY_OF_MONTH, day)
            val currentDate = calendar.time
            var formattedDate = dateFormat.format(currentDate)

            // 查找数据集合中是否存在当前日期的数据
            val matchingData = dataList.find {
                it.date== formattedDate
            }

            // 如果存在匹配的数据，则添加到补全后的列表中
            if (matchingData != null) {
                matchingData.date = formattedDate
                filledDataList.add(matchingData)
            } else {
                // 不存在匹配的数据，则添加一个值为0的数据
                filledDataList.add( Model(formattedDate, "0","0",0))
            }
        }

        return  filledDataList
    }
    fun fillMissingData(dataList: MutableList< Model>): MutableList< Model> {
        val filledDataList = mutableListOf< Model>()

        // 初始化日期范围
        val calendar = Calendar.getInstance()

        // 循环遍历12个月
        for (month in 1..12) {
            val formattedMonth = String.format("%02d", month)

            // 查找数据集合中是否存在当前月份的数据
            val matchingData = dataList.find {
                val d = it.date.split("-")
                if (d.size > 1){
                    d[1] == formattedMonth
            }else{
                false
            }}

            // 如果存在匹配的数据，则添加到补全后的列表中
            if (matchingData != null) {
                matchingData.date = formattedMonth
                filledDataList.add(matchingData)
            } else {
                // 不存在匹配的数据，则添加一个值为0的数据
                filledDataList.add( Model(formattedMonth, "0","0",0))
            }
        }

        return  convertDateFormat(filledDataList,"month")
    }
    private fun timestampToMonthDay(timestamp: Long, type :String): String {
        val dateFormat = SimpleDateFormat(type, Locale.getDefault())
        val date = Date(timestamp * 1000L) // 将时间戳转换为毫秒
        return dateFormat.format(date)
    }
    fun fillMissingDataNewMonth(dataList: MutableList<Model>, month: String): MutableList<Model> {
        val filledDataList = mutableListOf<Model>()

        // 获取指定月份的天数
        val calendar = Calendar.getInstance()
        calendar.time = SimpleDateFormat("yyyy-MM", Locale.getDefault()).parse("2023-$month") ?: return filledDataList
        val maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH)

        // 填充指定月份的每一天的数据
        for (day in 1..maxDay) {
            val formattedDate = String.format("%02d", day)

            // 检查 dataList 是否包含当前日期的数据
            val matchingData = dataList.find { it.date.endsWith("-$formattedDate") }

            // 如果 dataList 中包含当前日期的数据，则将其添加到 filledDataList 中
            if (matchingData != null) {
                matchingData.date = formattedDate
                filledDataList.add(matchingData)
            } else {
                // 如果 dataList 中不包含当前日期的数据，则添加一个新的 Model 对象，其它属性使用默认值
                filledDataList.add(Model(formattedDate, "0", "0", 0))
            }
        }

        return convertDateFormat(filledDataList,"week")
    }

//    fun fillMissingDataNewMonth(dataList: MutableList<Model>, month: String): MutableList<Model> {
//        val filledDataList = mutableListOf<Model>()
//
//        // 获取指定月份的天数
//        val calendar = Calendar.getInstance()
//        calendar.time = SimpleDateFormat("MM", Locale.getDefault()).parse(month) ?: return filledDataList
//        val maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH)
//
//        // 填充指定月份的每一天的数据
//        for (day in 1..maxDay) {
//            val formattedDate = "$month-${String.format("%02d", day)}"
//
//            // 检查 dataList 是否包含当前日期的数据
//            val matchingData = dataList.find {
//                val d =  it.date.split("-")
//                if (d.size >=2){
//                    d[2]==formattedDate
//                }else{
//                   false
//                }
//            }
//
//            // 如果 dataList 中包含当前日期的数据，则将其添加到 filledDataList 中
//            if (matchingData != null) {
//                matchingData.date= formattedDate
//                filledDataList.add(matchingData)
//            } else {
//                // 如果 dataList 中不包含当前日期的数据，则添加一个新的 Model 对象，其它属性使用默认值
//                filledDataList.add(Model(formattedDate, "0", "0", 0))
//            }
//        }
//
//        return filledDataList
//    }
private fun convertMonthFormat(dataList: MutableList<Model>,  type: String): MutableList<Model> {
    val convertedDataList = mutableListOf<Model>()

    for (model in dataList) {
        val month = model.date.toInt()
        val formattedMonth = getFormattedMonth(month)
        val convertedModel = Model(formattedMonth, model.deep,model.light,model.days)
        convertedDataList.add(convertedModel)
    }

    return convertedDataList
}


    fun   convertDateFormat(dataList: MutableList<Model>, type: String): MutableList<Model> {
        val convertedDataList = mutableListOf<Model>()

        for (model in dataList) {
            val formattedTime = if (type == "month") {
                getFormattedMonth(model.date.toInt())
            } else {
                getFormattedDay(model.date.toInt())
            }
            val convertedModel =  Model(formattedTime, model.deep,model.light,model.days)
            convertedDataList.add(convertedModel)
        }

        return convertedDataList
    }

    private fun getFormattedMonth(month: Int): String {
        return "${month}月"
    }

    private fun getFormattedDay(day: Int): String {
        return "${day}日"
    }

}