package kr.co.vividnext.sodalive.user

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.report.ReportRepository
import kr.co.vividnext.sodalive.report.ReportRequest
import kr.co.vividnext.sodalive.report.ReportType

class UserViewModel(
    private val repository: UserRepository,
    private val reportRepository: ReportRepository
) : BaseViewModel() {
    private val _memberProfile = MutableLiveData<GetMemberProfileResponse>()
    val memberProfile: LiveData<GetMemberProfileResponse>
        get() = _memberProfile

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

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

    fun getMemberProfile(id: Long, onSuccess: () -> Unit) {
        _isLoading.value = true

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

    fun memberBlock(memberId: Long, onSuccess: () -> Unit) {
        _isLoading.value = true
        compositeDisposable.add(
            repository.memberBlock(
                userId = memberId,
                token = "Bearer ${SharedPreferenceManager.token}"
            )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(
                    {
                        _isLoading.value = false

                        if (it.success) {
                            _toastLiveData.postValue("차단하였습니다.")
                            onSuccess()
                        } else {
                            val message = it.message ?: "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
                            _toastLiveData.postValue(message)
                        }
                    },
                    {
                        _isLoading.value = false
                        it.message?.let { message -> Logger.e(message) }
                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
                    }
                )
        )
    }

    fun memberUnBlock(memberId: Long, onSuccess: () -> Unit) {
        _isLoading.value = true
        compositeDisposable.add(
            repository.memberUnBlock(
                userId = memberId,
                token = "Bearer ${SharedPreferenceManager.token}"
            )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(
                    {
                        _isLoading.value = false

                        if (it.success) {
                            _toastLiveData.postValue("차단이 해제 되었습니다.")
                            onSuccess()
                        } else {
                            val message = it.message ?: "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
                            _toastLiveData.postValue(message)
                        }
                    },
                    {
                        _isLoading.value = false
                        it.message?.let { message -> Logger.e(message) }
                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
                    }
                )
        )
    }

    fun report(
        type: ReportType,
        userId: Long,
        reason: String = "프로필 신고",
        onSuccess: () -> Unit
    ) {
        _isLoading.value = true

        val request = ReportRequest(type, reason, reportedMemberId = userId)
        compositeDisposable.add(
            reportRepository.report(
                request = request,
                token = "Bearer ${SharedPreferenceManager.token}"
            )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(
                    {
                        if (it.message != null) {
                            _toastLiveData.postValue(it.message)
                        } else {
                            _toastLiveData.postValue(
                                "신고가 접수되었습니다."
                            )
                        }

                        _isLoading.value = false
                        onSuccess()
                    },
                    {
                        _isLoading.value = false
                        it.message?.let { message -> Logger.e(message) }
                        _toastLiveData.postValue("신고가 접수되었습니다.")
                        onSuccess()
                    }
                )
        )
    }
}
