testActivity

package com.example.surveyapp.MainClass;

import android.app.ProgressDialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.example.surveyapp.PojoModel.Barangay;
import com.example.surveyapp.PojoModel.JsonResponse;
import com.example.surveyapp.PojoModel.Municipality;
import com.example.surveyapp.PojoModel.Organization;
import com.example.surveyapp.PojoModel.PeerAssigned;
import com.example.surveyapp.PojoModel.PeerPartOne;
import com.example.surveyapp.PojoModel.PeerPartThree;
import com.example.surveyapp.PojoModel.PeerPartTwo;
import com.example.surveyapp.PojoModel.Peers;
import com.example.surveyapp.PojoModel.Province;
import com.example.surveyapp.PojoModel.Questionnaire;
import com.example.surveyapp.PojoModel.Questions;
import com.example.surveyapp.PojoModel.Region;
import com.example.surveyapp.PojoModel.SelfAnswersFive;
import com.example.surveyapp.PojoModel.SelfAnswersFour;
import com.example.surveyapp.PojoModel.SelfAnswersOne;
import com.example.surveyapp.PojoModel.SelfAnswersThree;
import com.example.surveyapp.PojoModel.SelfAnswersTwo;
import com.example.surveyapp.PojoModel.Selfs;
import com.example.surveyapp.PojoModel.Users;
import com.example.surveyapp.R;
import com.example.surveyapp.RestAdapters.ApiInterface;
import com.example.surveyapp.RestAdapters.ApiUtils;
import com.example.surveyapp.RestAdapters.DatabaseHelper;
import com.google.gson.Gson;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import retrofit2.Callback;
import retrofit2.Response;

public class MainActivity extends AppCompatActivity {


    private List<Questions> questionList = new ArrayList<Questions>();
    private List<Users> users;
    private List<Questions> questions;
    private List<Peers.PeersList> peersLists = new ArrayList<>();
    private Peers.PeersList peersList;
    private List<Selfs.SelfsList> selfsLists;
    private List<PeerAssigned.PeerAssignedList> peerAssignedLists;
    private List<PeerPartOne.PeerPartOneList> peerPartOneLists;
    private List<PeerPartTwo.PeerPartTwoList> peerPartTwoLists;
    private List<PeerPartThree.PeerPartThreeList> peerPartThreeLists;
    private List<SelfAnswersOne.SelfAnswersOneList> selfAnswersOneLists;
    private List<SelfAnswersTwo.SelfAnswersTwoList> selfAnswersTwoLists;
    private List<SelfAnswersThree.SelfAnswersThreeList> selfAnswersThreeLists;
    private List<SelfAnswersFour.SelfAnswersFourList> selfAnswersFourLists;
    private List<SelfAnswersFive.SelfAnswersFiveList> selfAnswersFiveLists;
    private List<Questionnaire.QuestionnaireList> questionnaireLists;
    private List<Barangay.BarangayList> barangayLists;
    private List<Municipality.MunicipalityList> municipalityLists;
    private List<Organization.OrganizationList> organizationLists;
    private List<Province.ProvinceList> provinceLists;
    private List<Region.RegionList> regionLists;
    private ApiInterface mApiInterface;
    Button mButton, syncButton;
    TextView mUsername, mPassword;
    String  message;
    int success, mID;
    String mUsertype;
    private DatabaseHelper db;
    public static final String COLUMN_ID = "user_id";
    public static final String COLUMN_USER_TYPE = "user_type";
    SharedPreferences sharedPreferences;
    private ProgressDialog progressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        db = new DatabaseHelper(this);
        mApiInterface = ApiUtils.getApiInterface();
        mUsername = (TextView) findViewById(R.id.main_username);
        mPassword = (TextView) findViewById(R.id.main_password);
        mButton = (Button) findViewById(R.id.login);
        sharedPreferences = getSharedPreferences("session",MODE_PRIVATE);


        if(sharedPreferences.contains("username") && sharedPreferences.contains("password")){
            nextActivity();
        }

        try {
            db.createDataBase();
        } catch (IOException e) {
            e.printStackTrace();
        }
        Boolean check = db.checkDataBase();
        Log.d("test", String.valueOf(check));
        //getData();
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // getData();
                // login();
                //getRemoteRequests();

            }
        });

    }

    public void nextActivity(){
        Intent intent = new Intent(MainActivity.this, BottomNavActivity.class);
        startActivity(intent);
        finish();
    }


    public void getData(){

        new Thread(new Runnable() {
            @Override
            public void run() {
                getUsersFromRemoteServer();
                getPeersFromRemoteServer();
                getSelfsFromRemoteServer();
                getPeerAssignedFromRemoteServer();
                getPeerPart1FromRemoteServer();
                getPeerPart2FromRemoteServer();
                getPeerPart3FromRemoteServer();
                getSelfAnswers1FromRemoteServer();
                getSelfAnswers2FromRemoteServer();
                getSelfAnswers3FromRemoteServer();
                getSelfAnswers4FromRemoteServer();
                getSelfAnswers5FromRemoteServer();
                getOrganizationFromRemoteServer();
            }
        }).start();
    }
    public void getPeersFromRemoteServer(){
        mApiInterface.getPeers().enqueue(new Callback<Peers>() {
            @Override
            public void onResponse(Call<Peers> call, Response<Peers> response) {
                peersLists = response.body().getPeersList();
                db.storePeersFromRemoteServer(peersLists);
                Log.d("PeerListData", peersLists.toString());
            }

            @Override
            public void onFailure(Call<Peers> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }

    public void getBarangayFromRemoteServer(){
        mApiInterface.getBarangay().enqueue(new Callback<Barangay>() {
            @Override
            public void onResponse(Call<Barangay> call, Response<Barangay> response) {
                barangayLists = response.body().getBarangayLists();
                db.storeBarangayFromRemoteServer(barangayLists);
                Log.d("barangaySize", String.valueOf(barangayLists.size()));
                // Log.d("barangayList", barangayLists.toString());
            }

            @Override
            public void onFailure(Call<Barangay> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }
    public void getMunicipalityFromRemoteServer(){
        mApiInterface.getMunicipality().enqueue(new Callback<Municipality>() {
            @Override
            public void onResponse(Call<Municipality> call, Response<Municipality> response) {
                municipalityLists = response.body().getMunicipalityLists();
                db.storeMunicipalityFromRemoteServer(municipalityLists);
                Log.d("municipalitySize", String.valueOf(municipalityLists.size()));
                //  Log.d("MunicipalityList", municipalityLists.toString());
            }

            @Override
            public void onFailure(Call<Municipality> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }
    public void getOrganizationFromRemoteServer(){
        mApiInterface.getOrganization().enqueue(new Callback<Organization>() {
            @Override
            public void onResponse(Call<Organization> call, Response<Organization> response) {
                organizationLists = response.body().getOrganizationLists();
                db.storeOrganizationFromRemoteServer(organizationLists);
                Log.d("organizationSze", String.valueOf(organizationLists.size()));
                //  Log.d("organizationList", organizationLists.toString());
            }

            @Override
            public void onFailure(Call<Organization> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }
    public void getProvinceFromRemoteServer(){
        mApiInterface.getProvince().enqueue(new Callback<Province>() {
            @Override
            public void onResponse(Call<Province> call, Response<Province> response) {
                provinceLists = response.body().getProvinceLists();
                db.storeProvinceFromRemoteServer(provinceLists);
                Log.d("provinceSize", String.valueOf(provinceLists.size()));
                //   Log.d("provinceList", provinceLists.toString());
            }

            @Override
            public void onFailure(Call<Province> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }
    public void getRegionFromRemoteServer(){
        mApiInterface.getRegion().enqueue(new Callback<Region>() {
            @Override
            public void onResponse(Call<Region> call, Response<Region> response) {
                regionLists = response.body().getRegionLists();
                db.storeRegionFromRemoteServer(regionLists);
                Log.d("regionSize", String.valueOf(regionLists.size()));
                //  Log.d("regionList", regionLists.toString());
            }

            @Override
            public void onFailure(Call<Region> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }

    public void getSelfsFromRemoteServer(){
        mApiInterface.getSelfs().enqueue(new Callback<Selfs>() {
            @Override
            public void onResponse(Call<Selfs> call, Response<Selfs> response) {
                selfsLists = response.body().getSelfsLists();
                db.storeSelfsFromRemoteServer(selfsLists);
                Log.d("SelfsListData", selfsLists.toString());
            }

            @Override
            public void onFailure(Call<Selfs> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }

    public void getPeerAssignedFromRemoteServer(){
        mApiInterface.getPeerAssigned().enqueue(new Callback<PeerAssigned>() {
            @Override
            public void onResponse(Call<PeerAssigned> call, Response<PeerAssigned> response) {
                peerAssignedLists = response.body().getPeerAssignedLists();
                db.storePeerAssignedFromRemoteServer(peerAssignedLists);
                Log.d("PeerAssignedListData", peerAssignedLists.toString());
            }

            @Override
            public void onFailure(Call<PeerAssigned> call, Throwable t) {
                Log.d("error on server", String.valueOf(t));
            }
        });
    }

    public void getUsersFromRemoteServer(){
        mApiInterface.getAllUsers().enqueue(new Callback<JsonResponse>() {
            @Override
            public void onResponse(Call<JsonResponse> call, Response<JsonResponse> response) {
                success = response.body().getSuccess();
                message = response.body().getMessage();

                if (success == 1){
                    users = response.body().getUsers();
                    Log.d("mydata","Number of data :"+ users.size());
                    Log.d("UsersListData", users.toString());

                    db.storeUsersFromRemoteServer(users);

                }
                else{
                    Log.d("wrong credentials", "true");
                }
            }


            @Override
            public void onFailure(Call<JsonResponse> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });

    }

    public void getPeerPart1FromRemoteServer(){
        mApiInterface.getPeerPartOne().enqueue(new Callback<PeerPartOne>() {
            @Override
            public void onResponse(Call<PeerPartOne> call, Response<PeerPartOne> response) {
                peerPartOneLists = response.body().getPeerPartOneLists();
                db.storePeerPartOneFromRemoteServer(peerPartOneLists);
                Log.d("peerPartOneLists", peerPartOneLists.toString());

            }

            @Override
            public void onFailure(Call<PeerPartOne> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getPeerPart2FromRemoteServer(){
        mApiInterface.getPeerPartTwo().enqueue(new Callback<PeerPartTwo>() {
            @Override
            public void onResponse(Call<PeerPartTwo> call, Response<PeerPartTwo> response) {
                peerPartTwoLists = response.body().getPeerPartTwoLists();
                db.storePeerPartTwoFromRemoteServer(peerPartTwoLists);
                Log.d("peerPartTwoLists", peerPartTwoLists.toString());
            }

            @Override
            public void onFailure(Call<PeerPartTwo> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getPeerPart3FromRemoteServer(){
        mApiInterface.getPeerPartThree().enqueue(new Callback<PeerPartThree>() {
            @Override
            public void onResponse(Call<PeerPartThree> call, Response<PeerPartThree> response) {
                peerPartThreeLists = response.body().getPeerPartThreeLists();
                db.storePeerPartThreeFromRemoteServer(peerPartThreeLists);
                Log.d("peerPartThreeLists", peerPartThreeLists.toString());
            }

            @Override
            public void onFailure(Call<PeerPartThree> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getSelfAnswers1FromRemoteServer(){
        mApiInterface.getSelfAnswersOne().enqueue(new Callback<SelfAnswersOne>() {
            @Override
            public void onResponse(Call<SelfAnswersOne> call, Response<SelfAnswersOne> response) {
                selfAnswersOneLists = response.body().getSelfAnswersOneLists();
                db.storeSelfAnswersOneFromRemoteServer(selfAnswersOneLists);
                Log.d("selfAnswersOneLists", selfAnswersOneLists.toString());
            }

            @Override
            public void onFailure(Call<SelfAnswersOne> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getSelfAnswers2FromRemoteServer(){
        mApiInterface.getSelfAnswersTwo().enqueue(new Callback<SelfAnswersTwo>() {
            @Override
            public void onResponse(Call<SelfAnswersTwo> call, Response<SelfAnswersTwo> response) {
                selfAnswersTwoLists = response.body().getSelfAnswersTwoLists();
                db.storeSelfAnswersTwoFromRemoteServer(selfAnswersTwoLists);
                Log.d("selfAnswersTwoLists", selfAnswersTwoLists.toString());
            }

            @Override
            public void onFailure(Call<SelfAnswersTwo> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getSelfAnswers3FromRemoteServer(){
        mApiInterface.getSelfAnswersThree().enqueue(new Callback<SelfAnswersThree>() {
            @Override
            public void onResponse(Call<SelfAnswersThree> call, Response<SelfAnswersThree> response) {
                selfAnswersThreeLists = response.body().getSelfAnswersThreeLists();
                db.storeSelfAnswersThreeFromRemoteServer(selfAnswersThreeLists);
                Log.d("selfAnswersThreeLists", selfAnswersThreeLists.toString());
            }

            @Override
            public void onFailure(Call<SelfAnswersThree> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getSelfAnswers4FromRemoteServer(){
        mApiInterface.getSelfAnswersFour().enqueue(new Callback<SelfAnswersFour>() {
            @Override
            public void onResponse(Call<SelfAnswersFour> call, Response<SelfAnswersFour> response) {
                selfAnswersFourLists = response.body().getSelfAnswersFourLists();
                db.storeSelfAnswersFourFromRemoteServer(selfAnswersFourLists);
                Log.d("selfAnswersFourLists", selfAnswersFourLists.toString());
            }

            @Override
            public void onFailure(Call<SelfAnswersFour> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getSelfAnswers5FromRemoteServer(){
        mApiInterface.getSelfAnswersFive().enqueue(new Callback<SelfAnswersFive>() {
            @Override
            public void onResponse(Call<SelfAnswersFive> call, Response<SelfAnswersFive> response) {
                selfAnswersFiveLists = response.body().getSelfAnswersFiveLists();
                db.storeSelfAnswersFiveFromRemoteServer(selfAnswersFiveLists);
                Log.d("selfAnswersFiveLists", selfAnswersFiveLists.toString());
            }

            @Override
            public void onFailure(Call<SelfAnswersFive> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }

    public void getQuestionnaireFromRemoteServer(){
        mApiInterface.getQuestionnaire().enqueue(new Callback<Questionnaire>() {
            @Override
            public void onResponse(Call<Questionnaire> call, Response<Questionnaire> response) {
                questionnaireLists = response.body().getQuestionnaireLists();
                db.storeQuestionnaireFromRemoteServer(questionnaireLists);
                Log.d("questionnaireList", questionnaireLists.toString());
            }

            @Override
            public void onFailure(Call<Questionnaire> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }


    public void login(){
        final String getUsername = mUsername.getText().toString().trim();
        final String getPassword = mPassword.getText().toString().trim();


        mApiInterface.login(getUsername,getPassword).enqueue(new Callback<JsonResponse>() {
            @Override
            public void onResponse(Call<JsonResponse> call, Response<JsonResponse> response) {
                SharedPreferences.Editor editor = sharedPreferences.edit();
                if(response.isSuccessful()) {
                    success = response.body().getSuccess();
                    message = response.body().getMessage();
                    if (success == 1){
                        Log.w("Full json=> ",new Gson().toJson(response));
                        users = response.body().getUsers();
                        String mEmail = users.get(0).getEmail();
                        mID = users.get(0).getId();
                        String mPassword = users.get(0).getPassword();
                        mUsertype = users.get(0).getUser_type();
                        nextActivity();
                        editor.putString("username", mEmail);
                        editor.putString("password", mPassword);
                        editor.putInt("user_id", mID);
                        editor.putString("user_type", mUsertype);
                        editor.commit();


                    }else{
                        Log.d("mysuccess", String.valueOf(success));
                        Log.d("mymessage", message);
                        Log.d("Error is?", String.valueOf(response));
                    }


                }else {
                    Log.d("isResponseSuccessful", "ResponseFailed");
                    Log.d("Error is?", String.valueOf(response));
                    Log.w("Full json=> ",new Gson().toJson(response));
                }
            }

            @Override
            public void onFailure(Call<JsonResponse> call, Throwable t) {
                Log.d("isResponseGood?", "Not Good");
                Log.d("Error is?", String.valueOf(t));
            }
        });
    }
}