package com.example.basecore.base

import androidx.lifecycle.ViewModel
import com.example.basecore.net.CODE_EXPIRED
import com.example.basecore.net.ex.ExceptionHandle
import com.example.basecore.net.http.BaseListResponse
import com.example.basecore.net.http.BaseResponseBean
import com.example.basecore.net.http.OssBaseResponse
import com.example.basecore.net.http.Result
import com.example.basecore.util.LogUtils


import kotlinx.coroutines.coroutineScope
import java.lang.Exception

/**
 * @Description  A ViewModel is alive longer than Activity or Fragment,
 * it should not reference a View, or any class that might hold a context reference to an Activity.
 *
 */
open class BaseViewModel : ViewModel() {

    suspend fun <T : Any> safeCall(
        call: suspend () -> Result<T>
    ): Result<T> {
        return try {
            call()
        } catch (e: Exception) {
            val ex = ExceptionHandle.handleException(e)
            Result.Error(ex)
        }
    }


    suspend fun <T : Any> execute(response: BaseResponseBean<T>): Result<T> {

        LogUtils.d("Thread = ${Thread.currentThread()}")
        return coroutineScope {
            when {
                response.isOk -> {
                    Result.Success(response.data)
                }

                response.isExpired -> {
                    Result.Expired(
                        CODE_EXPIRED
                    )
                }

                else -> {
                    Result.Error(
                        ExceptionHandle.ResponseThrowable(
                            Exception(response.errorMsg),
                            601
                        )
                    )
                }
            }
        }
    }


    suspend fun <T : Any> callList(response: BaseListResponse<T>): Result<List<T>> {

        return coroutineScope {
            when {
                response.isOk -> {
                    Result.Success(response.data)
                }

                response.isExpired -> {
                    Result.Expired(
                        CODE_EXPIRED
                    )
                }

                else -> {
                    Result.Error(
                        ExceptionHandle.ResponseThrowable(
                            Exception(response.errorMsg),
                            601
                        )
                    )
                }
            }
        }
    }


    suspend fun <T : Any> callNoResult(response: BaseResponseBean<T>): Result<T> {

        return coroutineScope {
            when {
                response.isOk -> {
                    Result.SuccessNone(response.status)
                }

                response.isExpired -> {
                    Result.Expired(
                        CODE_EXPIRED
                    )
                }

                else -> {
                    Result.Error(
                        ExceptionHandle.ResponseThrowable(
                            Exception(response.errorMsg),
                            601
                        )
                    )
                }
            }
        }
    }


    suspend fun callOSSToken(response: OssBaseResponse): Result<OssBaseResponse> {

        return coroutineScope {
            when {
                response.isOk -> {
                    Result.Success(response)
                }

                else -> {
                    Result.Error(
                        ExceptionHandle.ResponseThrowable(
                            Exception("未知错误"),
                            601
                        )
                    )
                }
            }
        }
    }

}