package kr.co.vividnext.sodalive.live.reservation_status

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.orhanobut.logger.Logger
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.schedulers.Schedulers
import kr.co.vividnext.sodalive.base.BaseViewModel
import kr.co.vividnext.sodalive.common.SharedPreferenceManager
import kr.co.vividnext.sodalive.live.LiveRepository

class LiveReservationStatusViewModel(
    private val repository: LiveRepository
) : BaseViewModel() {

    private val _liveReservationStatusLiveData = MutableLiveData<List<GetLiveReservationResponse>>()
    val liveReservationStatusLiveData: LiveData<List<GetLiveReservationResponse>>
        get() = _liveReservationStatusLiveData

    private val _toastLiveData = MutableLiveData<String?>()
    val toastLiveData: LiveData<String?>
        get() = _toastLiveData

    private var _isLoading = MutableLiveData(false)
    val isLoading: LiveData<Boolean>
        get() = _isLoading

    var reservationId: Long = 0
    var reason: String = ""

    fun getLiveReservationStatus(isActive: Boolean) {
        if (!_isLoading.value!!) {
            _isLoading.value = true
            compositeDisposable.add(
                repository.getReservations(isActive, "Bearer ${SharedPreferenceManager.token}")
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(
                        {
                            if (it.success && it.data != null) {
                                _liveReservationStatusLiveData.postValue(it.data!!)
                            } else {
                                if (it.message != null) {
                                    _toastLiveData.postValue(it.message)
                                } else {
                                    _toastLiveData.postValue(
                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
                                    )
                                }
                            }
                            _isLoading.value = false
                        },
                        {
                            _isLoading.value = false
                            it.message?.let { message -> Logger.e(message) }
                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
                        }
                    )
            )
        }
    }

    fun getReservation(onSuccess: (GetLiveReservationResponse) -> Unit) {
        if (!_isLoading.value!!) {
            _isLoading.value = true
            compositeDisposable.add(
                repository.getReservation(reservationId, "Bearer ${SharedPreferenceManager.token}")
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(
                        {
                            if (it.success && it.data != null) {
                                onSuccess(it.data)
                            } else {
                                if (it.message != null) {
                                    _toastLiveData.postValue(it.message)
                                } else {
                                    _toastLiveData.postValue(
                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
                                    )
                                }
                            }
                            _isLoading.value = false
                        },
                        {

                            _isLoading.value = false
                            it.message?.let { message -> Logger.e(message) }
                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
                        }
                    )
            )
        }
    }

    fun cancelReservation(onSuccess: () -> Unit) {
        if (!_isLoading.value!!) {
            if (reason.isBlank()) {
                _toastLiveData.postValue("취소이유를 선택해주세요.")
                return
            }

            _isLoading.value = true
            compositeDisposable.add(
                repository.cancelReservation(
                    CancelLiveReservationRequest(reservationId, reason),
                    "Bearer ${SharedPreferenceManager.token}"
                ).subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(
                        {
                            if (it.success) {
                                _toastLiveData.postValue("라이브 예약이 취소되었습니다.")
                                onSuccess()
                            } else {
                                if (it.message != null) {
                                    _toastLiveData.postValue(it.message)
                                } else {
                                    _toastLiveData.postValue(
                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
                                    )
                                }
                            }
                            _isLoading.value = false
                        },
                        {
                            _isLoading.value = false
                            it.message?.let { message -> Logger.e(message) }
                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
                        }
                    )
            )
        }
    }
}
