import android.arch.lifecycle.MutableLiveData
import android.util.Log
import com.jakewharton.retrofit2.adapter.kotlin.coroutines.experimental.CoroutineCallAdapterFactory
import kotlinx.coroutines.experimental.android.UI
import kotlinx.coroutines.experimental.async
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Call
import retrofit2.http.*
import ru.gildor.coroutines.retrofit.Result
import ru.gildor.coroutines.retrofit.awaitResult

object ServerAPI {

    var API_BASE_URL: String = getNetworkHost();
    var httpClient = OkHttpClient.Builder().addInterceptor(
        HttpLoggingInterceptor().apply {
            level = if (BuildConfig.DEBUG) HttpLoggingInterceptor.Level.BODY else HttpLoggingInterceptor.Level.NONE
        })

    var builder: Retrofit.Builder = Retrofit.Builder()
            .baseUrl(API_BASE_URL)
            .addCallAdapterFactory(CoroutineCallAdapterFactory())
            .addConverterFactory(GsonConverterFactory.create())

    var retrofit = builder
            .client(httpClient.build())
            .build()

    var netService = retrofit.create<NetService>(
        NetService::class.java!!)

    interface NetService {
        @GET("api/stores")
        fun getStoreAll(@Header("Authorization") bearer: String): Call<Array<Store>>
    }
}

   class Repository {

    fun getStores(token: String)  :  MutableLiveData<Resource<Array<Store>>>{
        val mutableLiveData = MutableLiveData<Resource<Array<Store>>>()
        mutableLiveData.value = Resource.loading(null)
        val req = PostsAPI.netService.getStoreAll(token)

        try {
            async(UI) {
                val result = req.awaitResult()
                // Check result type
                when (result) {
                    //Successful HTTP result
                    is Result.Ok -> {
                        mutableLiveData.value = Resource.success(result.value)
                    }
                    // Any HTTP error
                    is Result.Error -> {
                        mutableLiveData.value  = Resource.error("Http Error!", null)
                    }
                    // Exception while request invocation
                    is Result.Exception -> Log.d(TAG, result.exception.message)
                }
            }
        } catch (e: Exception) {
            Log.d(TAG, e.toString())
        }
        return mutableLiveData
    }
}
     

// A generic class that contains data and status about loading this data.
public class Resource<T> {
    @NonNull public final Status status;
    @Nullable public final T data;
    @Nullable public final String message;
    private Resource(@NonNull Status status, @Nullable T data,
            @Nullable String message) {
        this.status = status;
        this.data = data;
        this.message = message;
    }

    public static <T> Resource<T> success(@NonNull T data) {
        return new Resource<>(Status.SUCCESS, data, null);
    }

    public static <T> Resource<T> error(String msg, @Nullable T data) {
        return new Resource<>(Status.ERROR, data, msg);
    }

    public static <T> Resource<T> loading(@Nullable T data) {
        return new Resource<>(Status.LOADING, data, null);
    }

    public enum Status { SUCCESS, ERROR, LOADING }
}
      

class StoresViewModel (context: Context, token: String) : ViewModel() {
    val stores: MutableLiveData<Resource<Array<Store>>>
    init {
        val api = Repository()
        stores = api.getStores(token)
    }
}
      

class AppViewModelFactory(private val contect: Context, vararg params: Any) :
    ViewModelProvider.NewInstanceFactory() {
    private val mParams: Array<out Any>

    init {
        mParams = params
    }

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return if (modelClass == LoginViewModel::class.java) {
            LoginViewModel(contect, mParams[0] as String, mParams[1] as String) as T
        } else if (modelClass == StoresViewModel::class.java) {
            StoresViewModel(contect, mParams[0] as String) as T
        } else {
            super.create(modelClass)
        }
    }
}
      

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        val view = inflater.inflate(R.layout.stores_fragment, container, false)

        val tokenHolder = TokenHolder(PreferenceManager.getDefaultSharedPreferences(requireActivity()))

        viewModel = ViewModelProviders.of(this, AppViewModelFactory(requireActivity(), tokenHolder.token)).get(StoresViewModel::class.java)

        recyclerView = view.findViewById<RecyclerView>(R.id.store_list).apply {
            setHasFixedSize(true)
        }
        return view
    }


    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        // Observe data on the ViewModel, exposed as a LiveData
        viewModel.stores.observe(this, Observer<Resource<Array<Store>>> { storesResource ->

            val stores = storesResource?.data
            stores?.let {
                viewAdapter = StoresAdapter(stores!!)
                recyclerView.adapter = viewAdapter
            }

            if (storesResource?.status  == Resource.LOADING){
                log("Loading...")
            }

            if (storesResource?.status  == Resource.ERROR){
                log("Error : " + storesResource?.message)
            }

        })
    }