class DataSource(
    val myAdvancedSearch: myAdvancedSearch,
    var query: String
) : PageKeyedDataSource<Int, Model>() {

    companion object {
        const val pageSize = 10
        const val initialLoad = pageSize * 2
        const val prefetchDistance = pageSize / 2

        var data: List<Model>? = null

    }

    val emptyStateLiveData = MutableLiveData<Boolean>()
    val networkStateLiveData = MutableLiveData<NetworkState>()
    private val initialLoadingLiveData = MutableLiveData<NetworkState>()



    override fun loadInitial(params: LoadInitialParams<Int>, callback: LoadInitialCallback<Int, Model>) {
        initialLoadingLiveData.postValue(LOADING)
        networkStateLiveData.postValue(LOADING)

        query = MyFragment.query

        myAdvancedSearch
            .searchData(
                searchTerm = query,
                perPage = initialLoad
            )
            .subscribeOn(Schedulers.io())
            .map {
                it.items.map { item -> Model(item) }
            }
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                initialLoadingLiveData.postValue(LOADED)
                networkStateLiveData.postValue(LOADED)
            },{
                initialLoadingLiveData.postValue(NetworkState.failed(it.localizedMessage))
                networkStateLiveData.postValue(NetworkState.failed(it.localizedMessage))
            })

    }


    override fun loadAfter(params: LoadParams<Int>, callback: LoadCallback<Int, Model>) {
        networkStateLiveData.postValue(LOADING)

        myAdvancedSearch
            .searchData(
                searchTerm = query,
                perPage = initialLoad
            )
            .subscribeOn(Schedulers.io())
            .map {
                it.items.map { item -> Model(item) }
            }
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                networkStateLiveData.postValue(LOADED)

            },{
                networkStateLiveData.postValue(NetworkState.failed(it.localizedMessage))
            })
    }

    override fun loadBefore(params: LoadParams<Int>, callback: LoadCallback<Int, Model>) {}


    class NetworkState(val status: Status, val message: String) {

        enum class Status {
            RUNNING, SUCCESS, FAILED
        }

        companion object {
            val LOADED = NetworkState(Status.SUCCESS, "Success")
            val LOADING = NetworkState(Status.RUNNING, "Running")

            fun failed(errorMessage: String): NetworkState {
                return NetworkState(Status.FAILED, errorMessage)
            }
        }
    }
}