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

import android.Manifest;
import android.app.ActionBar;
import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.ActivityCompat;
import android.text.TextUtils;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;

import com.devspark.appmsg.AppMsg;
import com.google.gson.JsonSyntaxException;
import com.pnikosis.materialishprogress.ProgressWheel;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import kz.arta.synergy.workflow.mobile.android.R;
import kz.arta.synergy.workflow.mobile.android.attachments.adapters.AdapterAttachments;
import kz.arta.synergy.workflow.mobile.android.attachments.models.AttachmentItem;
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.components.OpenFileDialog;
import kz.arta.synergy.workflow.mobile.android.common.models.Person;
import kz.arta.synergy.workflow.mobile.android.common.models.offline.OfflineAttachment;
import kz.arta.synergy.workflow.mobile.android.common.offline.add.AddAttachment;
import kz.arta.synergy.workflow.mobile.android.common.offline.add.AddCompletionFile;
import kz.arta.synergy.workflow.mobile.android.common.offline.get.WorkAttachmentsTable;
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.Fonts;
import kz.arta.synergy.workflow.mobile.android.common.utils.ImageLoader;
import kz.arta.synergy.workflow.mobile.android.common.utils.MyApplication;
import kz.arta.synergy.workflow.mobile.android.common.utils.Utils;
import kz.arta.synergy.workflow.mobile.android.files.manager.DownloadFile;
import kz.arta.synergy.workflow.mobile.android.files.manager.UploadFile;
import kz.arta.synergy.workflow.mobile.android.forms.general.activities.FormPlayer;
import kz.arta.synergy.workflow.mobile.android.forms.mobile.activities.FormPlayerNative;
import kz.arta.synergy.workflow.mobile.android.works.manager.completion.CompletionWorkFile;
import kz.arta.synergy.workflow.mobile.android.works.models.CompletionResultItem;

/**
 * Created by neox on 19.04.14.
 * Завершение работы с формой завершения файл
 */
public class CompletionWorkFileActivity extends Activity {

    /**
     * Имя файла
     */
    public static final String FILENAME = "FILENAME";

    /**
     * onActivityResult
     */
    private static final int PHOTO = 1;

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

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

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

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

    /**
     * Вложения
     */
    private List<AttachmentItem> attachmentsArray;

    /**
     * Адаптер для вложений
     */
    private AdapterAttachments adapterAttachments;

    /**
     * Список со вложениями
     */
    private ListView attachmentsList;

    /**
     * UUID текущей работы
     */
    private String workID;

    /**
     * Имя выбранного файла (текстовое поле)
     */
    private TextView selectedFileText;

    /**
     * Объект завершает работу
     */
    private CompletionWorkFile completionWorkFile;

    /**
     * Иконка выбранного вложения
     */
    private ImageView icon;

    /**
     * Панель с результатом завершения работы (используется при добавлении файла с устройства)
     */
    private LinearLayout resultPanel;

    /**
     * Заголовок "Результат работы"
     */
    private TextView resultWork;

    /**
     * Результаты дочерних работ
     */
    private CompletionResultItem params;

    /**
     * Имя файла сделанного с помощью камеры
     */
    private long photoFileName;

    /**
     * Выбран ли результат из завершенных
     */
    private boolean child;

    /**
     * Имя текущей работы
     */
    private String name;

    /**
     * Выбран ли файл с устройства, либо нет
     */
    private boolean fromDevice;

    /**
     * Путь до файла выбранного с устройства
     */
    private String filePath;

    /**
     * Имя выбранного файла с устройства
     */
    private String fileName;

    /**
     * UUID выделенного файла
     */
    private String fileUUID;

    /**
     * Идентификатор данных по форме
     */
    private String dataUUID;

    /**
     * Имеется ли у формы мобильное представление
     */
    private boolean mobile;

    /**
     * Метод используется для проверки разрешений к Камере
     */
    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;
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {

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

        activity = this;

        Intent intent = getIntent();
        person = (Person) intent.getSerializableExtra(ActivityConst.PERSON);
        workID = intent.getStringExtra(ActivityConst.WORK_ID);
        name = intent.getStringExtra(ActivityConst.WORK_NAME);

        ActionBar actionBar = getActionBar();
        if (actionBar != null) {
            actionBar.hide();
            ((TextView) findViewById(R.id.title_action_bar_result)).setTypeface(Fonts.getMedium(activity));
        }

        settings = activity.getSharedPreferences(SettingsConst.DEFAULT_NAME_SETTINGS, Context.MODE_PRIVATE);

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

        // создаем объект для завершения работы и вбиваем в него первоначальные данные
        completionWorkFile = new CompletionWorkFile();
        completionWorkFile.setPerson(person);
        completionWorkFile.setActivity(activity);
        completionWorkFile.setWorkID(workID);
        completionWorkFile.setProgressBar(progressBar);

        // связываем нужные компоненты с java кодом
        createComponents();

        // из запускаем поток
        new Main().execute();
    }

    private void createComponents() {
        // кнопка "добавить файл с устройства"
        Button addFileFromDevice = (Button) findViewById(R.id.completion_work_file_button1);
        addFileFromDevice.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 fPath) {
                        dataUUID = null;
                        fromDevice = true;
                        filePath = fPath;
                        fileName = new File(fPath).getName();
                        selectedFileText.setText(new File(fPath).getName());
                        // включаем блок отвечающий за выбранный файл
                        resultPanel.setVisibility(View.VISIBLE);
                        // и title для него
                        resultWork.setVisibility(View.VISIBLE);
                        // and icon
                        icon.setVisibility(View.VISIBLE);
                        // дефолтная иконка для оффлайн вложений
                        icon.setBackgroundResource(R.drawable.no_icon);
                        if (!Utils.isOnline(activity, person.getHost()) && (Utils.checkSyncEnables(settings))) {
                            new AddCompletionFile(activity).add(workID, fileName, null, fPath, null, name, "true");
                        }
                    }
                });
                fileDialog.show();
            }
        });

        // кнопка сфотографировать
        Button addFileFromCamera = (Button) findViewById(R.id.completion_work_file_button2);
        addFileFromCamera.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, PHOTO);
                }
            }
        });

        // кнопка "сохранить" - завершает работу
        Button saveButton = (Button) findViewById(R.id.completion_work_button_save);
        saveButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // если не выбрана форма завершения то оповещаем пользователя об этом
                if (selectedFileText.getText() != null && !TextUtils.isEmpty(selectedFileText.getText())) {
                    if (Utils.isOnline(activity, person.getHost())) {
                        if (fromDevice) {
                            AddFile addFile = new AddFile();
                            addFile.setWorkID(workID);
                            addFile.setFilePath(filePath);
                            addFile.setFileName(fileName);
                            addFile.execute();
                        } else {
                            progressBar.setVisibility(View.VISIBLE);
                            // если если выбрал польозватель результат из завершенных
                            completionWorkFile.execute();
                        }
                    } else {
                        Intent intent = new Intent();
                        intent.putExtra(FILENAME, selectedFileText.getText());
                        setResult(RESULT_OK, intent);
                        finish();
                    }
                } else {
                    AppMsg.makeText(activity, getString(R.string.select_result_work), AppMsg.STYLE_ALERT).show();
                }
            }
        });

        resultWork = (TextView) findViewById(R.id.completion_work_file_result_title);
        resultWork.setText(resultWork.getText() + ":");
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == PHOTO) {
            if (resultCode != RESULT_CANCELED) {

                final String filePath = Environment.getExternalStorageDirectory() + File.separator +
                        Const.DIRECTORY_PHOTOS_NAME + File.separator + photoFileName + Const.DEFAULT_FILE_FORMAT;
                final String fileName = Utils.getNewPhotoName(photoFileName, getBaseContext());

                dataUUID = null;
                fromDevice = true;

                CompletionWorkFileActivity.this.filePath = filePath;
                CompletionWorkFileActivity.this.fileName = fileName;

                selectedFileText.setText(fileName);
                // включаем блок отвечающий за выбранный файл
                resultPanel.setVisibility(View.VISIBLE);
                // и title для него
                resultWork.setVisibility(View.VISIBLE);
                // and icon
                icon.setVisibility(View.VISIBLE);
                // дефолтная иконка для оффлайн вложений
                icon.setBackgroundResource(R.drawable.no_icon);

                if (!Utils.isOnline(activity, person.getHost()) && (Utils.checkSyncEnables(settings))) {
                    new AddCompletionFile(activity).add(workID, fileName, null, filePath, null, name, "true");
                }
            }
        }
    }

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

    /**
     * Используется для открытия файла
     *
     * @param fileName - имя файла
     * @param uuid     - uuid файла
     */
    private void openFile(String fileName, String uuid) {
        if (Utils.isOnline(activity, person.getHost())) {
            DownloadFile downloadFile = new DownloadFile(activity, person);
            downloadFile.setFileName(fileName);
            downloadFile.setUrl(person.getHost() + "rest/api/storage/pdf/get?identifier=" + uuid);
            downloadFile.execute();
        } else if (Utils.checkSyncEnables(settings)) {
            String filePath = new WorkAttachmentsTable(activity).getFilePathByUUID(uuid);
            if (filePath == null) {
                return;
            }
            String mime = Utils.getMimeByFilename(filePath);
            Intent intent = new Intent();
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            intent.setAction(Intent.ACTION_VIEW);
            intent.setDataAndType(Uri.fromFile(new File(filePath)), mime);
            try {
                activity.startActivity(intent);
            } catch (ActivityNotFoundException e) {
                AppMsg.makeText(activity, activity.getString(R.string.unknown_file), AppMsg.STYLE_ALERT).show();
            }
        }
    }

    /**
     * Проверяет имеются ли завершенные результаты дочерних работ
     */
    class Main extends AsyncTask<Void, Void, String> {

        @Override
        protected void onPostExecute(String result) {

            // создаем список, адаптер, новости и связываем все это дело
            attachmentsArray = new ArrayList<>();
            attachmentsList = (ListView) findViewById(R.id.attach_list_completion_work_file);
            adapterAttachments = new AdapterAttachments(activity, attachmentsArray, person);
            attachmentsList.setAdapter(adapterAttachments);

            resultPanel = (LinearLayout) findViewById(R.id.completion_form_file_result_work_block);
            resultPanel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (dataUUID != null) {
                        // если есть мобильное представление
                        if (mobile) {
                            Intent intent = new Intent(activity, FormPlayerNative.class);
                            intent.putExtra(ActivityConst.DATA_UUID, dataUUID);
                            intent.putExtra(ActivityConst.PERSON, person);
                            intent.putExtra(ActivityConst.CAN_EDIT, "true");
                            activity.startActivityForResult(intent, ActionUtils.SAVE_FORM);
                        } else {
                            Intent intent = new Intent(activity, FormPlayer.class);
                            intent.putExtra(ActivityConst.DATA_UUID, dataUUID);
                            intent.putExtra(ActivityConst.PERSON, person);
                            intent.putExtra(ActivityConst.CAN_EDIT, "true");
                            activity.startActivityForResult(intent, ActionUtils.SAVE_FORM);
                        }
                    } else {
                        if (fromDevice) {
                            Utils.openFileFromDevice(filePath, activity);
                        } else {
                            openFile(fileName, fileUUID);
                        }
                    }
                }
            });

            final ImageLoader imageLoader = new ImageLoader(activity, person);
            icon = (ImageView) findViewById(R.id.icon_attachment_completion_work_file);
            selectedFileText = (TextView) findViewById(R.id.text_attachment_completion_work_file);
            selectedFileText.setTypeface(Fonts.getMedium(activity));

            if (result != null) {
                try {
                    params = RestClient.getGson().fromJson(result, CompletionResultItem.class);
                } catch (JsonSyntaxException exc) {
                    params = null;
                }
                // если нам пришел валидный json
                if (params != null) {

                    // клик по списку
                    attachmentsList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                        @Override
                        public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {

                            mobile = Boolean.parseBoolean(attachmentsArray.get(i).getMobile());
                            dataUUID = attachmentsArray.get(i).getDataUUID();
                            fileUUID = attachmentsArray.get(i).getUuid();
                            fromDevice = false;
                            filePath = "";

                            if (child) {
                                completionWorkFile.setResultID(params.getPrevious_results()[i].getResultID());
                                completionWorkFile.setFileName(null);
                                completionWorkFile.setFileIdentifier(null);
                                completionWorkFile.setType(null);
                                completionWorkFile.setType("work");
                            } else {
                                completionWorkFile.setResultID(null);
                                completionWorkFile.setFileName(attachmentsArray.get(i).getName());
                                completionWorkFile.setFileIdentifier(fileUUID);
                                completionWorkFile.setType("work");
                            }

                            // загружаем изображение при клике
                            imageLoader.displayImage(Utils.parseUrlToIcon(person.getHost() + attachmentsArray.get(i).getIcon()), icon);
                            // пишем в текствьюшку имя выбранного файла
                            selectedFileText.setText(attachmentsArray.get(i).getName());
                            // включаем блок отвечающий за выбранный файл
                            resultPanel.setVisibility(View.VISIBLE);
                            // и title для него
                            resultWork.setVisibility(View.VISIBLE);
                            // and icon
                            icon.setVisibility(View.VISIBLE);
                        }
                    });

                    // если есть дочерние работы
                    if (params.getPrevious_results() != null) {
                        if (params.getPrevious_results().length != 0) {

                            // кнопка "из работы"
                            final Button fromWorkButton = (Button) findViewById(R.id.completion_work_button_from_work);
                            fromWorkButton.setTypeface(Fonts.getMedium(activity));

                            // кнопка "перепорученные"
                            final Button reassignedButton = (Button) findViewById(R.id.completion_work_button_reassigned);
                            reassignedButton.setTypeface(Fonts.getMedium(activity));
                            reassignedButton.setTextColor(getResources().getColor(R.color.default_darken_gray));

                            // клик по кнопке "из работы"
                            fromWorkButton.setOnClickListener(new View.OnClickListener() {
                                @Override
                                public void onClick(View view) {
                                    child = false;
                                    resultWork.setVisibility(View.GONE);
                                    resultPanel.setVisibility(View.GONE);
                                    selectedFileText.setText("");
                                    fromWorkButton.setBackgroundResource(R.drawable.button_left_form_completion_file);
                                    reassignedButton.setBackgroundResource(R.drawable.button_right_form_completion_file_no_active);
                                    reassignedButton.setTextColor(getResources().getColor(R.color.default_darken_gray));
                                    fromWorkButton.setTextColor(getResources().getColor(R.color.completion_work_file_pressed_button_title));
                                    // грузим вложения
                                    new GetAttach().execute();
                                }
                            });

                            // клик по кнопке "перепорученные"
                            reassignedButton.setOnClickListener(new View.OnClickListener() {
                                @Override
                                public void onClick(View view) {
                                    child = true;
                                    resultWork.setVisibility(View.GONE);
                                    resultPanel.setVisibility(View.GONE);
                                    progressBar.setVisibility(View.VISIBLE);
                                    selectedFileText.setText("");
                                    fromWorkButton.setBackgroundResource(R.drawable.button_left_form_completion_file_no_active);
                                    reassignedButton.setBackgroundResource(R.drawable.button_right_form_completion_file);
                                    reassignedButton.setTextColor(getResources().getColor(R.color.completion_work_file_pressed_button_title));
                                    fromWorkButton.setTextColor(getResources().getColor(R.color.default_darken_gray));
                                    attachmentsArray.clear();
                                    // вставляем работы которые возвратил сервер в наши
                                    for (int i = 0; i < params.getPrevious_results().length; i++) {
                                        AttachmentItem attachmentItem = new AttachmentItem();
                                        attachmentItem.setIcon(params.getPrevious_results()[i].getFile_icon());
                                        attachmentItem.setName(params.getPrevious_results()[i].getFile_name());
                                        attachmentsArray.add(attachmentItem);
                                    }
                                    // обновляем адаптер
                                    adapterAttachments.notifyDataSetChanged();
                                    // выставляем высоту для списка после его заполнения
                                    Utils.setListViewHeightBasedOnChildren(attachmentsList);
                                    // и делаем visible
                                    attachmentsList.setVisibility(View.VISIBLE);
                                    // выключаем прогрессбар
                                    progressBar.setVisibility(View.GONE);
                                }
                            });

                            LinearLayout buttons = (LinearLayout) findViewById(R.id.buttons_end_work_completion);
                            buttons.setVisibility(View.VISIBLE);

                            attachmentsList.setBackgroundResource(R.drawable.end_work_completion_file_list_background);
                        }
                    }
                }
            } else if (Utils.checkSyncEnables(settings)) {
                attachmentsList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                    @Override
                    public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {

                        fileUUID = attachmentsArray.get(i).getUuid();

                        fromDevice = false;

                        // добавляем для завершения работы
                        new AddCompletionFile(activity).add(workID, attachmentsArray.get(i).getName(), fileUUID, null, null, name, "false");

                        // пишем в текствьюшку имя выбранного файла
                        selectedFileText.setText(attachmentsArray.get(i).getName());
                        // включаем блок отвечающий за выбранный файл
                        resultPanel.setVisibility(View.VISIBLE);
                        // и title для него
                        resultWork.setVisibility(View.VISIBLE);
                        // and icon
                        icon.setVisibility(View.VISIBLE);
                        // дефолтная иконка для оффлайн вложений
                        icon.setBackgroundResource(R.drawable.no_icon);
                    }
                });
            } else {
                AppMsg.makeText(activity, getString(R.string.error_request), AppMsg.STYLE_ALERT).show();
            }
            new GetAttach().execute();
            super.onPostExecute(result);
        }

        @Override
        protected String doInBackground(Void... voids) {
            return new SendGetRequest(person).requestGET(person.getHost()
                    + "rest/api/workflow/work/get_completion_data?workID=" + workID + "&locale=" + MyApplication.getLang());
        }
    }

    /**
     * Загрузка списка вложений
     */
    class GetAttach extends AsyncTask<Void, Void, String> {

        @Override
        protected void onPostExecute(String result) {
            if (result != null) {
                try {
                    AttachmentItem[] attachmentItemAttachments = RestClient.getGson().fromJson(result, AttachmentItem[].class);
                    // отображение лейбла "Файлы из работы"
                    findViewById(R.id.files_from_work_title).setVisibility(View.VISIBLE);
                    // вставляем работы которые возвратил сервер в наши
                    Collections.addAll(attachmentsArray, attachmentItemAttachments);
                    // обновляем адаптер
                    adapterAttachments.notifyDataSetChanged();
                    // выставляем высоту для списка после его заполнения
                    Utils.setListViewHeightBasedOnChildren(attachmentsList);
                    // и делаем visible
                    attachmentsList.setVisibility(View.VISIBLE);
                } catch (Exception exc) {
                    AppMsg.makeText(activity, getString(R.string.error_download_attachments), AppMsg.STYLE_ALERT).show();
                }
            } else if (Utils.checkSyncEnables(settings)) {
                WorkAttachmentsTable workAttachmentsTable = new WorkAttachmentsTable(activity);
                List<AttachmentItem> allAttachments = new ArrayList<>();
                List<OfflineAttachment> offlineAttachments = new AddAttachment(activity).get();
                if (offlineAttachments != null && offlineAttachments.size() != 0) {
                    for (OfflineAttachment offlineAttachment : offlineAttachments) {
                        if (offlineAttachment.getActionID().equals(workID)) {
                            AttachmentItem attachmentItem1 = new AttachmentItem();
                            attachmentItem1.setName(offlineAttachment.getFilepath());
                            allAttachments.add(attachmentItem1);
                        }
                    }
                }
                List<AttachmentItem> current = workAttachmentsTable.get(workID);
                for (AttachmentItem aCurrent : current) {
                    allAttachments.add(aCurrent);
                }
                // добавляем их в список
                if (!allAttachments.isEmpty()) {
                    // отображение лейбла "Файлы из работы"
                    findViewById(R.id.files_from_work_title).setVisibility(View.VISIBLE);
                    // вставляем работы которые возвратил сервер в наши
                    for (AttachmentItem currentAttachment : allAttachments) {
                        attachmentsArray.add(currentAttachment);
                    }
                    // обновляем адаптер
                    adapterAttachments.notifyDataSetChanged();
                    // выставляем высоту для списка после его заполнения
                    Utils.setListViewHeightBasedOnChildren(attachmentsList);
                    // и делаем visible
                    attachmentsList.setVisibility(View.VISIBLE);
                }
            } else {
                AppMsg.makeText(activity, getString(R.string.error_download_attachments), AppMsg.STYLE_ALERT).show();
            }
            progressBar.setVisibility(View.GONE);
            super.onPostExecute(result);
        }

        @Override
        protected String doInBackground(Void... voids) {
            return new SendGetRequest(person).requestGET(person.getHost() +
                    "rest/api/workflow/work/" + workID + "/last_attachments?count=999999" + "&locale=" + MyApplication.getLang());
        }
    }

    /**
     * Добавление файла
     */
    class AddFile extends AsyncTask<Void, Void, String> {

        String filePath;

        String fileName;

        String workID;

        public void setWorkID(String workID) {
            this.workID = workID;
        }

        public void setFilePath(String filePath) {
            this.filePath = filePath;
        }

        public void setFileName(String fileName) {
            this.fileName = fileName;
        }

        @Override
        protected void onPreExecute() {
            progressBar.setVisibility(View.VISIBLE);
            super.onPreExecute();
        }

        @Override
        protected void onPostExecute(String result) {
            if (result != null) {
                icon.setImageResource(R.drawable.no_icon);
                resultWork.setVisibility(View.VISIBLE);
                selectedFileText.setText(fileName);
                resultPanel.setVisibility(View.VISIBLE);
                progressBar.setVisibility(View.GONE);
                completionWorkFile.setType("file");
                completionWorkFile.setFileName(fileName);
                completionWorkFile.setFilePath(result);
                completionWorkFile.execute();
            } else {
                AppMsg.makeText(activity, getString(R.string.error_add_file), AppMsg.STYLE_ALERT).show();
                selectedFileText.setText("");
            }
            super.onPostExecute(result);
        }

        @Override
        protected String doInBackground(Void... voids) {
            UploadFile uploadFile = new UploadFile(person, true, UploadFile.INBOX_FILE);
            try {
                return uploadFile.uploadFile(workID, fileName, filePath, true);
            } catch (Exception exc) {
                return null;
            }
        }
    }
}
