package com.cambercreak.xzdr;


import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.SimpleAdapter;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import com.cambercreak.xzdr.Utils.AvailableRecoveries;
import com.cambercreak.xzdr.Utils.Prefs;
import com.cambercreak.xzdr.Utils.Utilities;
import com.cambercreak.xzdr.Utils.Variable;
import com.cambercreak.xzdr.Utils.XzdrInstall;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonIOException;
import com.google.gson.JsonSyntaxException;
import com.spazedog.lib.rootfw3.RootFW;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


/**
 * A simple {@link android.app.Fragment} subclass.
 */
public class RecoveryFragment extends Fragment {

    private static final String ARG_SECTION_NUMBER = "section_number";
    private static final String TAG_TITLE = "title";
    private static final String TAG_VERSION = "version";

    private SharedPreferences sp;

    private ArrayList<HashMap<String, String>> relaseList =
            new ArrayList<HashMap<String, String>>();
    private ListView available_listview;
    private ProgressBar update_progressbar;
    private Button update_button;

    /**
     * Returns a new instance of this fragment for the given section
     * number.
     */
    public static RecoveryFragment newInstance(int sectionNumber) {
        RecoveryFragment fragment = new RecoveryFragment();
        Bundle args = new Bundle();
        args.putInt(ARG_SECTION_NUMBER, sectionNumber);
        fragment.setArguments(args);
        return fragment;
    }

    public RecoveryFragment() {
        // Required empty public constructor
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_recovery, container, false);
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        ((MainActivity) activity).onSectionAttached(getArguments().getInt(ARG_SECTION_NUMBER));
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        sp = PreferenceManager.getDefaultSharedPreferences(getActivity());
        available_listview =
                (ListView) getActivity().findViewById(R.id.recovery_available_listView);
        update_progressbar =
                (ProgressBar) getActivity().findViewById(R.id.recovery_update_progressbar);
        update_button = (Button) getActivity().findViewById(R.id.recovery_update_button);
        update_button.setOnClickListener(buttonPressedListener);
        getAvailableRecoveries();
    }

    @Override
    public void onResume() {
        super.onResume();
        updateUI();
    }

    public void updateUI() {
        List<String> mRecoveryModeList = new ArrayList<String>();
        mRecoveryModeList.clear();
        mRecoveryModeList.add(Variable.RCVY_PHL);
        mRecoveryModeList.add(Variable.RCVY_CWM);
        mRecoveryModeList.add(Variable.RCVY_TWR);
        if (!Variable.INST_RCVY_PHL) mRecoveryModeList.remove(Variable.RCVY_PHL);
        if (!Variable.INST_RCVY_CWM) mRecoveryModeList.remove(Variable.RCVY_CWM);
        if (!Variable.INST_RCVY_TWR) mRecoveryModeList.remove(Variable.RCVY_TWR);

        LinearLayout rcv_inst =
                (LinearLayout) getActivity().findViewById(R.id.recovery_layout_installed);
        LinearLayout rcv_miss =
                (LinearLayout) getActivity().findViewById(R.id.recovery_layout_not_installed);

        if (mRecoveryModeList.size() > 0) {
            rcv_inst.setVisibility(View.VISIBLE);
            rcv_miss.setVisibility(View.GONE);

            ArrayAdapter<String> dataAdapter =
                    new ArrayAdapter<String>(getActivity(), android.R.layout.simple_spinner_item,
                            mRecoveryModeList);
            dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

            Spinner mRecoverySpinner =
                    (Spinner) getActivity().findViewById(R.id.spinner_select_recovery);
            mRecoverySpinner.setAdapter(dataAdapter);
            mRecoverySpinner.setOnItemSelectedListener(itemSelectedListener);

            for (int position = 0; position < dataAdapter.getCount(); position++) {
                if (dataAdapter.getItem(position)
                        .matches(sp.getString(Prefs.RECOVERY_SPINNER_SELECTED, "philz"))) {
                    mRecoverySpinner.setSelection(position);
                    break;
                }
            }

            Button mRebootButton = (Button) getActivity().findViewById(R.id.button_reboot_recovery);
            mRebootButton.setOnClickListener(buttonRebootPressedListener);
        } else {
            TextView noRecoveries =
                    (TextView) getActivity().findViewById(R.id.textView_no_recoveries);
            rcv_inst.setVisibility(View.GONE);
            rcv_miss.setVisibility(View.VISIBLE);
            if (Utilities.isOldVersionInstalled()) {
                noRecoveries.setText(R.string.old_recovery_found);
            } else {
                noRecoveries.setText(R.string.no_recovery_found);
            }
        }
    }

    private AdapterView.OnItemSelectedListener itemSelectedListener =
            new AdapterView.OnItemSelectedListener() {

                @Override
                public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
                    sp.edit().putString(Prefs.RECOVERY_SPINNER_SELECTED,
                            adapterView.getItemAtPosition(i).toString()).apply();
                }

                @Override
                public void onNothingSelected(AdapterView<?> adapterView) {

                }
            };

    private View.OnClickListener buttonRebootPressedListener = new View.OnClickListener() {

        @Override
        public void onClick(View arg0) {
            RebootToRecovery rtr = new RebootToRecovery();
            rtr.execute();
        }
    };

    private View.OnClickListener buttonPressedListener = new View.OnClickListener() {

        @Override
        public void onClick(View view) {
            getAvailableRecoveries();
        }
    };

    public void getAvailableRecoveries() {
        String mURL = Variable.RMTE_JSON + Build.MODEL;
        if (sp.getBoolean(Prefs.BETA_ALLOW, false)) {
            mURL += "&beta";
        }
        if (sp.getBoolean(Prefs.APLHA_ALLOW, false) && sp.getBoolean(Prefs.ALPHA_UNLOCKED, false)) {
            mURL += "&account=" + Utilities.encodeAccountInfo(getActivity());
        }
        new GetJson().execute(mURL);
    }

    private class RebootToRecovery extends AsyncTask<String, Void, String> {

        private ProgressDialog pdia;

        public RebootToRecovery() {

        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            Utilities.readPropFile(getActivity());
            pdia = new ProgressDialog(getActivity());
            pdia.setMessage("Rebooting...");
            pdia.show();
        }

        @Override
        protected String doInBackground(String... strings) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            if (sp.getString(Prefs.RECOVERY_SPINNER_SELECTED, "philz").matches(Variable.RCVY_CWM)) {
                sp.edit().putString(Prefs.PROP_RECOVERY_BOOT, "cwm").commit();
            }
            if (sp.getString(Prefs.RECOVERY_SPINNER_SELECTED, "philz").matches(Variable.RCVY_PHL)) {
                sp.edit().putString(Prefs.PROP_RECOVERY_BOOT, "philz").commit();
            }
            if (sp.getString(Prefs.RECOVERY_SPINNER_SELECTED, "philz").matches(Variable.RCVY_TWR)) {
                sp.edit().putString(Prefs.PROP_RECOVERY_BOOT, "twrp").commit();
            }
            Utilities.writePropFile(getActivity());
            RootFW root = RootFW.getSharedRoot().get();
            root.shell().run("touch /cache/recovery/boot");
            root.power().reboot();

        }
    }

    private class GetJson extends AsyncTask<String, Void, String> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            update_progressbar.setVisibility(View.VISIBLE);
            update_button.setVisibility(View.GONE);
            available_listview.setVisibility(View.GONE);
            if (!Utilities.isOnline(getActivity())) {
                cancel(true);
            }
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            Toast.makeText(getActivity(), R.string.recovery_update_check_fail, Toast.LENGTH_SHORT)
                    .show();
            update_progressbar.setVisibility(View.GONE);
            update_button.setVisibility(View.VISIBLE);
            available_listview.setVisibility(View.GONE);
        }

        @Override
        protected String doInBackground(String... args) {
            InputStream source = retrieveStream(args[0]);
            Gson gson = new GsonBuilder().create();
            Reader reader = null;
            try {
                reader = new InputStreamReader(source);
            } catch (Exception e) {
                if (BuildConfig.DEBUG) Log.e(Variable.DEBUG_TAG, "InputStreamReaderException");
                this.cancel(true);
                return null;
            }
            AvailableRecoveries response = null;
            try {
                response = gson.fromJson(reader, AvailableRecoveries.class);
            } catch (JsonSyntaxException e) {
                if (BuildConfig.DEBUG) Log.e(Variable.DEBUG_TAG, "JsonSyntaxException");
                this.cancel(true);
                return null;
            } catch (JsonIOException e) {
                if (BuildConfig.DEBUG) Log.e(Variable.DEBUG_TAG, "JsonIOException");
                this.cancel(true);
                return null;
            }
            if (!response.result.isEmpty()) {
                Variable.AVAILABLE_RECOVERIES = response.result;
            }
            return null;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            relaseList.clear();
            if (!Variable.AVAILABLE_RECOVERIES.isEmpty()) {
                for (AvailableRecoveries.Result result : Variable.AVAILABLE_RECOVERIES) {
                    HashMap<String, String> map = new HashMap<String, String>();
                    map.put(TAG_TITLE, result.version.title);
                    map.put(TAG_VERSION, result.version.release_version);
                    relaseList.add(map);
                    Log.d(Variable.DEBUG_TAG, result.version.title);
                    Log.d(Variable.DEBUG_TAG, result.version.release_version);
                }
                ListAdapter adapter =
                        new SimpleAdapter(getActivity(), relaseList, R.layout.recoverylist_adapter,
                                new String[]{TAG_TITLE, TAG_VERSION,},
                                new int[]{R.id.ReleaseName, R.id.ReleaseVersion});
                available_listview.setAdapter(adapter);
                available_listview.setOnItemClickListener(onItemClickListener);
                update_progressbar.setVisibility(View.GONE);
                update_button.setVisibility(View.VISIBLE);
                available_listview.setVisibility(View.VISIBLE);
            } else {
                this.cancel(true);
            }
        }

        private AdapterView.OnItemClickListener onItemClickListener =
                new AdapterView.OnItemClickListener() {

                    @Override
                    public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
                        FragmentManager fm = getFragmentManager();
                        Bundle bundle = new Bundle();
                        bundle.putInt("key", i);
                        RecoveryDialogue alert = new RecoveryDialogue();
                        alert.setArguments(bundle);
                        alert.show(fm, "Alert_Dialog");
                    }
                };

        private InputStream retrieveStream(String url) {

            DefaultHttpClient client = new DefaultHttpClient();
            HttpGet getRequest = new HttpGet(url);
            try {
                HttpResponse getResponse = client.execute(getRequest);
                final int statusCode = getResponse.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    Log.w(getClass().getSimpleName(), "Error " + statusCode + " for URL " + url);
                    return null;
                }
                HttpEntity getResponseEntity = getResponse.getEntity();
                return getResponseEntity.getContent();
            } catch (IOException e) {
                getRequest.abort();
                Log.w(getClass().getSimpleName(), "Error for URL " + url, e);
            }
            return null;
        }
    }

    private class RecoveryDialogue extends DialogFragment {

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {

            Bundle bundle = getArguments();
            final int position = bundle.getInt("key");

            DialogInterface.OnClickListener positiveClick = new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    Toast.makeText(getActivity().getBaseContext(), "Installing...",
                            Toast.LENGTH_SHORT).show();
                    Bundle bundle = new Bundle();
                    bundle.putInt("key", position);
                    Intent intent = new Intent(getActivity(), XzdrInstall.class);
                    intent.putExtras(bundle);
                    getActivity().startService(intent);
                }
            };

            DialogInterface.OnClickListener negativeClick = new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    /*Toast.makeText(getActivity().getBaseContext(), "No option selecting",
                            Toast.LENGTH_SHORT).show();*/

                }
            };

            AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
            builder.setMessage(Variable.AVAILABLE_RECOVERIES.get(position).version.changelog)
                    .setNegativeButton("Cancel", negativeClick)
                    .setPositiveButton("Install", positiveClick).setTitle("Changelog: v" +
                    Variable.AVAILABLE_RECOVERIES.get(position).version.release_version);
            Dialog dialog = builder.create();
            return dialog;
        }
    }
}