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.formatDate
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 dev.utils.app.info.KeyValue
import kotlinx.coroutines.launch
import java.util.Date

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

    // ========== 筛选条件 ==========
    val flightDate = MutableLiveData(Date().formatDate())  // 航班日期，默认今天
    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")             // 总重量

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

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

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

        // 监听全选状态，自动更新所有列表项
        isAllChecked.observeForever { checked ->
            val list =
                pageModel.rv?.commonAdapter()?.items as? List<GjcMaWb> ?: return@observeForever
            list.forEach { it.checked.set(checked) }
            pageModel.rv?.commonAdapter()?.notifyDataSetChanged()
        }
    }

    // ========== 适配器配置 ==========
    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() {
        // 构建搜索条件
        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 }
        )

        // 列表参数 (含分页)
        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)
                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()
            }
        }
    }
}
