package kz.arta.synergy.workflow.mobile.android.common.activities;

/**
 * Created by neox on 03.05.14.
 * Настройки приложения
 * Весь этот класс - сплошной говнокод, ибо велосипед. (спека есть спека)
 */

import android.accounts.AccountManager;
import android.app.ActionBar;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.TimePickerDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.location.LocationManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.util.Base64;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.TimePicker;

import com.devspark.appmsg.AppMsg;
import com.google.firebase.iid.FirebaseInstanceId;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import kz.arta.synergy.workflow.mobile.android.R;
import kz.arta.synergy.workflow.mobile.android.AlarmManagerPosition;
import kz.arta.synergy.workflow.mobile.android.AlarmManagerSync;
import kz.arta.synergy.workflow.mobile.android.authorization.SynergyAccount;
import kz.arta.synergy.workflow.mobile.android.common.ActivityConst;
import kz.arta.synergy.workflow.mobile.android.common.SettingsConst;
import kz.arta.synergy.workflow.mobile.android.common.models.ErrorCode;
import kz.arta.synergy.workflow.mobile.android.common.models.Person;
import kz.arta.synergy.workflow.mobile.android.common.offline.SyncMain;
import kz.arta.synergy.workflow.mobile.android.common.requests.RestClient;
import kz.arta.synergy.workflow.mobile.android.common.utils.Const;
import kz.arta.synergy.workflow.mobile.android.common.utils.Fonts;
import kz.arta.synergy.workflow.mobile.android.common.utils.Logger;
import kz.arta.synergy.workflow.mobile.android.common.utils.Utils;
import kz.arta.synergy.workflow.mobile.android.common.utils.Wrapper;
import kz.arta.synergy.workflow.mobile.android.works.activities.completion.process.ProcessConst;

public class SettingsActivity extends Activity {

    /**
     * Данные для авторизированного пользователя
     */
    private Person person;

    /**
     * Активити
     */
    private Activity activity;

    /**
     * Настройки
     */
    private SharedPreferences settings;

    /**
     * Компоненты TextView
     */
    private TextView defaultModuleData;
    private TextView syncEnabledData;
    private TextView syncPeriodTitle;
    private TextView syncPeriodData;
    private TextView downloadAttachmentsTitle;
    private TextView downloadAttachmentsData;
    private TextView languageData;
    private TextView titleOpenLogActivity;
    private TextView positionStatus;
    private TextView positionTitlePeriodUpdate;
    private TextView positionPeriodUpdate;

    /**
     * Layouts
     */
    private RelativeLayout layoutPeriodSync;
    private RelativeLayout layoutDownloadAttachments;
    private RelativeLayout layoutSyncActivity;
    private RelativeLayout layoutPeriodUpdate;

    /**
     * Чекбокс "синхронизировать данные для автономной работы"
     */
    private CheckBox syncCheckBox;

    /**
     * Чекбокс "Отправлять данные о местоположении"
     */
    private CheckBox periodCheckBox;

    /**
     * Вызывается при кастомном выборе времени синхронизации
     */
    private TimePickerDialog.OnTimeSetListener syncPeriodCallBack = new TimePickerDialog.OnTimeSetListener() {
        public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
            SharedPreferences.Editor editor = settings.edit();
            if (hourOfDay == 0 && minute == 0) {
                editor.putString(SettingsConst.PERIOD_TIME_SYNC, "Каждые: " + hourOfDay + " часов " + minute + 1 + " минут");
                editor.putString(SettingsConst.PERIOD_MILLISECONDS_SYNC, (minute + 1) * 60 * 1000 + "");
                editor.apply();
                syncPeriodData.setText("Каждые: " + hourOfDay + " часов " + minute + 1 + " минут");
            } else {
                editor.putString(SettingsConst.PERIOD_TIME_SYNC, "Каждые: " + hourOfDay + " часов " + minute + " минут");
                editor.putString(SettingsConst.PERIOD_MILLISECONDS_SYNC, (hourOfDay * 60 * 60 * 1000) + (minute * 60 * 1000) + "");
                editor.apply();
                syncPeriodData.setText("Каждые: " + hourOfDay + " часов " + minute + " минут");
            }
            showDialogRestartApp();
        }
    };

    /**
     * Вызывается при кастомном выборе времени отправки данных о местоположении
     */
    private TimePickerDialog.OnTimeSetListener positionPeriodCallBack = new TimePickerDialog.OnTimeSetListener() {
        public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
            SharedPreferences.Editor editor = settings.edit();
            if (hourOfDay == 0 && minute == 0) {
                editor.putString(SettingsConst.PERIOD_TIME_POSITION, "Каждые: " + hourOfDay + " часов " + minute + 1 + " минут");
                editor.putString(SettingsConst.PERIOD_MILLISECONDS_POSITION, (minute + 1) * 60 * 1000 + "");
                editor.apply();
                positionPeriodUpdate.setText("Каждые: " + hourOfDay + " часов " + minute + 1 + " минут");
            } else {
                editor.putString(SettingsConst.PERIOD_TIME_POSITION, "Каждые: " + hourOfDay + " часов " + minute + " минут");
                editor.putString(SettingsConst.PERIOD_MILLISECONDS_POSITION, (hourOfDay * 60 * 60 * 1000) + (minute * 60 * 1000) + "");
                editor.apply();
                positionPeriodUpdate.setText("Каждые: " + hourOfDay + " часов " + minute + " минут");
            }
            AlarmManagerPosition alarmManagerPosition = new AlarmManagerPosition();
            alarmManagerPosition.cancelAlarm(activity);
            alarmManagerPosition.setAlarm(activity);
        }
    };

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.settings_activity);

        ActionBar actionBar = getActionBar();
        if (actionBar != null) {
            actionBar.hide();
        }

        activity = this;

        // пользователь
        person = (Person) getIntent().getSerializableExtra(ActivityConst.PERSON);

        // настройки
        settings = getSharedPreferences(SettingsConst.DEFAULT_NAME_SETTINGS, Context.MODE_PRIVATE);

        // адрес текущего сервера
        TextView addressData = (TextView) findViewById(R.id.settings_address_data);
        addressData.setTypeface(Fonts.getMedium(activity));
        addressData.setText(person.getHost());

        // инициализация леяутов
        initLayouts();

        // инициализация текстовых полей
        initTextViews();

        // инициализация чекбоксов
        initCheckBox();

        // получение сохраненных данных
        setData();
    }

    /**
     * Метод получает сохраненные настройки
     */
    private void setData() {

        // модуль по умолчанию
        if (settings.contains(SettingsConst.DEFAULT_MODULE)) {
            if (settings.getInt(SettingsConst.DEFAULT_MODULE, Const.WORKS) == Const.WORKS) {
                defaultModuleData.setText(getResources().getString(R.string.work));
            } else if (settings.getInt(SettingsConst.DEFAULT_MODULE, Const.WORKS) == Const.DOCUMENTS) {
                defaultModuleData.setText(getResources().getString(R.string.documents));
            } else if (settings.getInt(SettingsConst.DEFAULT_MODULE, Const.WORKS) == Const.FILES) {
                defaultModuleData.setText(getResources().getString(R.string.files));
            } else if (settings.getInt(SettingsConst.DEFAULT_MODULE, Const.WORKS) == Const.REGISTRY) {
                defaultModuleData.setText(getResources().getString(R.string.registries));
            }
        }

        // если включена синхронизация
        if (settings.contains(SettingsConst.SYNC_CHECKBOX)) {
            if (settings.getBoolean(SettingsConst.SYNC_CHECKBOX, false)) {
                syncEnabledData.setText(getString(R.string.enabled));
                syncCheckBox.setChecked(true);
                enableSyncComponents();
            } else {
                syncEnabledData.setText(getString(R.string.disabled));
                syncCheckBox.setChecked(false);
                disableSyncComponents();
            }
        } else {
            syncEnabledData.setText(getString(R.string.disabled));
            syncCheckBox.setChecked(false);
            disableSyncComponents();
        }

        // если включена передача геоданных
        if (settings.contains(SettingsConst.POSITION_CHECKBOX)) {
            if (settings.getBoolean(SettingsConst.POSITION_CHECKBOX, false)) {
                enablePositionComponents();
            } else {
                disablePositionComponents();
            }
        } else {
            disablePositionComponents();
        }

        // язык системы
        if (settings.contains(SettingsConst.LANGUAGE_DATA)) {
            languageData.setText(settings.getString(SettingsConst.LANGUAGE_DATA, ""));
        }

        // период синхронизации
        if (settings.contains(SettingsConst.PERIOD_TIME_SYNC)) {
            syncPeriodData.setText(settings.getString(SettingsConst.PERIOD_TIME_SYNC, ""));
        }

        // период отправки геоданных
        if (settings.contains(SettingsConst.PERIOD_TIME_POSITION)) {
            positionPeriodUpdate.setText(settings.getString(SettingsConst.PERIOD_TIME_POSITION, ""));
        }

        // дефолтное время для отправки данных
        if (!settings.contains(SettingsConst.PERIOD_MILLISECONDS_POSITION)) {
            SharedPreferences.Editor editor = settings.edit();
            editor.putString(SettingsConst.PERIOD_MILLISECONDS_POSITION, SettingsConst.DEFAULT_PERIOD_POSITION);
            editor.apply();
        }

        // загружать ли вложения
        if (settings.contains(SettingsConst.DOWNLOAD_ATTACHMENTS)) {
            downloadAttachmentsData.setText(settings.getString(SettingsConst.DOWNLOAD_ATTACHMENTS, ""));
        }
    }

    /**
     * Диалог вызывается при клике на галочку синхронизации
     */
    private void showDialogDisableSync() {
        // проверяем не запущена ли синхронизация
        if (!SyncMain.canSync) {
            AppMsg.makeText(activity, getString(R.string.sync_not_finished), AppMsg.STYLE_ALERT).show();
            syncCheckBox.setChecked(true);
        } else {
            AlertDialog.Builder ad = new AlertDialog.Builder(activity);
            ad.setTitle(getString(R.string.off));  // заголовок
            ad.setMessage(getString(R.string.disable_sync_settings_title)); // сообщение
            ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int arg1) {
                    disableSync();
                    syncEnabledData.setText(getString(R.string.disabled));
                    SharedPreferences.Editor editor = settings.edit();
                    editor.putBoolean(SettingsConst.SYNC_CHECKBOX, syncCheckBox.isChecked());
                    editor.apply();
                    setData();
                }
            });
            ad.setNegativeButton(getString(R.string.no), new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    syncCheckBox.setChecked(true);
                }
            });
            ad.setCancelable(false);
            ad.show();
        }
    }

    /**
     * "Включение" компонентов синхронизации
     */
    private void enableSyncComponents() {
        layoutPeriodSync.setEnabled(true);
        layoutDownloadAttachments.setEnabled(true);
        layoutSyncActivity.setEnabled(true);
        syncPeriodData.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
        syncPeriodTitle.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
        downloadAttachmentsData.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
        downloadAttachmentsTitle.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
        titleOpenLogActivity.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
    }

    /**
     * "Выключение" компонентов синхронизации
     */
    private void disableSyncComponents() {
        layoutPeriodSync.setEnabled(false);
        layoutDownloadAttachments.setEnabled(false);
        layoutSyncActivity.setEnabled(false);
        syncPeriodData.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
        syncPeriodTitle.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
        downloadAttachmentsData.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
        downloadAttachmentsTitle.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
        titleOpenLogActivity.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
    }

    /**
     * "Включение" компонентов отправки геоданных
     */
    private void enablePositionComponents() {
        periodCheckBox.setChecked(true);
        positionStatus.setText(getString(R.string.enabled));
        layoutPeriodUpdate.setEnabled(true);
        positionTitlePeriodUpdate.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
        positionPeriodUpdate.setTextColor(getResources().getColor(R.color.settings_text_color_enabled));
    }

    /**
     * "Выключение" компонентов отправки геоданных
     */
    private void disablePositionComponents() {
        periodCheckBox.setChecked(false);
        positionStatus.setText(getString(R.string.disabled));
        layoutPeriodUpdate.setEnabled(false);
        positionTitlePeriodUpdate.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
        positionPeriodUpdate.setTextColor(getResources().getColor(R.color.settings_text_color_disabled));
    }

    /**
     * Метод вызывается при клике на переключатель "Синхронизировать данные"
     */
    private void disableSync() {
        // говорим что синхронизация в данный момент не запущена
        SyncMain.running = false;
        // включаем возможность синхронизироваться следующий раз
        SyncMain.canSync = true;
        // отрубаем синхронизацию по таймеру, если включена
        new AlarmManagerSync().cancelAlarm(activity);
        // обнуляем настройки
        SharedPreferences.Editor editor = settings.edit();
        editor.remove(Const.SYNC_DATA);
        editor.putBoolean(SettingsConst.SYNC_CHECKBOX, false);
        editor.putString(SettingsConst.PERIOD_TIME_SYNC, getString(R.string.never));
        editor.putString(SettingsConst.DOWNLOAD_ATTACHMENTS, getString(R.string.never));
        editor.putString(SettingsConst.PERIOD_MILLISECONDS_SYNC, getString(R.string.zero));
        editor.putString(SettingsConst.PERIOD_TIME_POSITION, getString(R.string.three_minute));
        editor.putString(SettingsConst.PERIOD_MILLISECONDS_POSITION, SettingsConst.DEFAULT_PERIOD_POSITION);
        editor.putBoolean(SettingsConst.POSITION_CHECKBOX, false);
        editor.apply();
        // удаляем все с базы
        new SyncMain(activity).clearTables(true);
        // рекурсивно удаляем все сохраненные файлы
        deleteRecursive(new File(Environment.getExternalStorageDirectory().getPath()
                + File.separator + Const.ATTACHMENT_DIRECTORY_NAME));
    }

    /**
     * Диалог отображается при клике на кнопку "Выход"
     */
    private void showDialogLogout() {
        AlertDialog.Builder ad = new AlertDialog.Builder(activity);
        ad.setTitle(getString(R.string.exit));  // заголовок
        ad.setMessage(getString(R.string.logout_message)); // сообщение
        ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int arg1) {
                // если включена синхронизация
                if (Utils.checkSyncEnables(settings)) {
                    // выключаем/удаляем все, что связано с ней
                    disableSync();
                }
                // возвращаем модуль по умолчанию (работы)
                SharedPreferences.Editor editor = settings.edit();
                editor.putInt(SettingsConst.DEFAULT_MODULE, Const.WORKS);
                editor.putString(ProcessConst.CERT_PATH, "");
                editor.apply();
                // говорим что пароля у текущего аккаунта не будет
                AccountManager accountManager = AccountManager.get(activity);
                accountManager.setPassword(SynergyAccount.getSynergyAccount(person), "");
                // выключение отправки геоданных
                new AlarmManagerPosition().cancelAlarm(activity);
                // разрегистрация токена для пуш уведомлений
//                new UnregisterToken().execute();
                try {
                    FirebaseInstanceId.getInstance().deleteInstanceId();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                // удаление токена из базы synergy
                new RemoveToken(settings.getString(SettingsConst.TOKEN, "")).execute();
                // удаление всех сохраненных файлов
                deleteRecursive(new File(Environment.getExternalStorageDirectory().getPath()
                        + File.separator + Const.DIRECTORY_PHOTOS_NAME));
                // и форм
                deleteRecursive(new File(Environment.getExternalStorageDirectory().getPath()
                        + File.separator + Const.FORMS_DIRECTORY_NAME));
                // перезапуск приложения
                restartApp();
            }
        });
        ad.setNegativeButton(getString(R.string.no), null);
        ad.setCancelable(false);
        ad.show();
    }

    /**
     * Удаление файлов
     *
     * @param fileOrDirectory объект класса File
     */
    private void deleteRecursive(File fileOrDirectory) {
        if (fileOrDirectory.isDirectory()) {
            for (File file : fileOrDirectory.listFiles()) {
                if (file.getName().equals(Const.USER_ICON_NAME)) {
                    continue;
                }
                file.delete();
            }
        }
    }

    /**
     * Инициализация чекбоксов
     */
    private void initCheckBox() {

        syncCheckBox = (CheckBox) findViewById(R.id.settings_sync_checkbox);
        syncCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton compoundButton, boolean isChecked) {
                if (isChecked) {
                    syncEnabledData.setText(getString(R.string.enabled));
                    enableSyncComponents();
                    SharedPreferences.Editor editor = settings.edit();
                    editor.putBoolean(SettingsConst.SYNC_CHECKBOX, syncCheckBox.isChecked());
                    editor.apply();
                } else {
                    showDialogDisableSync();
                }
            }
        });

        periodCheckBox = (CheckBox) findViewById(R.id.settings_send_position_checkbox);
        periodCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                AlarmManagerPosition alarmManagerPosition = new AlarmManagerPosition();
                if (isChecked) {
                    alarmManagerPosition.setAlarm(activity);
                    LocationManager locationManager = (LocationManager) activity.getSystemService(Context.LOCATION_SERVICE);
                    // если провайдер GPS отключен - запускаем диалог
                    if (!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
                        AlertDialog.Builder ad = new AlertDialog.Builder(activity);
                        ad.setTitle(getString(R.string.gps));  // заголовок
                        ad.setMessage(getString(R.string.gps_disabled_message_settings));
                        ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int arg1) {
                                startActivity(new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                                enablePositionComponents();
                            }
                        });
                        ad.setNegativeButton(getString(R.string.no), new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                disablePositionComponents();
                            }
                        });
                        ad.setCancelable(false);
                        ad.show();
                    } else {
                        enablePositionComponents();
                    }
                } else {
                    disablePositionComponents();
                    alarmManagerPosition.cancelAlarm(activity);
                }
                // сохраняем настройки
                SharedPreferences.Editor editor = settings.edit();
                editor.putBoolean(SettingsConst.POSITION_CHECKBOX, periodCheckBox.isChecked());
                editor.apply();
            }
        });

        disableSyncComponents();
    }

    /**
     * Инициализация леяутов
     */
    private void initLayouts() {

        RelativeLayout languageLayout = (RelativeLayout) findViewById(R.id.layout_language);
        languageLayout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                final String[] langTitles = {"Русский", "Английский", "Казахский"};
                final String[] langKeys = {"ru", "en", "kz"};
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.language));
                builder.setItems(langTitles, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        languageData.setText(langTitles[item]);
                        SharedPreferences.Editor editor = settings.edit();
                        editor.putString(SettingsConst.LANGUAGE_DATA, langTitles[item]);
                        editor.putString("lang_settings", langKeys[item]);
                        editor.apply();
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        RelativeLayout layoutDefaultModule = (RelativeLayout) findViewById(R.id.layout_default_module);
        layoutDefaultModule.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                final String[] items = {getString(R.string.works), getString(R.string.documents), getString(R.string.files), getString(R.string.registries)};
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.default_module));
                builder.setItems(items, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        defaultModuleData.setText(items[item]);
                        SharedPreferences.Editor editor = settings.edit();
                        switch (item) {
                            case 0: {
                                editor.putInt(SettingsConst.DEFAULT_MODULE, Const.WORKS);
                                break;
                            }
                            case 1: {
                                editor.putInt(SettingsConst.DEFAULT_MODULE, Const.DOCUMENTS);
                                break;
                            }
                            case 2: {
                                editor.putInt(SettingsConst.DEFAULT_MODULE, Const.FILES);
                                break;
                            }
                            case 3: {
                                editor.putInt(SettingsConst.DEFAULT_MODULE, Const.REGISTRY);
                                break;
                            }
                        }
                        editor.apply();
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        layoutPeriodSync = (RelativeLayout) findViewById(R.id.layout_sync_period);
        layoutPeriodSync.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                final String[] period = {"Никогда", "30 минут", "1 час", "2 часа", "4 часа", "8 часов", "24 часа", "Настроить период"};
                final String[] periodMilliseconds = {"0", "1800000", "3600000", "7200000", "14400000", "28800000", "86400000", "Настроить период"};
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.sync_period_title_dialog));
                builder.setItems(period, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        if (item == 7) {
                            new TimePickerDialog(activity, syncPeriodCallBack, 0, 0, true).show();
                        } else {
                            syncPeriodData.setText(period[item]);
                            SharedPreferences.Editor editor = settings.edit();
                            editor.putString(SettingsConst.PERIOD_TIME_SYNC, period[item]);
                            editor.putString(SettingsConst.PERIOD_MILLISECONDS_SYNC, periodMilliseconds[item]);
                            editor.apply();
                            if (item == 0) {
                                new AlarmManagerSync().cancelAlarm(activity);
                            }
                            showDialogRestartApp();
                        }
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        layoutDownloadAttachments = (RelativeLayout) findViewById(R.id.layout_download_attachments);
        layoutDownloadAttachments.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                final String[] downloadAttachments = {"Никогда", "Всегда (может взиматься плата за передачу данных)", "Только через Wi-Fi"};
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.getting_attachments));
                builder.setItems(downloadAttachments, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        downloadAttachmentsData.setText(downloadAttachments[item]);
                        SharedPreferences.Editor editor = settings.edit();
                        editor.putString(SettingsConst.DOWNLOAD_ATTACHMENTS, downloadAttachments[item]);
                        editor.apply();
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        layoutSyncActivity = (RelativeLayout) findViewById(R.id.sync_activity);
        layoutSyncActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(getApplicationContext(), LogsActivity.class));

            }
        });

        // клик по кнопке "Выйти"
        RelativeLayout layoutLogout = (RelativeLayout) findViewById(R.id.layout_logout);
        layoutLogout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showDialogLogout();
            }
        });

        layoutPeriodUpdate = (RelativeLayout) findViewById(R.id.layout_period_update);
        layoutPeriodUpdate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final String[] periodTitle = {"1 минута", "3 минуты", "5 минут", "10 минут", "15 минут", "Настроить период"};
                final String[] periodMilliseconds = {"60000", "180000", "300000", "600000", "900000", "Настроить период"};
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.period_update));
                builder.setItems(periodTitle, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        if (item == 5) {
                            new TimePickerDialog(activity, positionPeriodCallBack, 0, 1, true).show();
                        } else {
                            positionPeriodUpdate.setText(periodTitle[item]);
                            SharedPreferences.Editor editor = settings.edit();
                            editor.putString(SettingsConst.PERIOD_TIME_POSITION, periodTitle[item]);
                            editor.putString(SettingsConst.PERIOD_MILLISECONDS_POSITION, periodMilliseconds[item]);
                            editor.apply();
                            AlarmManagerPosition alarmManagerPosition = new AlarmManagerPosition();
                            alarmManagerPosition.cancelAlarm(activity);
                            alarmManagerPosition.setAlarm(activity);
                        }
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        // клик по кнопке "Перезапустить приложение"
        RelativeLayout layoutRestartApp = (RelativeLayout) findViewById(R.id.layout_restart);
        layoutRestartApp.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                restartApp();
            }
        });
    }

    /**
     * Инициализация текстовых полей
     */
    private void initTextViews() {

        ((TextView) findViewById(R.id.title_settings_general)).setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_address_title)).setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_default_module_title)).setTypeface(Fonts.getMedium(activity));

        defaultModuleData = (TextView) findViewById(R.id.settings_default_module_data);
        defaultModuleData.setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_language_title)).setTypeface(Fonts.getMedium(activity));

        languageData = (TextView) findViewById(R.id.settings_language_data);
        languageData.setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_sync_enabled_title)).setTypeface(Fonts.getMedium(activity));

        syncEnabledData = (TextView) findViewById(R.id.settings_sync_enabled_data);
        syncEnabledData.setTypeface(Fonts.getMedium(activity));

        syncPeriodTitle = (TextView) findViewById(R.id.settings_sync_period_title);
        syncPeriodTitle.setTypeface(Fonts.getMedium(activity));

        syncPeriodData = (TextView) findViewById(R.id.settings_sync_period_data);
        syncPeriodData.setTypeface(Fonts.getMedium(activity));

        downloadAttachmentsTitle = (TextView) findViewById(R.id.settings_download_attachments_title);
        downloadAttachmentsTitle.setTypeface(Fonts.getMedium(activity));

        downloadAttachmentsData = (TextView) findViewById(R.id.settings_download_attachments_data);
        downloadAttachmentsData.setTypeface(Fonts.getMedium(activity));

        titleOpenLogActivity = (TextView) findViewById(R.id.settings_sync_activity_title);
        titleOpenLogActivity.setTypeface(Fonts.getMedium(activity));

        TextView logoutTitle = (TextView) findViewById(R.id.settings_logout_title);
        logoutTitle.setTypeface(Fonts.getMedium(activity));

        TextView logoutData = (TextView) findViewById(R.id.settings_logout_data);
        logoutData.setTypeface(Fonts.getMedium(activity));
        logoutData.setText(person.getUserName());

        positionTitlePeriodUpdate = (TextView) findViewById(R.id.settings_period_update_title);
        positionTitlePeriodUpdate.setTypeface(Fonts.getMedium(activity));

        positionPeriodUpdate = (TextView) findViewById(R.id.settings_period_update_data);
        positionPeriodUpdate.setTypeface(Fonts.getMedium(activity));

        positionStatus = (TextView) findViewById(R.id.settings_send_position_data);
        positionStatus.setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_restart_app)).setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_version_app_title)).setTypeface(Fonts.getMedium(activity));

        ((TextView) findViewById(R.id.settings_send_position_title)).setTypeface(Fonts.getMedium(activity));

        String version = null;
        try {
            PackageInfo pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
            version = pInfo.versionName;
        } catch (Exception exc) {
            Logger.v(exc.getLocalizedMessage());
        }

        TextView settingsVersionAppDate = (TextView) findViewById(R.id.settings_version_app_data);
        settingsVersionAppDate.setTypeface(Fonts.getMedium(activity));
        settingsVersionAppDate.setText(String.valueOf(version));
    }


    /**
     * Метод перезапускает приложение
     */
    private void restartApp() {
        Intent i = new Intent(getApplicationContext(), MainActivity.class);
        i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        getApplicationContext().startActivity(i);
    }

    /**
     * Запрос на сервер
     *
     * @param urlToServer - url сервера
     * @return - строка в формате json
     */
    private String request(String urlToServer) {
        String line;
        StringBuffer userInfo;
        try {
            URL url = new URL(urlToServer);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            String basicAuth = "Basic " + new String(Base64.encode(person.getAuth().getBytes(), Base64.NO_WRAP));
            connection.setRequestProperty("Authorization", basicAuth);
            InputStream content = connection.getInputStream();
            BufferedReader in = new BufferedReader(new InputStreamReader(content));
            userInfo = new StringBuffer();
            while ((line = in.readLine()) != null) {
                userInfo.append(line);
            }
            connection.disconnect();
            return userInfo.toString();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Метод перезапуска приложения
     */
    private void showDialogRestartApp() {
        AlertDialog.Builder ad = new AlertDialog.Builder(activity);
        ad.setTitle(getString(R.string.need_restart));  // заголовок
        ad.setMessage(getString(R.string.changes_app_restart_dialog_title));
        ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int arg1) {
                restartApp();
            }
        });
        ad.setNegativeButton(getString(R.string.no), null);
        ad.setCancelable(true);
        ad.show();
    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
    }

    /**
     * Класс исполользуется для разрегистрации токена
     */
//    class UnregisterToken extends AsyncTask<Void, Void, Void> {
//
//        @Override
//        protected Void doInBackground(Void... voids) {
//            try {
//                GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(activity);
//                gcm.unregister();
//            } catch (Exception ignored) {
//            }
//            return null;
//        }
//    }

    /**
     * Класс используется для удаления токена для работы с пуш уведомлениями с сервера
     */
    class RemoveToken extends AsyncTask<Void, Void, String> {

        String token;

        public RemoveToken(String token) {
            this.token = token;
        }

        @Override
        protected void onPostExecute(String result) {
            try {
                ErrorCode errorCode = RestClient.getGson().fromJson(result, ErrorCode.class);
                if (errorCode.getErrorCode().equals(Wrapper.NO_ERROR)) {
                    SharedPreferences.Editor editor = settings.edit();
                    editor.remove(SettingsConst.TOKEN);
                    editor.apply();
                }
            } catch (Exception ignored) {
            }
            super.onPostExecute(result);
        }

        @Override
        protected String doInBackground(Void... voids) {
            return request(person.getHost() + "rest/api/mobile/utils/remove_token?token=" + token);
        }
    }
}