VidiDin-Android/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt

package com.gamedog.vididin.manager

import com.ama.core.architecture.util.AndroidUtil
import com.ama.core.architecture.util.DateUtil
import com.ama.core.architecture.util.SpUtil
import com.ama.core.architecture.util.eventbus.NotifyMan
import com.gamedog.vididin.VididinEvents
import com.gamedog.vididin.manager.WithdrawManager.Companion.STATE_NEED_WATCH_AD


class WithdrawManager private constructor() {


    private val mItemList: MutableList<WithdrawItemBean> by lazy {
        val itemList = SpUtil.instance().getList<WithdrawItemBean>(SpUtil.KEY_WITHDRAW_ITEM_LIST).toMutableList()
        if (itemList.isEmpty()) {
            itemList.addAll(generateItemList())
            saveInfos2Sp(itemList)
        }
        itemList
    }


    companion object {
        const val EACH_SUB_ITEM_CASH_NUM: Float = 1F

        const val STATE_NEED_WATCH_AD: Int = 0
        const val STATE_COULD_WITHDRAW: Int = 1
        const val STATE_WITHDRAWING: Int = 2
        const val STATE_HAS_WITHDRAWED: Int = 3


        @Volatile
        private var instance: WithdrawManager? = null
        fun instance(): WithdrawManager {
            return instance ?: synchronized(this) {
                instance ?: WithdrawManager().also {
                    instance = it
                }
            }
        }
    }

    private fun generateItemList(): MutableList<WithdrawItemBean> {
        val itemList = mutableListOf<WithdrawItemBean>()
        itemList.add(WithdrawItemBean(0, 10F, AndroidUtil.randomInt(50, 70), generateSubItemList(10F)))
        itemList.add(WithdrawItemBean(1, 20F, AndroidUtil.randomInt(50, 70), generateSubItemList(20F)))
        itemList.add(WithdrawItemBean(2, 50F, AndroidUtil.randomInt(50, 70), generateSubItemList(50F)))
        itemList.add(WithdrawItemBean(3, 100F, AndroidUtil.randomInt(50, 70), generateSubItemList(100F)))
        itemList.add(WithdrawItemBean(4, 300F, AndroidUtil.randomInt(50, 70), generateSubItemList(300F)))
        return itemList
    }

    private fun generateSubItemList(totalCashInItem: Float): List<WithdrawSubItem> {
        val subItemList = mutableListOf<WithdrawSubItem>()
        val subItemCount: Int = (totalCashInItem/EACH_SUB_ITEM_CASH_NUM).toInt()

        for (i in 0..subItemCount-1) {
            val initProgress = AndroidUtil.randomInt(50, 70)
            subItemList.add(WithdrawSubItem(i, EACH_SUB_ITEM_CASH_NUM, initProgress, initProgress, 0F))
        }
        return subItemList
    }

    private fun saveInfos2Sp(itemList: MutableList<WithdrawItemBean>) {
        SpUtil.instance().putList(SpUtil.KEY_WITHDRAW_ITEM_LIST, itemList)
    }

    fun getItemList(): List<WithdrawItemBean> {
        return mItemList
    }

    fun getItem(itemIndex: Int): WithdrawItemBean {
        return mItemList[itemIndex]
    }


    fun addAdEarnForSubBean(itemIndex: Int, selectedSubIndex: Int, earnMoneyNum: Float) : Boolean {
        if (itemIndex >= 0 && itemIndex < mItemList.size) {
            try {
                val subBean = mItemList[itemIndex].subItemList[selectedSubIndex]
                subBean.hasEarnMoneyByAd += earnMoneyNum * 5 // dollar 2 bariz
                calculateSubBeanProgress(subBean)  //传入 itembean 更新 selectedIndex为下一个
                saveInfos2Sp(mItemList)
                notifyProgressUpdated(subBean)
                return true
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }

        return false
    }

    private fun notifyProgressUpdated(subBean: WithdrawSubItem) {
        NotifyMan.instance().sendEvent(VididinEvents.EVENT_WITHDRAW_SUB_ITEM_PROGRESS_UPDATED,
            NotifyMan.NotifyData(subBean.index))
    }

    private fun notifySelectedSubBeanChanged(subBean: WithdrawSubItem) {
        NotifyMan.instance().sendEvent(VididinEvents.EVENT_WITHDRAW_SELECTED_SUB_ITEM_CHANGED, NotifyMan.NotifyData(subBean.index))
    }

    private fun calculateSubBeanProgress(subBean: WithdrawSubItem) {
        val needEarnProgress = 100 - subBean.startProgress
        if (subBean.hasEarnMoneyByAd >= subBean.cashTotal) {
            subBean.currentProgress = 100
            // update state
            if (subBean.withdrawState == STATE_NEED_WATCH_AD) {
                subBean.withdrawState = STATE_COULD_WITHDRAW
            }
        } else {
            val newProgress = subBean.startProgress + (needEarnProgress * (subBean.hasEarnMoneyByAd / subBean.cashTotal)).toInt()
            subBean.currentProgress = if (newProgress >= 100) 99 else newProgress
        }
    }

    fun updateSubBeanState(subBean: WithdrawSubItem, newState: Int) {
        subBean.withdrawState = newState
        saveInfos2Sp(mItemList)
    }

    fun startItem(curItem: WithdrawItemBean) {
        if (curItem.startMs <= 0L) {
            curItem.startMs = DateUtil.getCurTimeMs()
            saveInfos2Sp(mItemList)
        }
    }

}


data class WithdrawItemBean(
    val index: Int,
    val totalCashNum: Float,
    var totalProgress: Int = 0,
    val subItemList: List<WithdrawSubItem> = emptyList(),
    var startMs: Long = 0L,
)

data class WithdrawSubItem(
    val index: Int,
    val cashTotal: Float,
    val startProgress: Int = 0,
    var currentProgress: Int = 0,
    var hasEarnMoneyByAd: Float = 0F,
    var withdrawState: Int = STATE_NEED_WATCH_AD,
)