package com.gyf.csams.activity.model

import android.app.Application
import android.net.Uri
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.gson.reflect.TypeToken
import com.gyf.csams.MainApplication
import com.gyf.csams.module.*
import com.gyf.csams.uikit.AbstractComment
import com.gyf.csams.uikit.ActivityDetailMenu
import com.gyf.csams.uikit.TopMenuInterface
import com.gyf.lib.model.ScrollViewModel
import com.gyf.lib.uikit.ValidStringForm
import com.gyf.lib.util.*
import kotlinx.coroutines.launch
import java.io.File

/**
 * 活动详情菜单通用状态
 *
 */
class ActivityDetailViewModel : ViewModel(), TopMenuInterface<ActivityDetailMenu> {
    override val _currentMenu: MutableLiveData<ActivityDetailMenu> = MutableLiveData()
    override val currentMenu: LiveData<ActivityDetailMenu> = _currentMenu
}


/**
 * 活动信息
 *
 */
class ActivityInfoViewModel : ViewModel() {
    private val _activityDetailVo = MutableLiveData<ActivityDetailVo>()
    val activityDetailVo: LiveData<ActivityDetailVo> = _activityDetailVo

    val tendency = MutableLiveData<CheckTendencyResVo>()

    fun checkTendency(activityId: Int) {
        viewModelScope.launch {
            HttpClient.post(url = Api.buildUrl(ActivityApi.CheckTendency),
                callback = HttpCallback<CheckTendencyResVo>(action = "检查用户倾向",
                    onSuccess = {
                        it.body?.apply { tendency.postValue(this) }
                    }, typeToken = object : TypeToken<ApiResponse<CheckTendencyResVo>>() {}.type
                ),
                jsonParam =
                CheckTendencyVo(activityId = activityId, token = TokenManager.getToken())
            )
        }
    }

    /**
     * 记录用户倾向
     *
     * @param type
     * @param activityId
     * @param callback
     */
    fun tendency(type: TendencyType, activityId: Int, callback: (flag: Boolean) -> Unit) {
        viewModelScope.launch {
            HttpClient.post(url = Api.buildUrl(ActivityApi.Tendency),
                callback = HttpCallback<Boolean>(action = "记录用户倾向",
                    onSuccess = {
                        it.body?.let(callback)
                    }, typeToken = object : TypeToken<ApiResponse<Boolean>>() {}.type
                ),
                jsonParam =
                TendencyVo(activityId = activityId, type = type, token = TokenManager.getToken())
            )
        }
    }

    /**
     * 加载活动详情
     *
     * @param activityId
     */
    fun load(activityId: Int) {
        viewModelScope.launch {
            HttpClient.post(url = Api.buildUrl(ActivityApi.Show),
                callback = HttpCallback<ActivityDetailVo>(action = "加载活动详情",
                    onSuccess = { it ->
                        it.body?.let {
                            _activityDetailVo.postValue(it)
                        }
                    }, typeToken = object : TypeToken<ApiResponse<ActivityDetailVo>>() {}.type
                ),
                jsonParam = ShowActivityVo(activityId = activityId, token = TokenManager.getToken())
            )
        }
    }

}


/**
 * 活动相册数据状态管理
 *
 */
class ActivityPhotoViewModel(application: Application) :
    ScrollViewModel<ActivityPhotoVo>(application) {

    val name = ValidStringForm("照片名", textLength = 10)

    /**
     * 上传照片
     *
     * @param uri
     */
    fun upload(activityId: Int, uri: Uri, callback: (message: String) -> Unit) {
        val resolver = getApplication<MainApplication>().contentResolver
        resolver.openInputStream(uri)?.readBytes()?.apply {
            name.clean()
            viewModelScope.launch {
                val context = getApplication<MainApplication>()
                runCatching {
                    val cacheFile = File(context.cacheDir, "${System.currentTimeMillis()}")
                    cacheFile.writeBytes(this@apply)
                    HttpClient.uploadFile(url = Api.buildUrl(ActivityApi.UploadPhoto),
                        callback = HttpCallback<Boolean>(action = "上传照片",
                            onSuccess = {
                                callback("上传成功")
                            }, typeToken = object : TypeToken<ApiResponse<Boolean>>() {}.type
                        ),
                        params = mapOf(
                            "activityId" to "$activityId",
                            "name" to name.getValue()
                        ),
                        fileList = arrayOf(cacheFile)
                    )
                }
            }

        }
    }

    /**
     * 加载相册
     *
     */
    fun load(activityId: Int) {
        viewModelScope.launch {
            HttpClient.post(
                url = Api.buildUrl(ActivityApi.Photo),
                callback = HttpCallback<MutableList<ActivityPhotoVo>>(
                    action = "加载相册",
                    onSuccess = {
                        _data.postValue(it.body)
                    },
                    typeToken = object :
                        TypeToken<ApiResponse<MutableList<ActivityPhotoVo>>>() {}.type
                ),
                jsonParam = SearchActivityPhotoVo(activityId = activityId)
            )
        }
    }
}


class ActivityMemberViewModel(application: Application) :
    ScrollViewModel<UserInfoVo>(application) {


}

class BBSCommentModel : AbstractComment() {
    override val newContent = ValidStringForm(formDesc = "评论内容", textLength = 80)

    var activityId: Int? = null


    /**
     * 发送评论
     * @param callback
     */
    override fun send(callback: (message: String) -> Unit) {
        viewModelScope.launch {
            HttpClient.post(url = Api.buildUrl(ActivityApi.SendComment),
                callback = HttpCallback<Boolean>(action = "发送评论",
                    onSuccess = {
                        callback(it.message)
                    }, typeToken = object : TypeToken<ApiResponse<Boolean>>() {}.type
                ),
                jsonParam =
                SendBBSVo(
                    content = newContent.getValue(),
                    token = TokenManager.getToken(),
                    activityId = activityId ?: throw IllegalArgumentException("活动id没有初始化")
                )
            )
        }
    }
}

/**
 * 交流区数据状态管理
 *
 */
class BBSViewModel(application: Application) : ScrollViewModel<BBSVo>(application) {


    /**
     * 加载评论
     */
    fun load(activityId: Int) {
        viewModelScope.launch {
            HttpClient.post(url = Api.buildUrl(ActivityApi.Comment),
                callback = HttpCallback<MutableList<BBSVo>>(action = "加载评论",
                    onSuccess = {
                        _data.postValue(it.body)
                    }, typeToken = object : TypeToken<ApiResponse<MutableList<BBSVo>>>() {}.type
                ),
                jsonParam = SearchCommentVo(activityId = activityId)
            )
        }
    }
}