yinmeng-android/app/src/main/java/com/mango/moshen/home/HomeViewModel.kt

package com.mango.moshen.home

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.mango.moshen.base.BaseViewModel
import com.mango.core.bean.response.ListResult
import com.mango.core.home.bean.BannerInfo
import com.mango.core.home.bean.HomeRoomInfo
import com.mango.core.home.bean.HomeTagInfo
import com.mango.core.home.bean.ResourceInfo
import com.mango.core.home.model.HomeModel
import com.mango.core.room.bean.AnchorInfo
import com.mango.core.room.bean.HomeLiveTopInfo
import com.mango.core.room.bean.SingleRoomSortInfo
import com.mango.core.statistic.StatisticManager
import com.mango.core.statistic.protocol.StatisticsProtocol
import com.mango.core.utils.toast
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async

class HomeViewModel : BaseViewModel() {

    private val _bannerLiveData = MutableLiveData<List<BannerInfo>>()
    val bannerLiveData: LiveData<List<BannerInfo>> = _bannerLiveData

    private val _hotRoomLiveData = MutableLiveData<ListResult<HomeRoomInfo>>()
    val hotRoomLiveData: LiveData<ListResult<HomeRoomInfo>> = _hotRoomLiveData

    private val _gameRoomLiveData = MutableLiveData<ListResult<HomeRoomInfo>>()
    val gameRoomLiveData: LiveData<ListResult<HomeRoomInfo>> = _gameRoomLiveData

    private val _pickRoomLiveData = MutableLiveData<HomeRoomInfo>()
    val pickRoomLiveData: LiveData<HomeRoomInfo> = _pickRoomLiveData

    private val _openGameRoomLiveData = MutableLiveData<Long>()
    val openGameRoomLiveData: LiveData<Long> = _openGameRoomLiveData

    private val _concernsLiveData = MutableLiveData<List<HomeRoomInfo>>()
    val concernsLiveData: LiveData<List<HomeRoomInfo>> = _concernsLiveData

    private val _collectLiveData = MutableLiveData<ListResult<HomeRoomInfo>>()
    val collectLiveData: LiveData<ListResult<HomeRoomInfo>> = _collectLiveData

    private val _tagLiveData = MutableLiveData<List<HomeTagInfo>>()
    val tagLiveData: LiveData<List<HomeTagInfo>> = _tagLiveData

    private val _emptyLiveData = MutableLiveData<Boolean>()
    val emptyLiveData: LiveData<Boolean> = _emptyLiveData

    private val _resourceLiveData = MutableLiveData<List<ResourceInfo>>()
    val resourceLiveData: LiveData<List<ResourceInfo>> = _resourceLiveData

    private val _resourceJumpLiveData = MutableLiveData<HomeRoomInfo>()
    val resourceJumpLiveData: LiveData<HomeRoomInfo> = _resourceJumpLiveData

    private val _singleAnchorHomeLiveData = MutableLiveData<ListResult<HomeRoomInfo>>()
    val singleAnchorHomeLiveData: LiveData<ListResult<HomeRoomInfo>> = _singleAnchorHomeLiveData


    private val _singleRoomSortInfoLiveData = MutableLiveData<ListResult<SingleRoomSortInfo>>()
    val singleRoomSortInfoLiveData: LiveData<ListResult<SingleRoomSortInfo>> =
        _singleRoomSortInfoLiveData

    private val _homeLiveTopInfoLiveData = MutableLiveData<HomeLiveTopInfo>()
    val homeLiveTopInfoLiveData: LiveData<HomeLiveTopInfo> = _homeLiveTopInfoLiveData

    private val _anchorInfoLiveData = MutableLiveData<AnchorInfo>()
    val anchorInfoLiveData: LiveData<AnchorInfo> = _anchorInfoLiveData

    fun getBannerInfo() {
        safeLaunch {
            _bannerLiveData.value = HomeModel.getHomeBanner("9")
        }
    }

    fun getTagInfo() {
        safeLaunch {
            _tagLiveData.value = HomeModel.getHomeTag()
        }
    }

    fun getHomeResource() {
        safeLaunch {
            _resourceLiveData.value = HomeModel.getHomeResource()
        }
    }

    fun getResourceJumpInfo(id: Int) {
        safeLaunch(
            onError = {
                _resourceJumpLiveData.value = null
                it.message.toast()
            },
            block = {
                _resourceJumpLiveData.value = HomeModel.getResourceJumpInfo(id)
            }
        )

    }

    fun getHotRoom(pageNum: Int, pageSize: Int) {
        safeLaunch(
            onError = {
                _hotRoomLiveData.value = ListResult.failed(pageNum)
            },
            block = {
                val result = HomeModel.getHotRoom()
                _hotRoomLiveData.value = ListResult.success(result, pageNum)
            }
        )
    }


    fun getGameRoom(pageNum: Int, pageSize: Int) {
        safeLaunch(
            onError = {
                _gameRoomLiveData.value = ListResult.failed(pageNum)
            },
            block = {
                val result = HomeModel.getGameRoom(pageNum, pageSize)
                _gameRoomLiveData.value = ListResult.success(result, pageNum)
            }
        )
    }

    fun fastPickGameRoom(mgId: Long? = null) {
        safeLaunch(
            onError = {
                it.message.toast()
                StatisticManager.Instance()
                    .onEvent(
                        StatisticsProtocol.EVENT_USERCENTER_QUICK_ENTRYSUCCESS_CLICK,
                        "个人中心快捷进房点击未匹配成功"
                    )
            },
            block = {
                val homeRoomInfo = HomeModel.fastPickGameRoom(mgId)
                if (homeRoomInfo?.isPick == true) {
                    _pickRoomLiveData.value = homeRoomInfo
                } else if (homeRoomInfo?.isNeedOpenSelfRoom == true) {
                    _openGameRoomLiveData.value = mgId
                }
            }
        )
    }


    fun getCollectRoom(pageNum: Int, pageSize: Int) {
        safeLaunch(
            onError = {
                _collectLiveData.value = ListResult.failed(pageNum)
                _emptyLiveData.value = true
            },
            block = {
                if (pageNum == 1) {
                    val concernsRooms = async(Dispatchers.IO) {
                        try {
                            HomeModel.getConcernsRoom()
                        } catch (e: Throwable) {
                            null
                        }
                    }
                    val collectRooms = async(Dispatchers.IO) {
                        try {
                            HomeModel.getCollectRoom(pageNum, pageSize)
                        } catch (e: Throwable) {
                            null
                        }
                    }
                    _concernsLiveData.value = concernsRooms.await()
                    val collectList = collectRooms.await()
                    if (collectList == null) {
                        _collectLiveData.value = ListResult.failed(pageNum)
                    } else {
                        _collectLiveData.value =
                            ListResult.success(collectList.fansRoomList, pageNum)
                    }
                    _emptyLiveData.value = _concernsLiveData.value.isNullOrEmpty() &&
                            _collectLiveData.value?.data.isNullOrEmpty()
                } else {
                    val result = HomeModel.getCollectRoom(pageNum, pageSize)
                    _collectLiveData.value = ListResult.success(result?.fansRoomList, pageNum)
                }

            }
        )
    }

    fun requestSingleRoomSortList() {
        safeLaunch(
            onError = {
                //保证最少有一个推荐tab,防止出现空白页
                _singleRoomSortInfoLiveData.value =
                    ListResult.success(listOf(SingleRoomSortInfo(null, "推荐")), 1)
            },
            block = {
                val result = HomeModel.requestSingleRoomSortList()
                val fullResult = ArrayList<SingleRoomSortInfo>()
                fullResult.add(SingleRoomSortInfo(null, "推荐"))
                result?.let { fullResult.addAll(it) }
                _singleRoomSortInfoLiveData.value = ListResult.success(fullResult, 1)
            }
        )
    }

    fun getHomeSingleAnchorList() {
        safeLaunch(
            onError = {
                _singleAnchorHomeLiveData.value = ListResult.failed(1)
            },
            block = {
                val result = HomeModel.getHomeSingleAnchorList()
                _singleAnchorHomeLiveData.value = ListResult.success(
                    if ((result?.size ?: 0) > 4) {
                        result?.subList(0, 4)
                    } else {
                        result
                    }, 1
                )
            }
        )
    }

    fun requestHomeLiveTopInfo() {
        safeLaunch(
            onError = {
                _homeLiveTopInfoLiveData.value = null
            },
            block = {
                _homeLiveTopInfoLiveData.value = HomeModel.requestHomeLiveTopInfo()
            }
        )
    }

    fun requestAnchorInfo() {
        safeLaunch(
            onError = {
                _anchorInfoLiveData.value = null
            },
            block = {
                _anchorInfoLiveData.value = HomeModel.requestAnchorInfo()
            }
        )
    }


}