package ru.nvtech.sedkp.documents

import android.arch.persistence.room.EmptyResultSetException
import android.util.Base64
import com.androidnetworking.error.ANError
import com.crashlytics.android.Crashlytics
import io.reactivex.Observable
import io.reactivex.SingleSource
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
import ru.nvtech.sedkp.base.BasePresenter
import ru.nvtech.sedkp.domain.model.CachedRequest
import ru.nvtech.sedkp.domain.model.Filter
import ru.nvtech.sedkp.domain.model.FilterNameType
import ru.nvtech.sedkp.domain.model.FilterType
import ru.nvtech.sedkp.domain.model.network.DocumentsInfoList
import ru.nvtech.sedkp.domain.repository.AuthProvider
import ru.nvtech.sedkp.domain.usecases.*
import ru.nvtech.sedkp.extentions.timberError
import timber.log.Timber
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.net.UnknownHostException
import javax.inject.Inject

class DocumentsPresenter @Inject constructor(private val documentsUseCase: DocumentsUseCase,
                                             private val filterUseCase: FilterUseCase,
                                             private val settingsUseCase: SettingsUseCase,
                                             private val authUseCase: AuthUseCase,
                                             private val authProvider: AuthProvider,
                                             private val docInfoUseCase: DocInfoUseCase,
                                             private val cachedRequestUseCase: CachedRequestUseCase)
    : BasePresenter<DocumentsContract.View>(), DocumentsContract.Presenter {

    private lateinit var filter: Filter
    var isSettingComplete: Boolean = false
    lateinit var documentsInfoList: DocumentsInfoList
    private var docInfoList: MutableList<DocumentsInfoList.DocInfo> = mutableListOf()


    override fun authProcess() {
        viewMVP?.showProgressBar(true)
        disposables.add(settingsUseCase.getSettings()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    getFilterFromBD()
                    if (it.login.isNotBlank() and it.password.isNotBlank() and (it.localEndpoint.isNotBlank() or it.remoteEndpoint.isNotBlank())) {
                        authProvider.putCredentials("Basic ${Base64.encodeToString("${it.login}:${it.password}".toByteArray(), Base64.NO_WRAP)}")
                        authorisation(it.remoteEndpoint, it.localEndpoint)
                        isSettingComplete = true
                    } else {
                        viewMVP?.showProgressBar(false)
                        viewMVP?.showAlertSettingsDialog()
                        isSettingComplete = false
                    }
                }, {
                    viewMVP?.showProgressBar(false)

                    if (it::class.java == EmptyResultSetException::class.java) {
                        viewMVP?.openSettings()
                        isSettingComplete = false
                    } else {
                        viewMVP?.onLoadError("Ошибка загрузки документов")
                        timberError(it)
                    }

                }))
    }

    private fun authorisation(remoteEndpoint: String, localEndpoint: String) {
        disposables.add(authUseCase.authorisation(remoteEndpoint)
                .onErrorResumeNext {
                    val err = it
                    //TODO("добавить логику обработки ошибок тут/ либо в репозитории")
                    if (it.cause != null) {
                        when (it.cause!!::class.java) {
                            ConnectException::class.java,
                            SocketTimeoutException::class.java,
                            UnknownHostException::class.java ->
                                return@onErrorResumeNext authUseCase.authorisation(localEndpoint)
                            else -> {
                                return@onErrorResumeNext SingleSource { observer -> observer.onError(err) }
                            }
                        }
                    } else {

                        return@onErrorResumeNext SingleSource { observer -> observer.onError(err) }
                    }

                }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    authProvider.putUserId(it.userId)
                    loadDocuments()
                }, {
                    authProvider.setEmpty()
                    viewMVP?.showProgressBar(false)
                    timberError(it)
                    Crashlytics.logException(it)
                    if (it.cause != null) {
                        when (it.cause!!::class.java) {
                            ConnectException::class.java,
                            SocketTimeoutException::class.java,
                            UnknownHostException::class.java -> {
                                viewMVP?.onLoadError("Ошибка подключения к серверу")
                            }
                            else -> {
                                viewMVP?.onLoadError("Ошибка авторизации")
                            }
                        }
                    } else {
                        viewMVP?.onLoadError("Ошибка авторизации")

                    }

                }))
    }


    override fun loadDocuments(offset: Int) {
        viewMVP?.setTitle(filter)
        if (offset == 0) docInfoList.clear()

        if (filter.filterMap.containsKey(FilterType.CATEGORY).and(filter.filterMap[FilterType.CATEGORY] == FilterNameType.LAST_SEEN)) {
            viewMVP?.showProgressBar(true)
            disposables.add(docInfoUseCase.getDocInfoList()
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(
                            {
                                val doc = DocumentsInfoList(docs = it.toMutableList(), offset = offset, portion = 0, count = it.size)

                                docInfoList.clear()
                                documentsInfoList = doc.copy()
                                docInfoList.addAll(doc.docs)
                                documentsInfoList.docs = docInfoList
                                viewMVP?.onLoadDocumentsSuccess(documentsInfoList)
                                restoreCacheRequest()
                            },
                            {
                                viewMVP?.showProgressBar(false)
                                viewMVP?.onLoadError("Ошибка загрузки документов")

                                timberError(it)
                            })
            )
            return
        }

        if (authProvider.getUserId() == null) {
            authProcess()
        } else {
            viewMVP?.showProgressBar(true)
            disposables.add(documentsUseCase.getDocs(filter, offset)
                    .onErrorResumeNext {
                        //                        authProvider.setEmpty()
                        authProcess()
                        return@onErrorResumeNext SingleSource { observer -> observer.onError(it) }
                    }
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(
                            {
                                documentsInfoList = it.copy()
                                docInfoList.addAll(it.docs)
                                documentsInfoList.docs = docInfoList
                                viewMVP?.onLoadDocumentsSuccess(documentsInfoList)
                                restoreCacheRequest()
                                //TODO("FOR TESTING")
                                //checkGson(it.docs)
                            },
                            {
                                viewMVP?.onLoadError("Ошибка загрузки документов")
                                timberError(it)
                            })
            )
        }
    }

}