package com.lukouguoji.gjc.viewModel

import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.viewModelScope
import com.lukouguoji.gjc.R
import com.lukouguoji.gjc.holder.IntExpStorageUseViewHolder
import com.lukouguoji.module_base.base.BasePageViewModel
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.commonAdapter
import com.lukouguoji.module_base.ktx.launchCollect
import com.lukouguoji.module_base.ktx.launchLoadingCollect
import com.lukouguoji.module_base.ktx.noNull
import com.lukouguoji.module_base.ktx.showToast
import com.lukouguoji.module_base.ktx.toRequestBody
import com.lukouguoji.module_base.model.ScanModel
import com.lukouguoji.module_base.util.DictUtils
import dev.utils.app.info.KeyValue
import kotlinx.coroutines.launch

/**
 * 国际出港-仓库 ViewModel
 */
class IntExpStorageUseViewModel : BasePageViewModel() {

    // ========== 筛选条件 ==========
    val flightDate = MutableLiveData("")  // 航班日期，默认为空（可手动选择）
    val flightNo = MutableLiveData("")                 // 航班号
    val clearResult = MutableLiveData("")              // 清仓综合结果
    val clearResultList = MutableLiveData<List<KeyValue>>() // 清仓综合结果列表
    val wbNo = MutableLiveData("")                     // 运单号
    val location = MutableLiveData("")              // 库位号

    // ========== 统计信息 ==========
    val totalWbNumber = MutableLiveData("0")           // 总票数
    val totalPc = MutableLiveData("0")                 // 总件数
    val totalWeight = MutableLiveData("0")             // 总重量

    // ========== 5.5寸手机版专属 ==========
    // 筛选弹层显隐
    val filterVisible = MutableLiveData(false)

    // 筛选条件（设计稿弹层 8 项中平板没有的 6 项；平板布局无对应控件 → 恒为空 → 不进请求）
    val agentId = MutableLiveData("")          // 代理（agentCode）
    val spCode = MutableLiveData("")           // 特码
    val dest = MutableLiveData("")             // 目的站
    val awbType = MutableLiveData("")          // 运单类型（pageQuery 无此入参，预留，见接口问题清单）
    val businessType = MutableLiveData("")     // 业务类型（同上预留）
    val goodsCn = MutableLiveData("")          // 品名(中)（同上预留）

    // 筛选下拉字典（initPhoneExtras 加载，平板不请求）
    val agentList = MutableLiveData(listOf(KeyValue("全部", "")))
    val specialCodeList = MutableLiveData<List<KeyValue>>(emptyList())
    val awbTypeList = MutableLiveData<List<KeyValue>>(emptyList())
    val businessTypeList = MutableLiveData(
        listOf(
            KeyValue("全部", ""),
            KeyValue("普货", "1"),
            KeyValue("特货", "2")
        )
    )

    // 三格统计：未清仓 / 已清仓（总票数复用 totalWbNumber，服务端全量口径）。
    // 复用 pageQueryTotal 按 clearNormal=0/1 各查一次（入参 schema 含 clearNormal）。
    val unclearedCount = MutableLiveData("0")
    val clearedCount = MutableLiveData("0")

    private var phoneExtrasEnabled = false

    /**
     * 手机形态专属初始化（Activity 在 DeviceUtil.isPhone() 时调用）。
     * 平板端不调用，请求次数与行为零变化。
     */
    fun initPhoneExtras() {
        phoneExtrasEnabled = true
        // 代理（与 06 出港查询同源接口）
        launchCollect({ NetApply.api.getIntExpAgentList() }) {
            onSuccess = { result ->
                val list = mutableListOf(KeyValue("全部", ""))
                result.data?.forEach { list.add(KeyValue(it.name ?: "", it.code ?: "")) }
                agentList.value = list
            }
        }
        // 特码：flag=1 国际；ieFlag 必须留空——传 "E" 后端返回空数组
        DictUtils.getSpecialCodeList(addAll = false, flag = 1, ieFlag = "") { list ->
            specialCodeList.postValue(listOf(KeyValue("全部", "")) + list)
        }
        // 运单类型（type=IO 国际出港）
        DictUtils.getWaybillTypeList(type = Constant.businessType.IO, addAll = true) {
            awbTypeList.postValue(it)
        }
    }

    /** 筛选按钮点击 - 打开筛选面板 */
    fun filterClick() {
        filterVisible.value = true
    }

    /** 关闭筛选面板 */
    fun closeFilter() {
        filterVisible.value = false
    }

    /** 重置筛选条件 */
    fun resetFilter() {
        flightDate.value = ""
        flightNo.value = ""
        agentId.value = ""
        spCode.value = ""
        dest.value = ""
        awbType.value = ""
        businessType.value = ""
        goodsCn.value = ""
    }

    /** 确认筛选 - 关闭面板并刷新 */
    fun confirmFilter() {
        filterVisible.value = false
        refresh()
    }

    // ========== 全选状态 ==========
    val isAllChecked = MutableLiveData(false)

    fun onItemCheckChanged() {
        updateCheckAllStatus()
    }

    fun updateCheckAllStatus() {
        val list = pageModel.rv?.commonAdapter()?.items as? List<GjcMaWb> ?: return
        isAllChecked.value = list.isNotEmpty() && list.all { it.checked.get() }
    }

    // ========== 全局展开状态 ==========
    /**
     * 全局展开状态
     * - true: 全部展开
     * - false: 全部收起
     */
    val isAllExpanded = MutableLiveData(false)

    init {
        // 初始化清仓综合结果列表（根据实际需求配置）
        clearResultList.value = listOf(
            KeyValue("全部", ""),
            KeyValue("正常", "1"),
            KeyValue("异常", "0")
        )

    }

    // ========== 适配器配置 ==========
    val itemViewHolder = IntExpStorageUseViewHolder::class.java
    val itemLayoutId = R.layout.item_int_exp_storage_use

    /**
     * 搜索按钮点击
     */
    fun searchClick() {
        refresh()
    }

    /**
     * 全选按钮点击（联动勾选所有子列表项）
     */
    fun checkAllClick() {
        val list = pageModel.rv?.commonAdapter()?.items as? List<GjcMaWb> ?: return

        val shouldCheckAll = !isAllChecked.value!!

        // 联动勾选/取消主列表和子列表
        list.forEach { maWb ->
            maWb.checked.set(shouldCheckAll)
            // 同时联动勾选/取消所有子列表项
            maWb.storageUseList?.forEach { storageUse ->
                storageUse.checked.set(shouldCheckAll)
            }
        }

        isAllChecked.value = shouldCheckAll

        pageModel.rv?.commonAdapter()?.notifyDataSetChanged()
    }

    /**
     * 切换全局展开/收起状态
     */
    fun toggleAllExpand() {
        val list = pageModel.rv?.commonAdapter()?.items as? List<GjcMaWb> ?: return

        // 切换全局状态
        val shouldExpand = !isAllExpanded.value!!
        isAllExpanded.value = shouldExpand

        // 更新所有列表项的 showMore 状态
        list.forEach { bean ->
            // 只有当有子列表时才设置展开状态
            if (!bean.storageUseList.isNullOrEmpty()) {
                bean.showMore.set(shouldExpand)
            }
        }

        // 刷新列表UI
        pageModel.rv?.commonAdapter()?.notifyDataSetChanged()
    }

    /**
     * 扫码运单号
     */
    fun scanWbNo() {
        ScanModel.startScan(getTopActivity(), Constant.RequestCode.WAYBILL)
    }

    /**
     * 清仓操作（在Activity中调用，会显示对话框）
     */
    fun clearStorage() {
        // 由Activity显示对话框
    }

    /**
     * 执行清仓操作
     * @param clearNormal 清仓正常（"0"或"1"）
     * @param maWbListForClear 包含选中子列表项的主列表数据
     */
    fun performClear(clearNormal: String, maWbListForClear: List<GjcMaWb>) {
        if (maWbListForClear.isEmpty()) {
            showToast("请至少选择一个库位")
            return
        }

        // 构建请求参数：完整的主子列表结构
        val params = mapOf(
            "clearNormal" to clearNormal,
            "maWbList" to maWbListForClear
        ).toRequestBody()

        launchLoadingCollect({ NetApply.api.clearIntExpStorage(params) }) {
            onSuccess = {
                showToast("清仓成功")
                viewModelScope.launch {
                    FlowBus.with<String>(ConstantEvent.EVENT_REFRESH).emit("refresh")
                }
                refresh()  // 刷新列表
            }
            onFailed = { _, msg ->
                showToast(msg.noNull("清仓失败"))
            }
        }
    }

    /**
     * 修改库位
     */
    fun modifyStorage() {
        // 由Activity显示对话框
    }

    /**
     * 执行修改库位操作
     * @param locationName 新的库位名称 (后端的location字段)
     * @param locationId 新的库位ID (后端的locationId字段)
     * @param storageUse 选中的单个库位使用对象
     */
    fun performModifyStorage(
        locationName: String,
        locationId: String,
        storageUse: com.lukouguoji.module_base.bean.GjcStorageUse
    ) {
        if (locationName.isEmpty() || locationId.isEmpty()) {
            showToast("请选择库位")
            return
        }

        // 创建更新后的库位对象（覆盖 location 和 locationId 字段）
        val updatedStorage = storageUse.copy(
            location = locationName,
            locationId = locationId.toLongOrNull() ?: 0
        )

        // 直接使用更新后的对象构建请求参数
        val params = updatedStorage.toRequestBody()

        launchLoadingCollect({ NetApply.api.modifyIntExpStorage(params) }) {
            onSuccess = {
                showToast("修改库位成功")
                viewModelScope.launch {
                    FlowBus.with<String>(ConstantEvent.EVENT_REFRESH).emit("refresh")
                }
                refresh()  // 刷新列表
            }
            onFailed = { _, msg ->
                showToast(msg.noNull("修改库位失败"))
            }
        }
    }

    /**
     * 出库操作（在Activity中调用，会显示二次确认对话框）
     */
    fun outStorage() {
        // 由Activity显示二次确认对话框
    }

    /**
     * 执行出库操作
     * @param selectedStorageList 选中的子列表项（库位）
     */
    fun performOutStorage(selectedStorageList: List<com.lukouguoji.module_base.bean.GjcStorageUse>) {
        if (selectedStorageList.isEmpty()) {
            showToast("请选择要出库的库位")
            return
        }

        // 将选中的子列表项转换为RequestBody
        val params = selectedStorageList.toRequestBody()

        launchLoadingCollect({ NetApply.api.outIntExpStorage(params) }) {
            onSuccess = {
                showToast("出库成功")
                viewModelScope.launch {
                    FlowBus.with<String>(ConstantEvent.EVENT_REFRESH).emit("refresh")
                }
                refresh()  // 刷新列表
            }
            onFailed = { _, msg ->
                showToast(msg.noNull("出库失败"))
            }
        }
    }

    /**
     * 入库操作
     */
    fun inStorage() {
        // 由Activity显示对话框
    }

    /**
     * 执行入库操作
     * @param locationName 库位名称 (后端的location字段)
     * @param locationId 库位ID (后端的locationId字段)
     * @param maWbListForInStorage 包含选中子列表项的主列表数据
     */
    fun performInStorage(
        locationName: String,
        locationId: String,
        maWbListForInStorage: List<GjcMaWb>
    ) {
        if (maWbListForInStorage.isEmpty()) {
            showToast("请至少选择一个单据")
            return
        }

        if (locationName.isEmpty() || locationId.isEmpty()) {
            showToast("请选择库位")
            return
        }

        // 构建请求参数：库位名称 + 库位ID + 完整的主子列表结构
        val params = mapOf(
            "location" to locationName,
            "locationId" to locationId.toLongOrNull(),
            "maWbList" to maWbListForInStorage
        ).toRequestBody()

        launchLoadingCollect({ NetApply.api.inIntExpStorage(params) }) {
            onSuccess = {
                showToast("入库成功")
                viewModelScope.launch {
                    FlowBus.with<String>(ConstantEvent.EVENT_REFRESH).emit("refresh")
                }
                refresh()  // 刷新列表
            }
            onFailed = { _, msg ->
                showToast(msg.noNull("入库失败"))
            }
        }
    }

    /**
     * 获取数据 (重写BasePageViewModel)
     */
    override fun getData() {
        // 构建搜索条件（手机专属 6 项平板恒为空，不进请求；awbType/businessType/goodsCn
        // 为 pageQuery 未定义入参，后端静默忽略，补齐后自动生效，见接口问题清单）
        val filterParams = mapOf(
            "fdate" to flightDate.value?.ifEmpty { null },
            "fno" to flightNo.value?.ifEmpty { null },
            "wbNo" to wbNo.value?.ifEmpty { null },
            "location" to location.value?.ifEmpty { null },
            "clearNormal" to clearResult.value?.ifEmpty { null },
            "agentCode" to agentId.value?.ifEmpty { null },
            "spCode" to spCode.value?.ifEmpty { null },
            "dest" to dest.value?.ifEmpty { null },
            "awbType" to awbType.value?.ifEmpty { null },
            "businessType" to businessType.value?.ifEmpty { null },
            "goodsCn" to goodsCn.value?.ifEmpty { null }
        )

        // 列表参数 (含分页)
        val listParams = (filterParams + mapOf(
            "pageNum" to pageModel.page,
            "pageSize" to pageModel.limit
        )).toRequestBody()

        // 统计参数 (无分页)
        val totalParams = filterParams.toRequestBody()

        // 获取列表 (带Loading)
        launchLoadingCollect({ NetApply.api.getIntExpStorageUseList(listParams) }) {
            onSuccess = { result ->
                // 手动处理 PageInfo 数据
                pageModel.handleDataList(result.list) { updateCheckAllStatus() }
                pageModel.haveMore.postValue((result.pages) > pageModel.page)
                // 数据加载完成后，重置全局展开状态为收起
                isAllExpanded.value = false
            }
        }

        // 获取统计信息 (后台请求，不阻塞列表)
        launchCollect({ NetApply.api.getIntExpStorageUseTotal(totalParams) }) {
            onSuccess = { result ->
                val data = result.data
                totalWbNumber.value = (data?.wbNumber ?: 0).toString()
                totalPc.value = (data?.totalPc ?: 0).toString()
                totalWeight.value = (data?.totalWeight ?: 0.0).toString()
            }
        }

        // 手机专属：未清仓/已清仓分项统计（同条件 + clearNormal=0/1 各查一次，平板不发）
        if (phoneExtrasEnabled) {
            val unclearedParams = (filterParams + mapOf("clearNormal" to "0")).toRequestBody()
            launchCollect({ NetApply.api.getIntExpStorageUseTotal(unclearedParams) }) {
                onSuccess = { unclearedCount.value = (it.data?.wbNumber ?: 0).toString() }
            }
            val clearedParams = (filterParams + mapOf("clearNormal" to "1")).toRequestBody()
            launchCollect({ NetApply.api.getIntExpStorageUseTotal(clearedParams) }) {
                onSuccess = { clearedCount.value = (it.data?.wbNumber ?: 0).toString() }
            }
        }
    }
}
