package kz.arta.synergy.workflow.mobile.android.works.activities.create;

import android.Manifest;
import android.app.ActionBar;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.app.TimePickerDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.FragmentActivity;
import android.util.TypedValue;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.TimePicker;

import com.devspark.appmsg.AppMsg;
import com.pnikosis.materialishprogress.ProgressWheel;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

import kz.arta.synergy.workflow.mobile.android.R;
import kz.arta.synergy.workflow.mobile.android.common.ActivityConst;
import kz.arta.synergy.workflow.mobile.android.common.components.DatePickerFragment;
import kz.arta.synergy.workflow.mobile.android.common.components.OpenFileDialog;
import kz.arta.synergy.workflow.mobile.android.common.components.TimePickerFragment;
import kz.arta.synergy.workflow.mobile.android.common.models.CreateDefaults;
import kz.arta.synergy.workflow.mobile.android.common.models.Person;
import kz.arta.synergy.workflow.mobile.android.common.models.settings.CompletionFormItem;
import kz.arta.synergy.workflow.mobile.android.common.models.settings.PriorityItem;
import kz.arta.synergy.workflow.mobile.android.common.requests.RestClient;
import kz.arta.synergy.workflow.mobile.android.common.requests.SendGetRequest;
import kz.arta.synergy.workflow.mobile.android.common.utils.ActionUtils;
import kz.arta.synergy.workflow.mobile.android.common.utils.Const;
import kz.arta.synergy.workflow.mobile.android.common.utils.DateUtils;
import kz.arta.synergy.workflow.mobile.android.common.utils.Fonts;
import kz.arta.synergy.workflow.mobile.android.common.utils.UserSerializable;
import kz.arta.synergy.workflow.mobile.android.common.utils.Utils;
import kz.arta.synergy.workflow.mobile.android.users.activities.UserChooserActivity;
import kz.arta.synergy.workflow.mobile.android.users.activities.UserChooserMultiActivity;
import kz.arta.synergy.workflow.mobile.android.works.manager.create.ChangeWork;
import kz.arta.synergy.workflow.mobile.android.works.manager.create.CreateWork;
import kz.arta.synergy.workflow.mobile.android.works.models.WorkItem;

/**
 * Created by neox on 06.04.14.
 * Создание/редактирование работы
 */
public class CreateWorkActivity extends FragmentActivity {

    /**
     * Константы для метода startActivityForResult
     */
    private static final int SELECT_RESPONSIBLE = 1;
    private static final int SELECT_AUTHOR = 2;
    private static final int SELECT_EXECUTORS = 3;
    private static final int ADD_PHOTO = 4;

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

    /**
     * Прогрессбар
     */
    private ProgressWheel progressBar;

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

    /**
     * UUID ответственного
     */
    private String responsibleID;

    /**
     * UUID автора
     */
    private String authorID;

    /**
     * Приоритет работы (1 по умолчанию)
     */
    private String selectedPriority = "1";

    /**
     * uuid формы завершения
     */
    private String formCompletionID;

    /**
     * Список добавленных файлов при создании работы
     */
    private List<String> fileNames = new ArrayList<>();

    /**
     * Имя файла для того случая когда пользователь добавляет снимок сделанный с помощью камеры
     */
    private long photoFileName;

    /**
     * Текст работы
     */
    private EditText nameWork;

    /**
     * Чекбокс для поля "Ответственный"
     */
    private CheckBox resCheckBox;

    /**
     * Ответственный
     */
    private TextView responsible;

    /**
     * Заголовок для поля "Автор"
     */
    private TextView authorTitle;

    /**
     * Автор
     */
    private TextView author;

    /**
     * Заголовок для поля "Исполнители"
     */
    private TextView executorsTitle;

    /**
     * Исполнители
     */
    private TextView executors;

    /**
     * Дата начала
     */
    private TextView startDate;

    /**
     * Время начала
     */
    private TextView startTime;

    /**
     * Дата завершения
     */
    private TextView finishDate;

    /**
     * Время завершения
     */
    private TextView finishTime;

    /**
     * Приоритет
     */
    private TextView priority;

    /**
     * Форма завершения
     */
    private TextView formCompletion;

    /**
     * Заголовок для комментария
     */
    private TextView commentTitle;

    /**
     * Комментарий который добавится к работе
     */
    private EditText comment;

    /**
     * Айдишники выбранных пользователей
     */
    private List<String> selectedUsers;

    /**
     * Леяут содержащий имена добавленных файлов
     */
    private LinearLayout addedFiles;

    /**
     * Объект "Работа"
     */
    private WorkItem work;

    /**
     * Массив с именами приоритетов
     */
    private String[] priorityNames;

    /**
     * Массив с айдишниками приоритетов
     */
    private String[] priorityID;

    /**
     * Кнопка "Создать"
     */
    private Button createWorkButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

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

        activity = this;

        Intent intent = getIntent();
        person = (Person) intent.getSerializableExtra(ActivityConst.PERSON);
        work = (WorkItem) intent.getSerializableExtra(ActivityConst.WORK);

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

        progressBar = (ProgressWheel) findViewById(R.id.create_work_progress_bar);

        // приоритет по умолчанию
        selectedPriority = person.getDefaults().getPriority();

        // заголовок активити
        String dialogName = getIntent().getStringExtra(ActivityConst.DIALOG_NAME);
        if (dialogName != null) {
            ((TextView) findViewById(R.id.title_action_bar_create_work)).setText(dialogName);
        }

        // получение данных для создания работы
        getCreateDefaults();
    }

    /**
     * Выполняется
     */
    private void init() {
        // если мы редактируем работу
        if (work != null) {
            // текст работы
            nameWork.setText(work.getName());
            // ответственный
            responsible.setText(work.getUser().getName());
            // uuid ответственного
            responsibleID = work.getUser().getID();
            // убираем чекбокс
            resCheckBox.setVisibility(View.GONE);
            // цвет текста заголовка для автора
            authorTitle.setTextColor(getResources().getColor(R.color.disabled_title_all_activity));
            // отключааем возможность кликнуть по автору
            author.setEnabled(false);
            // автор
            author.setText(work.getAuthor().getName());
            // отключение поля "Исполнители" (при редактировании не нужен)
            executors.setVisibility(View.GONE);
            // отключение лейбла "Исполнители" (при редактировании не нужен)
            executorsTitle.setVisibility(View.GONE);
            // отключение поля "Комментарий" (при редактировании не нужен)
            comment.setVisibility(View.GONE);
            // отключение лейбла "Исполнители" (при редактировании не нужен)
            commentTitle.setVisibility(View.GONE);
            // текущий приоритет
            selectedPriority = work.getPriority();
            // поиск нужного приоритета (для отображения в поле)
            if (person.getCurrentPriorityItemHashMap().get(selectedPriority) == null) {
                if (person.getPriorityItemHashMap().get(selectedPriority) != null) {
                    priority.setText((person.getPriorityItemHashMap().get(selectedPriority).getName()));
                } else {
                    priority.setText("");
                }
                selectedPriority = "-1";
            } else {
                priority.setText(person.getCurrentPriorityItemHashMap().get(selectedPriority).getName());
            }
            // uuid формы завершения
            formCompletionID = work.getCompletionFormID();
            // поиск нужной формы завершения (для отображения в поле)
            if (work.getCompletionFormID() != null && work.getCompletionFormID().length() != 0) {
                formCompletion.setText(Utils.getFormCompletion(work.getCompletionFormID(), person, activity, false));
            } else {
                formCompletion.setText(getString(R.string.no));
            }
            // время редактируемой работы
            getWorkData();
        } else {
            // uuid автора
            authorID = person.getUuid();
            // по умолчанию чекбокс "Ответственный" включен
            resCheckBox.setChecked(true);
            // получение стаднартного времени создания работы
            getDefaultData();
        }
    }

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

        String priorityName = null;

        List<String> names = new ArrayList<>();
        List<String> id = new ArrayList<>();

        if (person.getSettings().getCurrentPriorities() != null) {
            for (PriorityItem priorityItem : person.getSettings().getCurrentPriorities()) {
                names.add(priorityItem.getName());
                id.add(priorityItem.getId());
                if (priorityItem.getBase().equals("true")) {
                    priorityName = priorityItem.getName();
                }
            }
        }

        priorityNames = new String[names.size()];
        priorityID = new String[id.size()];

        names.toArray(priorityNames);
        id.toArray(priorityID);

        addedFiles = (LinearLayout) findViewById(R.id.create_work_added_files);

        // применяем шрифты в заголовкам
        initTitles();

        // а также к кнопкам
        initButtons();

        resCheckBox = (CheckBox) findViewById(R.id.create_work_check_box);
        resCheckBox.setTypeface(Fonts.getMedium(activity));
        resCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                responsible.setText("");
                responsibleID = null;
            }
        });

        nameWork = (EditText) findViewById(R.id.create_work_text_work);

        responsible = (TextView) findViewById(R.id.create_work_responsible);
        responsible.setTypeface(Fonts.getMedium(activity));
        responsible.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (work != null || resCheckBox.isChecked()) {
                    Intent intent = new Intent(CreateWorkActivity.this, UserChooserActivity.class);
                    intent.putExtra(ActivityConst.PERSON, person);
                    intent.putExtra(ActivityConst.SHOW_ALL, person.getSettings().getAllowResendWork());
                    intent.putExtra(ActivityConst.USER_ID, responsibleID);
                    intent.putExtra(ActivityConst.USER_NAME, responsible.getText());
                    startActivityForResult(intent, SELECT_RESPONSIBLE);
                }
            }
        });

        author = (TextView) findViewById(R.id.create_work_author);
        author.setTypeface(Fonts.getMedium(activity));
        author.setText(person.getUserName());
        author.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(CreateWorkActivity.this, UserChooserActivity.class);
                intent.putExtra(ActivityConst.PERSON, person);
                intent.putExtra(ActivityConst.SHOW_ALL, person.getSettings().getAllowResendWork());
                intent.putExtra(ActivityConst.USER_ID, responsibleID);
                intent.putExtra(ActivityConst.USER_NAME, responsible.getText());
                intent.putExtra(ActivityConst.AUTHOR, true);
                startActivityForResult(intent, SELECT_AUTHOR);
            }
        });

        // отображаем поле "автор" (если нужно)
        if (person.getSettings().getDisplayAuthorInput().equals("true")) {
            author.setVisibility(View.VISIBLE);
            authorTitle.setVisibility(View.VISIBLE);
        } else {
            author.setVisibility(View.GONE);
            authorTitle.setVisibility(View.GONE);
        }

        executors = (TextView) findViewById(R.id.create_work_executors);
        executors.setTypeface(Fonts.getMedium(activity));
        executors.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(CreateWorkActivity.this, UserChooserMultiActivity.class);
                intent.putExtra(ActivityConst.PERSON, person);
                if (person.getSettings().getAllowAddWorkResponsibles().equals("true")) {
                    intent.putExtra(ActivityConst.SHOW_ALL, person.getSettings().getAllowAddWorkResponsibles());
                } else if (person.getSettings().getSetWorkFromResponsible().equals("true")) {
                    intent.putExtra(ActivityConst.SHOW_ALL, person.getSettings().getSetWorkFromResponsible());
                } else {
                    intent.putExtra(ActivityConst.SHOW_ALL, "false");
                }
                if (person.getSettings().getSetWorkFromResponsible().equals("true")) {
                    intent.putExtra(ActivityConst.USER_ID, responsibleID);
                }
                if (selectedUsers != null && selectedUsers.size() != 0) {
                    intent.putExtra(ActivityConst.SELECTED, selectedUsers.toArray(new String[selectedUsers.size()]));
                }
                startActivityForResult(intent, SELECT_EXECUTORS);
            }
        });

        if (person.getSettings().getDocflowDemandSignBeforeAssign().equals("true")) {
            executors.setVisibility(View.GONE);
            executorsTitle.setVisibility(View.GONE);
            resCheckBox.setEnabled(false);
            resCheckBox.setChecked(true);
        }

        startDate = (TextView) findViewById(R.id.create_work_start_data);
        startDate.setTypeface(Fonts.getMedium(activity));
        startDate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showDatePicker(startDate);
            }
        });

        startTime = (TextView) findViewById(R.id.create_work_start_time);
        startTime.setTypeface(Fonts.getMedium(activity));
        startTime.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showTimePicker(startTime);
            }
        });

        finishDate = (TextView) findViewById(R.id.create_work_finish_data);
        finishDate.setTypeface(Fonts.getMedium(activity));
        finishDate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showDatePicker(finishDate);
            }
        });

        finishTime = (TextView) findViewById(R.id.create_work_finish_time);
        finishTime.setTypeface(Fonts.getMedium(activity));
        finishTime.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showTimePicker(finishTime);
            }
        });

        priority = (TextView) findViewById(R.id.create_work_priority);
        priority.setTypeface(Fonts.getMedium(activity));
        priority.setText(priorityName);
        priority.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.choose_priority));
                builder.setItems(priorityNames, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int item) {
                        priority.setText(priorityNames[item]);
                        selectedPriority = String.valueOf(priorityID[item]);
                    }
                });
                builder.setCancelable(true);
                builder.show();
            }
        });

        formCompletion = (TextView) findViewById(R.id.create_work_form_completion);
        formCompletion.setTypeface(Fonts.getMedium(activity));
        formCompletion.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
                builder.setTitle(getString(R.string.choose_form_end));
                final CompletionFormItem[] completionForms = person.getSettings().getWorkCompletionForms();
                final String[] itemsWorkCompletion = new String[completionForms.length];
                for (int i = 0; i < itemsWorkCompletion.length; i++) {
                    itemsWorkCompletion[i] = completionForms[i].getName();
                }
                builder.setItems(Utils.parseFormCompletion(itemsWorkCompletion, getString(R.string.no)),
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int item) {
                                if (item == 0) {
                                    formCompletionID = null;
                                    formCompletion.setText(getString(R.string.no));
                                } else {
                                    formCompletionID = completionForms[item - 1].getId();
                                    formCompletion.setText(itemsWorkCompletion[item - 1]);
                                }
                            }
                        });
                builder.setCancelable(true);
                builder.show();
            }
        });

        comment = (EditText) findViewById(R.id.create_work_enter_comment);
    }

    /**
     * Метод используется для проверки разрешений к Камере
     */
    public boolean isCameraPermissionGranted() {
        if (Build.VERSION.SDK_INT >= 23) {
            if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
                return true;
            } else {
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, 101);
                return false;
            }
        } else {
            return true;
        }
    }

    /**
     * Инициализация кнопок (Сфотографировать, С устройства, Сохранить)
     */
    private void initButtons() {
        Button fromAndroid = (Button) findViewById(R.id.create_work_button1);
        fromAndroid.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                final OpenFileDialog fileDialog = new OpenFileDialog(activity);
                fileDialog.setOpenDialogListener(new OpenFileDialog.OpenDialogListener() {
                    @Override
                    public void OnSelectedFile(String fileName) {
                        if (!fileNames.contains(fileName)) {
                            fileNames.add(fileName);
                            addedFiles.addView(addFileName(new File(fileName).getName()));
                        } else {
                            AppMsg.makeText(activity, getString(R.string.filename_already_exists), AppMsg.STYLE_ALERT).show();
                        }
                    }
                });
                fileDialog.show();
            }
        });
        Button fromCamera = (Button) findViewById(R.id.create_work_button2);
        fromCamera.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                File file = new File(Environment.getExternalStorageDirectory() +
                        File.separator + Const.DIRECTORY_PHOTOS_NAME + File.separator);
                if (!file.exists()) {
                    file.mkdir();
                }
                photoFileName = System.currentTimeMillis();
                Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                Uri uriSavedImage = Uri.fromFile(new File(Environment.getExternalStorageDirectory() + File.separator +
                        Const.DIRECTORY_PHOTOS_NAME + File.separator + photoFileName + Const.DEFAULT_FILE_FORMAT));
                cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, uriSavedImage);

                //UPD: 2023-11-11 - добавил проверку разрешений, иначе приложение крашится
                if (isCameraPermissionGranted()) {
                    startActivityForResult(cameraIntent, ADD_PHOTO);
                }
            }
        });
        createWorkButton = (Button) findViewById(R.id.create_work_button_save);
        createWorkButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (work == null) {
                    createWork();
                } else {
                    changeWork();
                }
            }
        });
        if (work != null) {
            createWorkButton.setText(getString(R.string.save));
        }
    }

    /**
     * Запрос на изменение работы
     *
     * @param stDate - время создания
     * @param fnDate - время завершения
     */
    private void changeWorkRequest(String stDate, String fnDate) {
        ChangeWork changeWork = new ChangeWork(progressBar, activity, person);
        changeWork.setFileNames(fileNames);
        changeWork.setCompletionFormID(formCompletionID);
        changeWork.setFinishDate(fnDate);
        changeWork.setStartDate(stDate);
        if (!work.getUser().getID().equals(responsibleID)) {
            changeWork.setUserID(responsibleID);
        }
        changeWork.setName(nameWork.getText().toString());
        changeWork.setPriority(selectedPriority);
        changeWork.setActionID(work.getActionID());
        changeWork.execute();
    }

    /**
     * Запрос на создание работы
     *
     * @param stDate - время создания
     * @param fnDate - время завершения
     */
    private void createWorkRequest(String stDate, String fnDate) {
        CreateWork create = new CreateWork(progressBar, activity, person);
        // кнопка "создать"
        create.setCreateWorkButton(createWorkButton);
        // текст работы
        create.setName(nameWork.getText().toString());
        // добавлять ли ответственного
        create.setEnableResponsible(resCheckBox.isChecked());
        // автор работы
        create.setAuthorID(authorID);
        // исполнитель работы
        create.setUserID(responsibleID);
        // соисполнители (если есть)
        create.setResUserID(selectedUsers);
        // начальное время
        create.setStartDate(stDate);
        // время завершения
        create.setFinishDate(fnDate);
        // приоритет
        create.setPriority(selectedPriority);
        // передаем форму завершения
        create.setCompletionFormID(formCompletionID);
        // если комментарий есть - добавляем его
        create.setCommentText(comment.getText().toString());
        // передаем список файлов
        create.setFileNames(fileNames);
        // и запускаем поток
        create.execute();
    }

    /**
     * Нужные заголовки
     */
    private void initTitles() {
        authorTitle = (TextView) findViewById(R.id.title_create_work_author);
        executorsTitle = (TextView) findViewById(R.id.title_create_work_executors);
        commentTitle = (TextView) findViewById(R.id.create_work_enter_comment_title);
    }

    /**
     * Метод отправляет запрос на создания работы
     */
    private void createWork() {
        // если не заполнены необходимые поля - сообщаем об этом, иначе создаем работу
        if (nameWork.getText().length() != 0) {
            if (resCheckBox.isChecked()) {
                if (responsible.getText().length() == 0) {
                    AppMsg.makeText(activity, getString(R.string.empty_edit), AppMsg.STYLE_ALERT).show();
                    return;
                }
            }
            String stDate = DateUtils.parseData(startDate.getText().toString() + " " + startTime.getText().toString(),
                    DateUtils.DEFAULT_DATE_FORMAT, DateUtils.DEFAULT_EDIT_TEXT_DATE + " " + DateUtils.DEFAULT_EDIT_TEXT_TIME);
            String fnDate = DateUtils.parseData(finishDate.getText().toString() + " " + finishTime.getText().toString(),
                    DateUtils.DEFAULT_DATE_FORMAT, DateUtils.DEFAULT_EDIT_TEXT_DATE + " " + DateUtils.DEFAULT_EDIT_TEXT_TIME);
            createWorkRequest(stDate, fnDate);
        } else {
            AppMsg.makeText(activity, getString(R.string.empty_edit), AppMsg.STYLE_ALERT).show();
        }
    }

    /**
     * Вызывается при нажатии на кнопку "Сохранить"
     */
    private void changeWork() {
        if (nameWork.getText().length() != 0) {
            if (resCheckBox.isChecked()) {
                if (responsible.getText().length() == 0) {
                    AppMsg.makeText(activity, getString(R.string.empty_edit), AppMsg.STYLE_ALERT).show();
                    return;
                }
            }
            // если у работы несуществующий приоритет
            if (selectedPriority.equals("-1")) {
                AppMsg.makeText(activity, getString(R.string.message_incorrect_priority), AppMsg.STYLE_ALERT).show();
                return;
            }
            String stDate = DateUtils.parseData(startDate.getText().toString() + " " + startTime.getText().toString(),
                    DateUtils.DEFAULT_DATE_FORMAT, DateUtils.DEFAULT_EDIT_TEXT_DATE + " " + DateUtils.DEFAULT_EDIT_TEXT_TIME);
            String fnDate = DateUtils.parseData(finishDate.getText().toString() + " " + finishTime.getText().toString(),
                    DateUtils.DEFAULT_DATE_FORMAT, DateUtils.DEFAULT_EDIT_TEXT_DATE + " " + DateUtils.DEFAULT_EDIT_TEXT_TIME);
            try {
                Calendar cal1 = Calendar.getInstance();
                Calendar cal2 = Calendar.getInstance();
                cal1.setTime(new SimpleDateFormat(DateUtils.DEFAULT_DATE_FORMAT).parse(fnDate));
                cal2.setTime(new SimpleDateFormat(DateUtils.DEFAULT_DATE_FORMAT).parse(work.getFinish_date()));
                if (!work.getUser().getID().equals(responsibleID)) {
                    if (work.getIs_expired().equals("true")) {
                        if (!cal1.after(cal2)) {
                            AppMsg.makeText(activity, getString(R.string.can_not_change_expired_work_responsible), AppMsg.STYLE_ALERT).show();
                        } else {
                            showDialogChangeWork(stDate, fnDate);
                        }
                    } else {
                        showDialogChangeWork(stDate, fnDate);
                    }
                } else {
                    changeWorkRequest(stDate, fnDate);
                }
            } catch (Exception exc) {
                AppMsg.makeText(activity, exc.getMessage(), AppMsg.STYLE_ALERT).show();
            }
        } else {
            AppMsg.makeText(activity, getString(R.string.empty_edit), AppMsg.STYLE_ALERT).show();
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // ответственный
        if (requestCode == SELECT_RESPONSIBLE && resultCode != RESULT_CANCELED) {
            String userName = data.getStringExtra(ActivityConst.USER_NAME);
            responsibleID = data.getStringExtra(ActivityConst.USER_ID);
            responsible.setText(userName);
            executors.setText("");
            selectedUsers = null;
        } else if (requestCode == SELECT_AUTHOR && resultCode != RESULT_CANCELED) {
            String userName = data.getStringExtra(ActivityConst.USER_NAME);
            authorID = data.getStringExtra(ActivityConst.USER_ID);
            author.setText(userName);
        } else if (requestCode == SELECT_EXECUTORS && resultCode != RESULT_CANCELED) {
            UserSerializable userSerializable = (UserSerializable) data.getSerializableExtra(ActivityConst.USERS_ID);
            List<String> names = userSerializable.getNames();
            selectedUsers = userSerializable.getUsersID();
            executors.setText(names.toString().replace("[", "").replace("]", ""));
        } else if (requestCode == ADD_PHOTO && resultCode != RESULT_CANCELED) {
            final String filePathPhoto = Utils.getNewPhotoName(photoFileName, getBaseContext());
            fileNames.add(Environment.getExternalStorageDirectory() + "/" + Const.DIRECTORY_PHOTOS_NAME + "/" + filePathPhoto);
            addedFiles.addView(addFileName(filePathPhoto));
        }
    }

    /**
     * Отображения диаолга выбора даты
     *
     * @param edit - TextView
     */
    private void showDatePicker(final TextView edit) {
        DatePickerFragment date = new DatePickerFragment();
        Bundle args = new Bundle();
        args.putInt(DateUtils.YEAR, Integer.parseInt(DateUtils.parseData(edit.getText().toString(),
                "yyyy", DateUtils.DEFAULT_EDIT_TEXT_DATE)));
        args.putInt(DateUtils.MONTH, Integer.parseInt(DateUtils.parseData(edit.getText().toString(),
                "MM", DateUtils.DEFAULT_EDIT_TEXT_DATE)) - 1);
        args.putInt(DateUtils.DAY, Integer.parseInt(DateUtils.parseData(edit.getText().toString(),
                "dd", DateUtils.DEFAULT_EDIT_TEXT_DATE)));
        date.setArguments(args);
        date.setCallBack(new DatePickerDialog.OnDateSetListener() {
            @Override
            public void onDateSet(DatePicker datePicker, int year, int monthOfYear, int dayOfMonth) {
                edit.setText(DateUtils.changePickerDialog(dayOfMonth) + " / " + DateUtils.changePickerDialog(monthOfYear + 1)
                        + " / " + String.valueOf(year));
            }
        });
        date.show(getSupportFragmentManager(), "Date Picker");
    }

    /**
     * Отображения диаолга выбора времени
     *
     * @param edit - TextView
     */
    private void showTimePicker(final TextView edit) {
        TimePickerFragment date = new TimePickerFragment();
        Bundle args = new Bundle();
        args.putInt(DateUtils.HOUR, Integer.parseInt(DateUtils.parseData(edit.getText().toString(),
                "HH", DateUtils.DEFAULT_EDIT_TEXT_TIME)));
        args.putInt(DateUtils.MINUTES, Integer.parseInt(DateUtils.parseData(edit.getText().toString(),
                "mm", DateUtils.DEFAULT_EDIT_TEXT_TIME)));
        date.setArguments(args);
        date.setCallBack(new TimePickerDialog.OnTimeSetListener() {
            @Override
            public void onTimeSet(TimePicker timePicker, int hour, int minute) {
                edit.setText(DateUtils.changePickerDialog(hour) + ":" + DateUtils.changePickerDialog(minute));
            }
        });
        date.show(getSupportFragmentManager(), "Time Picker");
    }

    /**
     * Метод берет время создания работы из настроек
     */
    private void getDefaultData() {
        startDate.setText(DateUtils.parseData(person.getDefaults().getStart_date(),
                DateUtils.DEFAULT_EDIT_TEXT_DATE, DateUtils.DEFAULT_DATE_FORMAT));
        startTime.setText(DateUtils.parseData(person.getDefaults().getStart_date(),
                DateUtils.DEFAULT_EDIT_TEXT_TIME, DateUtils.DEFAULT_DATE_FORMAT));
        finishDate.setText(DateUtils.parseData(person.getDefaults().getFinish_date(),
                DateUtils.DEFAULT_EDIT_TEXT_DATE, DateUtils.DEFAULT_DATE_FORMAT));
        finishTime.setText(DateUtils.parseData(person.getDefaults().getFinish_date(),
                DateUtils.DEFAULT_EDIT_TEXT_TIME, DateUtils.DEFAULT_DATE_FORMAT));
    }

    /**
     * Метод берет время создания работы из текщей работы
     */
    private void getWorkData() {
        startDate.setText(DateUtils.parseData(work.getStart_date(),
                DateUtils.DEFAULT_EDIT_TEXT_DATE, DateUtils.DEFAULT_DATE_FORMAT));
        startTime.setText(DateUtils.parseData(work.getStart_date(),
                DateUtils.DEFAULT_EDIT_TEXT_TIME, DateUtils.DEFAULT_DATE_FORMAT));
        finishDate.setText(DateUtils.parseData(work.getFinish_date(),
                DateUtils.DEFAULT_EDIT_TEXT_DATE, DateUtils.DEFAULT_DATE_FORMAT));
        finishTime.setText(DateUtils.parseData(work.getFinish_date(),
                DateUtils.DEFAULT_EDIT_TEXT_TIME, DateUtils.DEFAULT_DATE_FORMAT));
        progressBar.setVisibility(View.GONE);
    }

    /**
     * Добавление имени фалйа в леяут со списком добавленных вложений
     *
     * @param attachmentName - текст вложения
     * @return - TextView
     */
    private TextView addFileName(String attachmentName) {
        final int pixelMargin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 10, getResources().getDisplayMetrics());
        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,
                LinearLayout.LayoutParams.WRAP_CONTENT);
        params.setMargins(0, pixelMargin, 0, pixelMargin);
        TextView fName = new TextView(activity);
        fName.setText(attachmentName);
        fName.setTextColor(getResources().getColor(R.color.default_blue_color));
        fName.setTypeface(Fonts.getRoman(activity));
        fName.setLayoutParams(params);
        fName.setTag(attachmentName);
        fName.setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                removeAddedFile(v.getTag().toString());
                return true;
            }
        });
        return fName;
    }

    /**
     * Метод вызываетя при долгом нажатии (лонгтап) на добавленный ранее файл
     *
     * @param fileName имя файла
     */
    private void removeAddedFile(String fileName) {
        showRemoveFileDialogItem(fileName);
    }

    /**
     * Метод отображает диалог с одним единственным пунктом "Удалить"
     *
     * @param fileName имя файла
     */
    private void showRemoveFileDialogItem(final String fileName) {
        String[] items = {"Удалить"};
        AlertDialog.Builder builder = new AlertDialog.Builder(activity);
        builder.setTitle(getString(R.string.deleting_file));
        builder.setItems(items, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int item) {
                showRemoveFileDialog(fileName);
            }
        });
        builder.setCancelable(true);
        builder.show();
    }

    /**
     * Метод отображает диалог спрашивающий пользователя действительно ли он хочет удалить выбранный файл с двумя кнопками (да/нет)
     *
     * @param fileName имя файла
     */
    private void showRemoveFileDialog(final String fileName) {
        AlertDialog.Builder ad = new AlertDialog.Builder(activity);
        ad.setTitle(getString(R.string.deleting_file));  // заголовок
        ad.setMessage(getString(R.string.are_u_sure_deleting_file_question));
        ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int arg1) {
                // удаление имени файла из леяута
                for (int i = 0; i < addedFiles.getChildCount(); i++) {
                    if (((TextView) addedFiles.getChildAt(i)).getText().toString().equals(fileName)) {
                        addedFiles.removeViewAt(i);
                        break;
                    }
                }
                // удаление имени файла из массива добавленных файлов
                Iterator<String> iterator = fileNames.iterator();
                while (iterator.hasNext()) {
                    String fPath = iterator.next();
                    String fName = fPath.substring(fPath.lastIndexOf("/") + 1, fPath.length());
                    if (fName.equals(fileName)) {
                        iterator.remove();
                        break;
                    }
                }
            }
        });
        ad.setNegativeButton(getString(R.string.no), null);
        ad.setCancelable(true);
        ad.show();
    }

    /**
     * Диалог вызывается при изменении работы - если пользователь изменил ответственного
     *
     * @param stDate - дата создания
     * @param fnDate - дата завершения
     */
    private void showDialogChangeWork(final String stDate, final String fnDate) {
        AlertDialog.Builder ad = new AlertDialog.Builder(activity);
        ad.setTitle(getString(R.string.change_responsible));  // заголовок
        ad.setMessage(getString(R.string.message_change_responsible_change_work));
        ad.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int arg1) {
                changeWorkRequest(stDate, fnDate);
            }
        });
        ad.setNegativeButton(getString(R.string.no), null);
        ad.setCancelable(true);
        ad.show();
    }

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

    /**
     * Метод загружает дефолтные параметры для создания работы/резолюции при открытии экрана
     */
    private void getCreateDefaults() {
        new SendGetRequest("rest/api/workflow/work/create_defaults", person) {
            @Override
            protected void onPreExecute() {
                initComponents();
                super.onPreExecute();
            }

            @Override
            protected void onPostExecute(String result) {
                if (result == null) {
                    AppMsg.makeText(activity, getString(R.string.error_to_get_create_defaults), AppMsg.STYLE_ALERT).show();
                    return;
                }
                CreateDefaults createDefaults = null;
                try {
                    createDefaults = RestClient.getGson().fromJson(result, CreateDefaults.class);
                } catch (Exception exc) {
                    AppMsg.makeText(activity, getString(R.string.error_parsing), AppMsg.STYLE_ALERT).show();
                }
                if (createDefaults != null) {
                    person.setDefaults(createDefaults);
                    init();
                }
                super.onPostExecute(result);
            }
        }.execute();
    }
}
