package com.example.smart.ui.options.device

import android.text.TextUtils
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.viewModelScope
import com.example.basecore.base.BaseContextViewModel
import com.example.basecore.net.http.Result
import com.example.basecore.util.toast
import com.example.smart.MyApp
import com.example.smart.bean.CommonOptionsBean
import com.example.smart.enumlist.DeviceType
import com.example.smart.reqeust.RetrofitClient
import com.example.smart.ui.options.device.bean.CreateDeviceInfo
import com.example.smart.ui.options.device.bean.DeviceParams
import com.example.smart.ui.options.device.bean.DeviceUsageBean
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.launch


class AddDeviceViewModel() : BaseContextViewModel() {

    val deviceUsageBean = MutableLiveData<List<DeviceUsageBean>>()

    val deviceFreeBean = MutableLiveData<List<CommonOptionsBean>>()

    val requestResult = MutableLiveData<String>()


    /**
     * 当前可用的设备列表
     */
    fun freeDevices(deviceType: DeviceType) {
        viewModelScope.launch(Dispatchers.Main) {
            val result = safeCall { callList(RetrofitClient.api.freeDevices(deviceType)) }
            if (result is Result.Success) {
                deviceFreeBean.value = result.data
            } else if (result is Result.Error) {
                MyApp.app.toast(result.exception.message ?: "未知错误")
            }
        }
    }

    /**
     * 设备申请使用需要填写的清单
     */
    fun callUsageDevices(deviceType: DeviceType) {
        viewModelScope.launch(Dispatchers.Main) {
            val result = safeCall { callList(RetrofitClient.api.deviceUsage(deviceType)) }
            if (result is Result.Success) {
                deviceUsageBean.value = result.data
            } else if (result is Result.Error) {
                MyApp.app.toast(result.exception.message ?: "未知错误")
            }
        }
    }


    /**
     * 安装设备
     */
    fun requestUseDevice(
        params: DeviceParams,
        deviceParams: CreateDeviceInfo,
        isEdit: Boolean,
        fail: (String) -> Unit
    ) {
        viewModelScope.launch(Dispatchers.Main) {
            val result = async {
                safeCall {
                    if (isEdit) {
                        callNoResult(RetrofitClient.api.editUseDevice(params))
                    } else {
                        callNoResult(RetrofitClient.api.requestUseDevice(params))
                    }
                }
            }

            val info = result.await()
            if(info is Result.Error){
                fail(info.exception.message ?: "修改错误")
                return@launch
            }

            if(isEdit) {
                val deviceResult = async {
                    safeCall { callNoResult(RetrofitClient.api.editDeviceInfo(deviceParams)) }
                }
                val deviceInfo = deviceResult.await()
                if (deviceInfo is Result.Error) {
                    fail(deviceInfo.exception.message ?: "更新设备信息错误")
                    return@launch
                }
            }

            if (info is Result.SuccessNone) {
                requestResult.value = info.status
            } else {
                fail("修改错误")
            }

//            if (result is Result.SuccessNone) {
//                requestResult.value = result.status
//            } else if (result is Result.Error) {
//                fail(result.exception.message ?: "未知错误")
//            }
        }
    }


    val deviceCreateInfo = MutableLiveData<List<DeviceUsageBean>>()

    /**
     * 创建新设备需要填写的表单
     */
    fun callCreateDeviceInfo(deviceType: DeviceType) {
        viewModelScope.launch(Dispatchers.Main) {
            val result = safeCall { callList(RetrofitClient.api.deviceCreateInfo(deviceType)) }
            if (result is Result.Success) {
                deviceCreateInfo.value = result.data
            } else if (result is Result.Error) {
                MyApp.app.toast(result.exception.message ?: "未知错误")
            }
        }
    }


    val deviceInfoBean = MutableLiveData<List<DeviceUsageBean>>()

    val createDeviceInfo = MutableLiveData<CreateDeviceInfo>()

    /**
     * 获取某个已有设备的表单，此时可修改
     */
    fun callDeviceInfoById(id: String, deviceType: DeviceType, fail: () -> Unit) {
        viewModelScope.launch(Dispatchers.Main) {
            //已有设备信息
            val infoResult =
                async {
                    safeCall { execute(RetrofitClient.api.deviceInfoById(id)) }
                }

            //表单信息
            val formInfo =
                async {
                    safeCall { callList(RetrofitClient.api.deviceCreateInfo(deviceType)) }
                }
            val data = infoResult.await()
            val formData = formInfo.await()

            if (formData is Result.Success) {
                val list = formData.data
                if (data is Result.Success) {
                    createDeviceInfo.value = data.data
                    val deviceInfo = data.data
                    list.forEach {
                        it.items.forEach { info ->
                            val s = deviceInfo.properties[info.name]
                            if (!TextUtils.isEmpty(s)) {
                                info.uploadContent = s
                            }
                        }
                    }
                }
                deviceInfoBean.value = list
            } else {
                fail()
            }

//            if (result is Result.Success) {
//                deviceInfoBean.value = result.data
//            } else if (result is Result.Error) {
//                MyApp.app.toast(result.exception.message ?: "未知错误")
//            }
        }
    }


    val createResult = MutableLiveData<String>()

    /**
     * 新建一个从未使用过的设备
     */
    fun createDevice(info: CreateDeviceInfo, fail: (String) -> Unit) {
        viewModelScope.launch(Dispatchers.Main) {
            val result = safeCall { callNoResult(RetrofitClient.api.deviceAdd(info)) }
            if (result is Result.SuccessNone) {
                createResult.value = "ok"
            } else if (result is Result.Error) {
                fail(result.exception.message ?: "未知错误")
            }
        }
    }
}