package com.lukouguoji.gjc.viewModel

import android.content.Intent
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.viewModelScope
import com.google.gson.Gson
import com.lukouguoji.module_base.base.BaseViewModel
import com.lukouguoji.module_base.bean.GjcMaWb
import com.lukouguoji.module_base.common.Constant
import com.lukouguoji.module_base.common.ConstantEvent
import com.lukouguoji.module_base.http.net.NetApply
import com.lukouguoji.module_base.impl.FlowBus
import com.lukouguoji.module_base.ktx.launchLoadingCollect
import com.lukouguoji.module_base.ktx.launchCollect
import com.lukouguoji.module_base.ktx.showToast
import com.lukouguoji.module_base.ktx.toRequestBody
import com.lukouguoji.module_base.ktx.verifyNullOrEmpty
import dev.utils.app.info.KeyValue
import kotlinx.coroutines.launch

/**
 * 国际出港运单修改 ViewModel
 */
class GjcQueryEditViewModel : BaseViewModel() {

    // 数据Bean
    val dataBean = MutableLiveData(GjcMaWb())

    // 运单ID（用于查询详情）
    var maWbId: Long = 0

    // 包装类型下拉列表
    val packageTypeList = MutableLiveData<List<KeyValue>>(emptyList())

    // 运单类型下拉列表
    val waybillTypeList = MutableLiveData<List<KeyValue>>(emptyList())

    /**
     * 初始化数据
     */
    fun initOnCreated(intent: Intent) {
        val jsonData = intent.getStringExtra(Constant.Key.DATA) ?: ""
        if (jsonData.isNotEmpty()) {
            try {
                val tempBean = Gson().fromJson(jsonData, GjcMaWb::class.java)
                maWbId = tempBean.maWbId ?: 0  // 保存ID用于查询详情

                // 加载包装类型下拉列表
                loadPackageTypeList()

                // 加载运单类型下拉列表
                loadWaybillTypeList()

                // 调用详情接口获取完整数据
                loadDetails()
            } catch (e: Exception) {
                showToast("数据解析失败")
                getTopActivity().finish()
            }
        } else {
            showToast("未接收到数据")
            getTopActivity().finish()
        }
    }

    /**
     * 加载包装类型下拉列表
     */
    private fun loadPackageTypeList() {
        launchCollect({ NetApply.api.getPackTypeList() }) {
            onSuccess = { result ->
                // 转换为 KeyValue 列表，key 和 value 都使用 name（忽略 code）
                val keyValueList = result.data?.mapNotNull { bean ->
                    bean.name?.let { name -> KeyValue(name, name) }
                } ?: emptyList()
                packageTypeList.value = keyValueList
            }
        }
    }

    /**
     * 加载运单类型下拉列表
     * 使用接口: POST /typeCode/awb?type=10 (10代表国际出港)
     */
    private fun loadWaybillTypeList() {
        launchCollect({ NetApply.api.getWaybillTypeList("10") }) {
            onSuccess = { result ->
                // 转换为 KeyValue 列表，key 使用 name（显示），value 使用 code（存储和提交）
                val keyValueList = result.data?.mapNotNull { bean ->
                    if (bean.name != null && bean.code != null) {
                        KeyValue(bean.name, bean.code)
                    } else null
                } ?: emptyList()
                waybillTypeList.value = keyValueList
            }
        }
    }

    /**
     * 加载运单详情数据
     */
    private fun loadDetails() {
        if (maWbId == 0L) {
            showToast("运单ID不存在")
            getTopActivity().finish()
            return
        }

        launchLoadingCollect({ NetApply.api.getGjcQueryDetails(maWbId) }) {
            onSuccess = { result ->
                val data = result.data ?: emptyMap()

                // 1. 提取 maWb 对象（主要数据）
                val maWb = data["maWb"] as? Map<String, Any> ?: emptyMap()

                // 2. 提取 maWbM 对象（海关扩展数据）
                val maWbM = data["maWbM"] as? Map<String, Any> ?: emptyMap()

                // 3. 提取 warehouseList（仓库列表，用于计算入库件数和入库重量）
                val warehouseList = data["warehouseList"] as? List<Map<String, Any>> ?: emptyList()

                // 4. 合并两个对象
                val mergedData = mutableMapOf<String, Any>()
                mergedData.putAll(maWb)
                mergedData.putAll(maWbM)

                // 5. 特殊字段处理
                // 5.1 运单号: 组合 prefix + no
                val prefix = maWb["prefix"] as? String ?: ""
                val no = maWb["no"] as? String ?: ""
                if (prefix.isNotEmpty() && no.isNotEmpty()) {
                    mergedData["wbNo"] = "$prefix$no"
                }

                // 5.2 代理人: 如果 agentName 为空，使用 agentCode
                if (!mergedData.containsKey("agentName") || (mergedData["agentName"] as? String).isNullOrEmpty()) {
                    maWb["agentCode"]?.let { mergedData["agentName"] = it }
                }

                // 5.3 入库件数和入库重量: 从 warehouseList 计算总和
                if (warehouseList.isNotEmpty()) {
                    var totalPc = 0L
                    var totalWeight = 0.0

                    warehouseList.forEach { warehouse ->
                        // 提取 pc（件数）并累加
                        val pc = warehouse["pc"]
                        when (pc) {
                            is Number -> totalPc += pc.toLong()
                            is String -> totalPc += pc.toLongOrNull() ?: 0L
                        }

                        // 提取 weight（重量）并累加
                        val weight = warehouse["weight"]
                        when (weight) {
                            is Number -> totalWeight += weight.toDouble()
                            is String -> totalWeight += weight.toDoubleOrNull() ?: 0.0
                        }
                    }

                    // 覆盖原有的 arrivePc 和 arriveWeight
                    mergedData["arrivePc"] = totalPc
                    mergedData["arriveWeight"] = totalWeight
                }

                // 6. 转换为 GjcMaWb 对象
                val bean = Gson().fromJson(Gson().toJson(mergedData), GjcMaWb::class.java)

                // 7. 匹配包装类型（支持 contains）
                matchPackageType(bean)

                // 8. 匹配运单类型（支持 contains）
                matchWaybillType(bean)

                dataBean.value = bean
            }
        }
    }

    /**
     * 匹配包装类型
     * 使用 contains 匹配，支持简写值和完整值
     */
    private fun matchPackageType(bean: GjcMaWb) {
        val currentPackageType = bean.packageType
        if (currentPackageType.isNullOrEmpty()) return

        val packageList = packageTypeList.value ?: emptyList()
        if (packageList.isEmpty()) return

        // 使用 contains 匹配（完整值和简写值都支持）
        val match = packageList.find { keyValue ->
            keyValue.value?.contains(currentPackageType) == true
        }

        if (match != null) {
            // 使用匹配到的完整值
            bean.packageType = match.value
        }
    }

    /**
     * 匹配运单类型
     * 使用 code 进行匹配（bean.awbType 存储的是 code）
     * 显示时使用 name，但实际存储和提交的是 code
     */
    private fun matchWaybillType(bean: GjcMaWb) {
        val currentAwbTypeCode = bean.awbType
        if (currentAwbTypeCode.isNullOrEmpty()) return

        val waybillList = waybillTypeList.value ?: emptyList()
        if (waybillList.isEmpty()) return

        // 使用 code 进行精确匹配（value 字段存储的是 code）
        val match = waybillList.find { keyValue ->
            keyValue.value == currentAwbTypeCode
        }

        if (match != null) {
            // 使用匹配到的 code 值（确保存储的是 code，而不是 name）
            bean.awbType = match.value
        }
    }

    /**
     * 保存修改
     */
    fun submit() {
        val bean = dataBean.value ?: return

        // 字段校验
        if (bean.wbNo.verifyNullOrEmpty("运单号不能为空")) return

        // 调用更新接口
        launchLoadingCollect({
            NetApply.api.updateGjcMaWb(bean.toRequestBody())
        }) {
            onSuccess = {
                showToast("修改成功")
                // 发送刷新事件
                viewModelScope.launch {
                    FlowBus.with<String>(ConstantEvent.EVENT_REFRESH).emit("refresh")
                }
                getTopActivity().finish()
            }
        }
    }

    /**
     * 取消按钮
     */
    fun cancel() {
        getTopActivity().finish()
    }
}
