package com.xty.network.model

import android.os.Build
import androidx.annotation.RequiresApi
import java.io.Serializable
import java.text.SimpleDateFormat
import java.time.Instant
import java.util.Calendar
import java.util.Date
import java.util.Locale
import kotlin.math.roundToInt


/*
**血氧
* ,*/
data class XyangCompareBean(
    var model: MutableList<Model>,
    var modelCompare: MutableList<Model>,
    val value:  Value,
    val comprehensiveContent : String //": "根据2023-05对比数据，平均心率值变大，平均心率情况持平；心率异常情况变差；心率总体情况变差。"

): Serializable {

    data class Model(
        var time: String,//时间
        var value: Float //血氧值

    )
    data class Value(
    val normal : String ,// 844,正常次数
    val compareCount : String ,// 380,	总次数（对比）
    val hyoxemiaCompare : String ,// 0,低血氧（对比）
    val compareNormal : String ,// 355,正常次数（对比）
    val compareMin : String ,// 93,最小值（对比）
    val max : String ,// 100,最大值
    val compareAvg : String ,// 96,平均值（对比）
    val count : String ,// 881,	总次数
    val min : String ,// 94,	最小值
    val avg : String ,// 96,平均值
    val deficiency : String ,// 37,	供氧不足
    val compareMax : String ,// 100,	最大值（对比）
    val hyoxemia : String ,// 0,低血氧
    val deficiencyCompare : String  // 25	供氧不足（对比）
    )


    @RequiresApi(Build.VERSION_CODES.O)
    fun mapDataToTimeNodes(dataList: MutableList< Model>): MutableList< Model> {
        val mappedData = mutableListOf< Model>()
        val dateFormat = SimpleDateFormat("HH:mm", Locale.getDefault())
        // 创建一天的时间节点
        val calendar = Calendar.getInstance()
        calendar.set(Calendar.HOUR_OF_DAY, 0)
        calendar.set(Calendar.MINUTE, 0)
        calendar.set(Calendar.SECOND, 0)
        calendar.set(Calendar.MILLISECOND, 0)
        val startTime = calendar.time

        calendar.add(Calendar.DAY_OF_MONTH, 1)
        calendar.add(Calendar.MINUTE, -1)
        val endTime = calendar.time

        // 初始化时间节点和默认值
        var currentTime = startTime
        while (currentTime <= endTime) {
            mappedData.add( Model(dateFormat.format(currentTime), 0f))
            calendar.time = currentTime
            calendar.add(Calendar.MINUTE, 10)
            currentTime = calendar.time
        }
        val timestamp = 1688631900L
        val time = Date(timestamp * 1000)
        // 将数据集合中的时间映射到时间节点上
        for (model in dataList) {

            val timestamp = model.time.toLong() // 将时间戳字符串转换为长整型
            val time = Date.from(Instant.ofEpochSecond(timestamp)) // 使用 Instant 类转换为 Date 对象
            calendar.time = time

//            val timeStr = model.time
//            val time = dateFormat.parse(timeStr) // 将字符串转换为 Date 类型
//            calendar.time = time as Date

            // 舍弃分钟数为 10 的倍数以外的部分，进行四舍五入
            val minute = calendar.get(Calendar.MINUTE)
            val roundedMinute = (minute / 10.0).roundToInt() * 10
            calendar.set(Calendar.MINUTE, roundedMinute.toInt())
            calendar.set(Calendar.SECOND, 0)
            calendar.set(Calendar.MILLISECOND, 0)

            // 查找对应的时间节点并更新值
            val index = mappedData.indexOfFirst { it.time == dateFormat.format(calendar.time) }
            if (index != -1) {
                mappedData[index] =
                     Model(dateFormat.format(calendar.time), model.value)
            }
        }

        return mappedData
    }
    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 { formattedDate.contains(timestampToMonthDay(it.time.toLong(),"MM-dd"))   }

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

            // 增加一天
            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 {
//                val time =  it.time;
//                if (time.contains("-")){
//                    formattedDate.equals(time)
//                }else{
//                    formattedDate.contains(timestampToMonthDay(time.toLong(),"MM-dd"))
//                }
//            }
//
//            // 如果存在匹配的数据，则添加到补全后的列表中
//            if (matchingData != null) {
//                matchingData.time = formattedDate
//                filledDataList.add(matchingData)
//            } else {
//                // 不存在匹配的数据，则添加一个值为0的数据
//                filledDataList.add( Model(formattedDate, 0))
//            }
//        }
//
//        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 {
                val time = it.time
                if (time.contains("-")) {
                    formattedDate.equals(time)
                } else {
                    formattedDate.contains(timestampToMonthDay(time.toLong(), "MM-dd"))
                }
            }

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

        return convertMonthFormat(filledDataList,"week")
    }

    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 { timestampToMonthDay(it.time.toLong(),"MM" ) == formattedMonth }

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

        return convertMonthFormat(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   convertMonthFormat(dataList: MutableList<Model>, type: String): MutableList<Model> {
        val convertedDataList = mutableListOf<Model>()

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

        return convertedDataList
    }

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

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