package com.mygdx.game.retrofit;

import com.google.gson.Gson;
import com.mygdx.game.AndroidInterface;
import com.mygdx.game.AuthToken;
import com.mygdx.game.FileFromServer;
import com.mygdx.game.ModelBody;
import com.mygdx.game.RegistrationBody;

import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;

public class RetrofitRequests {

    private final static String LOG_TAG = RetrofitRequests.class.getSimpleName();
    private final static String SD_HD = "SD/HD";
    private final static String APPLICATION_JSON = "application/json";
    private final static String USERNAME = "figuro5";
    private final static String PASSWORD = "figuro5pass1";

    private LoadingService loadingService;
    private FiguromoApiService figuromoApiService;
    private String authToken;
    private Gson gson;

    public RetrofitRequests() {

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://colorcloud.figuromomodels.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

        figuromoApiService = retrofit.create(FiguromoApiService.class);

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://models.figuromomodels.com")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();


        loadingService = retrofit.create(LoadingService.class);
    }

    public Observable<FileFromServer> loadAtlas(final String fileName, boolean isHd){

        if (isHd) {
            return loadingService
                    .loadHDAtlas(fileName)
                    .subscribeOn(Schedulers.io())
                    .map(new Function<ResponseBody, FileFromServer>() {
                        @Override
                        public FileFromServer apply(ResponseBody responseBody) throws Exception {
                            return new FileFromServer(responseBody, fileName);
                        }
                    });
        } else {
            return loadingService
                    .loadSDAtlas(fileName)
                    .subscribeOn(Schedulers.io())
                    .map(new Function<ResponseBody, FileFromServer>() {
                        @Override
                        public FileFromServer apply(ResponseBody responseBody) throws Exception {
                            return new FileFromServer(responseBody, fileName);
                        }
                    });
        }
    }

    public Observable<FileFromServer> loadFile(final String fileName) {

        return loadingService
                .loadRegularFile(fileName)
                .subscribeOn(Schedulers.io())
                .map(new Function<ResponseBody, FileFromServer>() {
                    @Override
                    public FileFromServer apply(ResponseBody responseBody) throws Exception {
                        return new FileFromServer(responseBody, fileName);
                    }
                });
    }

    public Observable<ResponseBody> uploadSelectedModelJson(final String modelName, String json) {

        ModelBody modelBody = new ModelBody(modelName, json);
        gson = new Gson();
        String createPrintsBodyString = gson.toJson(modelBody);
        final RequestBody requestBody = RequestBody.create(MediaType.parse(APPLICATION_JSON), createPrintsBodyString);

        if (authToken != null) {
            return figuromoApiService.uploadJson(authToken, APPLICATION_JSON, requestBody);
        }

        return getAuthToken().flatMap(new Function<ResponseBody, ObservableSource<ResponseBody>>() {
            @Override
            public ObservableSource<ResponseBody> apply(ResponseBody responseBody) throws Exception {

                String token = gson.fromJson(responseBody.string(), AuthToken.class).getToken();
                authToken = "Token " + token;
                return figuromoApiService.uploadJson(authToken, APPLICATION_JSON, requestBody);
            }
        });
    }

    private Observable<ResponseBody> getAuthToken(){

        RegistrationBody registrationBody = new RegistrationBody(USERNAME, PASSWORD);
        String registrationBodyString = gson.toJson(registrationBody);

        RequestBody requestBody = RequestBody.create(MediaType.parse(APPLICATION_JSON), registrationBodyString);
        return figuromoApiService.getAuthToken(requestBody);
    }
}