package kz.arta.synergy.workflow.mobile.android.works.fragments;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Fragment;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.widget.SwipeRefreshLayout;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.TextView;

import com.devspark.appmsg.AppMsg;
import com.google.gson.JsonSyntaxException;
import com.jeremyfeinstein.slidingmenu.lib.SlidingMenu;
import com.pnikosis.materialishprogress.ProgressWheel;

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.common.ActivityConst;
import kz.arta.synergy.workflow.mobile.android.common.SettingsConst;
import kz.arta.synergy.workflow.mobile.android.common.activities.MainActivity;
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.models.settings.DialogInfoItem;
import kz.arta.synergy.workflow.mobile.android.common.offline.SyncMain;
import kz.arta.synergy.workflow.mobile.android.common.offline.get.WorksTable;
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.FragmentBackPressedListener;
import kz.arta.synergy.workflow.mobile.android.common.utils.FragmentConst;
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.common.utils.Wrapper;
import kz.arta.synergy.workflow.mobile.android.common.utils.swipelist.BaseSwipeListViewListener;
import kz.arta.synergy.workflow.mobile.android.common.utils.swipelist.SwipeListView;
import kz.arta.synergy.workflow.mobile.android.documents.DocumentConst;
import kz.arta.synergy.workflow.mobile.android.works.activities.create.CreateWorkActivity;
import kz.arta.synergy.workflow.mobile.android.works.activities.create.CreateWorkCustomActivity;
import kz.arta.synergy.workflow.mobile.android.works.adapters.AdapterWorkList;
import kz.arta.synergy.workflow.mobile.android.works.models.WorkItem;

/**
 * Created by neox on 01.11.14.
 * Список работ
 */
public class FragmentWorks extends Fragment {

    /**
     * Списки и компоненты для их работы (адаптеры, источники данных)
     */
    private SwipeListView mainList;
    private List<WorkItem> mainData;
    private AdapterWorkList mainAdapter;
    private ProgressWheel mainProgressBar;

    private SwipeListView childList;
    private List<WorkItem> childData;
    private AdapterWorkList childAdapter;
    private ProgressWheel childProgressBar;

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

    /**
     * Вся вьюха
     */
    private View view;

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

    /**
     * Урл на текущие работы
     */
    private String currentUrl;

    /**
     * Количество загружаемых работ
     */
    private int positionWork = 0;

    /**
     * Для динамического добавления работ при скорллинге
     */
    private boolean isLoading;

    /**
     * Номер выделенной работы в списке
     */
    private int selectedWork;

    /**
     * Ссылки до дочерних работ
     */
    private List<String> urlToChildData = new ArrayList<>();

    /**
     * Первая плашка для дочерних работ
     */
    private List<WorkItem> headChildData = new ArrayList<>();

    /**
     * Урл на дочерние работы
     */
    private String childUrl;

    /**
     * Позиция экрана дочерних работ (0 - дочерние работы закрыты)
     */
    private int positionChild = 0;

    /**
     * Боковая навигация (дочерние работы)
     */
    private SlidingMenu childDataSlidingMenu;

    /**
     * Текущий фрагмент
     */
    private Fragment fragment;

    /**
     * Типы текущего фильтра
     */
    private String fType = "OWN_WORKS";
    private String fID = null;
    private String oID = null;

    /**
     * Широковещательный приемник для получения обновлений от фильтров
     */
    private BroadcastReceiver filtersBroadcastReceiver;

    /**
     * Обновление спика работ свайпом
     */
    private SwipeRefreshLayout mainRefreshLayout;
    private SwipeRefreshLayout childRefreshLayout;

    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        fragment = this;
        view = inflater.inflate(R.layout.fragment_list, null);
        initComponents();
        // нажатие на кнопку "back"
        ((MainActivity) getActivity()).setFragmentBackPressedListener(new FragmentBackPressedListener() {
            @Override
            public void doBack() {
                if (((MainActivity) getActivity()).getFiltersSlidingMenu().isMenuShowing()) {
                    ((MainActivity) getActivity()).getFiltersSlidingMenu().toggle();
                } else {
                    backPressed();
                }
            }
        });
        return view;
    }

    /**
     * Приемник широковещательных сообщений для обновления списка работ из фильтров (на самом деле это не совсем правильно)
     */
    private void createBroadcastReceiver() {
        // сам BroadcastReceiver
        filtersBroadcastReceiver = new BroadcastReceiver() {
            // действия при получении сообщений
            public void onReceive(Context context, Intent intent) {
                String url = intent.getStringExtra(FragmentConst.URL_TO_WORKS);
                if (url != null) {
                    mainList.setSelection(0);
                    currentUrl = url;
                    positionWork = 0;
                    fType = intent.getStringExtra(DocumentConst.FILTER_TYPE);
                    fID = intent.getStringExtra(DocumentConst.FILTER_ID);
                    oID = intent.getStringExtra(DocumentConst.OBJECT_ID);
                    getWorkList(currentUrl, true, true, false);
                }
            }
        };
        // создаем фильтр для BroadcastReceiver
        IntentFilter intFilter = new IntentFilter(FragmentConst.UPDATE_LIST_BY_FILTERS);
        // регистрируем (включаем) BroadcastReceiver
        getActivity().registerReceiver(filtersBroadcastReceiver, intFilter);
    }

    /**
     * Начало инициализации компонентов
     */
    private void initComponents() {
        init();
        initMainList();
        initChildData();
        createBroadcastReceiver();
    }

    /**
     * Инициализация полей
     */
    private void init() {
        mSettings = getActivity().getSharedPreferences(SettingsConst.DEFAULT_NAME_SETTINGS, Context.MODE_PRIVATE);
        person = (Person) getArguments().getSerializable(ActivityConst.PERSON);
        currentUrl = "rest/api/workflow/works/list/" + person.getUuid() + "?locale=" + MyApplication.getLang() +
                "&startRecord=0&recordsCount=" + FragmentConst.DEFAULT_COUNT_WORKS;
    }

    /**
     * Список с основными работами
     */
    private void initMainList() {

        mainProgressBar = (ProgressWheel) view.findViewById(R.id.main_fragment_progress_bar);

        mainRefreshLayout = (SwipeRefreshLayout) view.findViewById(R.id.refresh);
        mainRefreshLayout.setColorSchemeResources(R.color.color1_update_list, R.color.color2_update_list,
                R.color.color3_update_list, R.color.color4_update_list);
        mainRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                mainRefreshLayout.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        isLoading = false;
                        positionWork = 0;
                        getWorkList(ActionUtils.parseWorkUrl(currentUrl, positionWork), true, false, true);
                    }
                }, 0);
            }
        });

        mainList = (SwipeListView) view.findViewById(R.id.refresh_list);
        mainData = new ArrayList<>();
        mainAdapter = new AdapterWorkList(getActivity().getApplicationContext(), mainData, false, R.layout.main_activity, person);
        mainList.setAdapter(mainAdapter);

        // скроллинг
        mainList.setOnScrollListener(new AbsListView.OnScrollListener() {
            @Override
            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
                // если работ больше 30 - динамически загружаем работы по 30 штук каждый раз
                if (totalItemCount >= FragmentConst.DEFAULT_COUNT_WORKS) {
                    final int lastItem = firstVisibleItem + visibleItemCount;
                    if (lastItem == totalItemCount) {
                        if (!isLoading) {
                            isLoading = true;
                            positionWork = positionWork + FragmentConst.DEFAULT_COUNT_WORKS;
                            getWorkList(ActionUtils.parseWorkUrl(currentUrl, positionWork), false, true, false);
                        }
                    }
                }
            }

            @Override
            public void onScrollStateChanged(AbsListView absListView, int i) {
            }

        });

        // свайп плашки
        mainList.setSwipeListViewListener(new BaseSwipeListViewListener() {
            @Override
            public void onOpened(int position, boolean toRight) {
                // если есть дочерние работы - открыаем их
                selectedWork = position;
                if (mainData.get(selectedWork).getHas_subprocesses().equals("true")) {
                    // если онлайн
                    if (Utils.isOnline(getActivity(), person.getHost())) {
                        headChildData.add(mainData.get(selectedWork));
                        childUrl = "rest/api/workflow/subworks/" + mainData.get(position).getActionID() + "?locale=" + MyApplication.getLang();
                        childDataSlidingMenu.showMenu();
                        positionChild++;
                        urlToChildData.add(childUrl);
                        getChildWorkList(childUrl, true);
                    } else {
                        AppMsg.makeText(getActivity(), getString(R.string.no_internet_connection), AppMsg.STYLE_ALERT).show();
                    }
                }
                mainList.closeOpenedItems();
            }

            @Override
            public void onClosed(int position, boolean fromRight) {
                mainRefreshLayout.setEnabled(true);
            }

            @Override
            public void onListChanged() {
            }

            @Override
            public void onMove(int position, float x) {
            }

            @Override
            public void onStartOpen(int position, int action, boolean right) {
                mainRefreshLayout.setEnabled(false);
            }

            @Override
            public void onStartClose(int position, boolean right) {
            }

            @Override
            public void onDouble(int position) {

            }

            @Override
            public void onSingle(int position) {
                if (mainData != null && mainData.size() != 0) {
                    // говорим, что просмотрели изменения
                    ActionUtils.markWorkSeen(mainData.get(position).getActionID(), person);
                    // и открываем
                    ActionUtils.openWork(mainData, position, getActivity(), fragment, person);
                }
            }

            @Override
            public void onLong(int position) {
                if (Utils.isOnline(getActivity(), person.getHost())) {
                    selectedWork = position;
                    showDialog(selectedWork);
                }
            }

            @Override
            public void onClickBackView(int position) {
            }

            @Override
            public void onDismiss(int[] reverseSortedPositions) {
            }
        });
        getWorkList(currentUrl, true, true, false);
    }

    /**
     * Метод вызывается при долгом нажатии на плашку
     *
     * @param selectedWork - id выделенной работы
     */
    private void showDialog(final int selectedWork) {
        FragmentCreateWork.hasUsers = false;
        AlertDialog.Builder dialogWork = new AlertDialog.Builder(getActivity());
        dialogWork.setTitle(getString(R.string.edit_work));
        final List<String> items = new ArrayList<>();
        if (positionWork == 0) {
            if (mainData.get(selectedWork).getCan_edit().equals("true")) {
                items.add(getString(R.string.edit));
            }
            if (mainData.get(selectedWork).getCan_delete().equals("true")) {
                items.add(getString(R.string.delete));
            }
        } else {
            if (childData.get(selectedWork).getCan_edit().equals("true")) {
                items.add(getString(R.string.edit));
            }
            if (childData.get(selectedWork).getCan_delete().equals("true")) {
                items.add(getString(R.string.delete));
            }
        }
        dialogWork.setItems(items.toArray(new String[items.size()]), new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int item) {
                if (items.get(item).equals(getString(R.string.edit))) {
                    openEditWorkActivity();
                } else if (items.get(item).equals(getString(R.string.delete))) {
                    String titleDialog;
                    if (!childDataSlidingMenu.isMenuShowing()) {
                        titleDialog = getString(R.string.delete_this_work) + " \"" + mainData.get(selectedWork).getName() + "\"?";
                    } else {
                        titleDialog = getString(R.string.delete_this_work) + " \"" + childData.get(selectedWork).getName() + "\"?";
                    }
                    AlertDialog.Builder adb = new AlertDialog.Builder(getActivity());
                    adb.setTitle(getActivity().getString(R.string.deleting_work_title));
                    adb.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            removeWork();
                        }
                    });
                    adb.setNegativeButton(getString(R.string.no), null);
                    adb.setMessage(titleDialog);
                    adb.show();
                }
            }
        });
        dialogWork.setCancelable(true);
        if (!items.isEmpty()) {
            dialogWork.show();
        }
    }

    /**
     * Список с дочерними работами
     */
    private void initChildData() {
        childDataSlidingMenu = new SlidingMenu(getActivity().getApplicationContext());
        childDataSlidingMenu.setMode(SlidingMenu.RIGHT);
        childDataSlidingMenu.attachToActivity(getActivity(), SlidingMenu.SLIDING_CONTENT);
        childDataSlidingMenu.setMenu(initChildWorksList());
        childDataSlidingMenu.setSlidingEnabled(false);
        childDataSlidingMenu.setBehindOffset(Utils.convertDpToPixel(Const.SLIDING_MENU_BEHIND_WIDTH, getActivity()));
        childDataSlidingMenu.setOnClosedListener(new SlidingMenu.OnClosedListener() {
            @Override
            public void onClosed() {
                positionChild = 0;
                headChildData.clear();
                childDataSlidingMenu.setSlidingEnabled(false);
                ((MainActivity) getActivity()).getFiltersSlidingMenu().setSlidingEnabled(true);
                ((MainActivity) getActivity()).createEventActionBar();
            }
        });
        childDataSlidingMenu.setOnOpenedListener(new SlidingMenu.OnOpenedListener() {
            @Override
            public void onOpened() {
                childDataSlidingMenu.setSlidingEnabled(true);
                ((MainActivity) getActivity()).getFiltersSlidingMenu().setSlidingEnabled(false);
            }
        });
    }

    /**
     * Загружает работы в список
     *
     * @param url        - ссылка до списка с работами
     * @param clearList  - очищать ли список с работами при загрузке работ
     * @param syncServer - синхронизировать ли данные
     */
    public void getWorkList(String url, final boolean clearList, final boolean showProgress, final boolean syncServer) {
        new SendGetRequest(url, person) {
            @Override
            protected void onPreExecute() {
                if (showProgress) {
                    mainProgressBar.setVisibility(View.VISIBLE);
                }
                super.onPreExecute();
            }

            @Override
            protected void onPostExecute(String result) {
                mainProgressBar.setVisibility(View.GONE);
                if (syncServer && !SyncMain.canSync && Utils.checkSyncEnables(mSettings)) {
                    AppMsg.makeText(getActivity(), getString(R.string.can_not_sync), AppMsg.STYLE_ALERT).show();
                    mainRefreshLayout.setRefreshing(false);
                    return;
                }
                if (result != null) {
                    try {
                        WorkItem[] works = RestClient.getGson().fromJson(result, WorkItem[].class);
                        if (works.length != 0) {
                            // если включен флаг "очищать список" - очищаем, нужно для полного обновления работ
                            if (clearList) {
                                mainData.clear();
                            }
                            Collections.addAll(mainData, works);
                            if (syncServer && Utils.checkSyncEnables(mSettings) && Utils.isOnline(getActivity(), person.getHost())) {
                                sync();
                            }
                            isLoading = false;
                        } else {
                            if (clearList) {
                                mainData.clear();
                            }
                            isLoading = true;
                        }
                    } catch (Exception exc) {
                        AppMsg.makeText(getActivity(), getString(R.string.no_connection), AppMsg.STYLE_ALERT).show();
                    }
                    refreshMainList();
                } else if (Utils.checkSyncEnables(mSettings)) {
                    if (!clearList) {
                        return;
                    }
                    getOfflineWorks();
                } else {
                    mainData.clear();
                    refreshMainList();
                    AppMsg.makeText(getActivity(), getString(R.string.no_connection), AppMsg.STYLE_ALERT).show();
                }
                super.onPostExecute(result);
            }
        }.execute();
    }

    /**
     * Данный метод синхронизирует работы, которые отображаются на данный момент в списке
     * Вызывается при обновлении списка свайпом
     */
    private void sync() {
        List<WorkItem> works = new WorksTable(getActivity().getBaseContext()).getWorks();
        if (works.isEmpty()) {
            AppMsg.makeText(getActivity(), getActivity().getString(R.string.no_sync_data), AppMsg.STYLE_ALERT).show();
            return;
        }
        if (!SyncMain.canSync) {
            AppMsg.makeText(getActivity(), getString(R.string.can_not_sync), AppMsg.STYLE_ALERT).show();
            return;
        }
        new SendGetRequest("about", person) {
            @Override
            protected void onPostExecute(String result) {
                if (result == null) {
                    return;
                }
                SyncMain offline = new SyncMain(getActivity(), person);
                offline.setAllSync(false);
                offline.setShowProgress(false);
                offline.setSend(false);
                offline.setAllWorks(mainData);
                offline.setfType(fType);
                offline.setfID(fID);
                offline.setoID(oID);
                offline.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
                super.onPostExecute(result);
            }
        }.execute();
    }

    /**
     * Метод инициализирует список дочерних работ и возвращает view
     *
     * @return view
     */
    public View initChildWorksList() {

        LayoutInflater ltInflater = getActivity().getLayoutInflater();
        View view = ltInflater.inflate(R.layout.child_works_activity, null, false);

        ((TextView) view.findViewById(R.id.title_action_bar_child_works)).setTypeface(Fonts.getMedium(getActivity()));

        // прогрессбар
        childProgressBar = (ProgressWheel) view.findViewById(R.id.child_work_progress_bar);

        // обновление дочерних работ свайпом
        childRefreshLayout = (SwipeRefreshLayout) view.findViewById(R.id.refresh_child);
        childRefreshLayout.setColorSchemeResources(R.color.color1_update_list, R.color.color2_update_list,
                R.color.color3_update_list, R.color.color4_update_list);
        childRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                childRefreshLayout.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        getChildWorkList(childUrl, false);
                    }
                }, 0);
            }
        });

        childList = (SwipeListView) view.findViewById(R.id.pull_refresh_list_child_works);
        childData = new ArrayList<>();
        childAdapter = new AdapterWorkList(getActivity().getApplicationContext(), childData, true, R.layout.main_activity, person);
        childList.setAdapter(childAdapter);

        // открытие дочерней работы
        childList.setSwipeListViewListener(new BaseSwipeListViewListener() {
            @Override
            public void onOpened(int position, boolean toRight) {
                selectedWork = position;
                if (selectedWork != 0 && childData.get(selectedWork).getHas_subprocesses().equals("true")) {
                    if (Utils.isOnline(getActivity(), person.getHost())) {
                        headChildData.add(childData.get(selectedWork));
                        childProgressBar.setVisibility(View.VISIBLE);
                        childUrl = "rest/api/workflow/subworks/" + childData.get(selectedWork).getActionID() + "?locale=" + MyApplication.getLang();
                        positionChild++;
                        getChildWorkList(childUrl, true);
                        urlToChildData.add(childUrl);
                    } else {
                        AppMsg.makeText(getActivity(), getString(R.string.no_internet_connection), AppMsg.STYLE_ALERT).show();
                    }
                }
                childList.closeOpenedItems();
            }

            @Override
            public void onSingle(int position) {
                // делаем работу просмотренной
                ActionUtils.markWorkSeen(childData.get(position).getActionID(), person);
                // а также открываем активити
                ActionUtils.openWork(childData, position, getActivity(), fragment, person);
            }

            @Override
            public void onDouble(int position) {

            }

            @Override
            public void onLong(int position) {
                if (Utils.isOnline(getActivity(), person.getHost())) {
                    selectedWork = position;
                    showDialog(selectedWork);
                }
            }

            @Override
            public void onClosed(int position, boolean fromRight) {
                childRefreshLayout.setEnabled(true);
            }

            @Override
            public void onListChanged() {
            }

            @Override
            public void onMove(int position, float x) {
            }

            @Override
            public void onStartOpen(int position, int action, boolean right) {
                childRefreshLayout.setEnabled(false);
            }

            @Override
            public void onStartClose(int position, boolean right) {
            }

            @Override
            public void onClickBackView(int position) {
            }

            @Override
            public void onDismiss(int[] reverseSortedPositions) {
            }
        });
        return view;
    }

    /**
     * Метод аналогичен методу getWorkList, только загружает дочерние работы
     *
     * @param url          ссылка до дочерних работ
     * @param showProgress отображать ли прогресс
     */
    private void getChildWorkList(String url, final boolean showProgress) {
        new SendGetRequest(url, person) {
            @Override
            protected void onPreExecute() {
                if (showProgress) {
                    childProgressBar.setVisibility(View.VISIBLE);
                }
                super.onPreExecute();
            }

            @Override
            protected void onPostExecute(String result) {
                childProgressBar.setVisibility(View.GONE);
                if (result != null) {
                    try {
                        WorkItem[] works = RestClient.getGson().fromJson(result, WorkItem[].class);
                        if (works.length != 0) {
                            childData.clear();
                            childData.add(headChildData.get(positionChild - 1));
                            Collections.addAll(childData, works);
                        } else {
                            // если дочерние вдруг кончились - закрываем боковую навигацию, и грузим заного список основных работ
                            childData.clear();
                            positionChild = 0;
                            childDataSlidingMenu.toggle();
                            getWorkList(currentUrl, true, true, false);
                        }
                    } catch (Exception exc) {
                        AppMsg.makeText(getActivity(), getString(R.string.error_download_works), AppMsg.STYLE_ALERT).show();
                    }
                    refreshChildList();
                } else {
                    childData.clear();
                    refreshChildList();
                    AppMsg.makeText(getActivity(), getString(R.string.error_download_works), AppMsg.STYLE_ALERT).show();
                }
                super.onPostExecute(result);
            }
        }.execute();
    }

    /**
     * Удаляет работу
     * В случае успешного выполнения - список работ обновляется
     * Иначе - отображается сообщение об ошибке
     */
    private void removeWork() {
        String url;
        if (positionChild == 0) {
            url = "rest/api/workflow/work/delete?workID=" + mainData.get(selectedWork).getActionID();
        } else {
            url = "rest/api/workflow/work/delete?workID=" + childData.get(selectedWork).getActionID();
        }
        new SendGetRequest(url + "&locale=" + MyApplication.getLang(), person) {
            @Override
            protected void onPreExecute() {
                if (positionChild == 0) {
                    mainProgressBar.setVisibility(View.VISIBLE);
                } else {
                    childProgressBar.setVisibility(View.VISIBLE);
                }
                super.onPreExecute();
            }

            @Override
            protected void onPostExecute(String result) {
                if (result != null) {
                    ErrorCode errorCode;
                    try {
                        errorCode = RestClient.getGson().fromJson(result, ErrorCode.class);
                    } catch (JsonSyntaxException e) {
                        errorCode = null;
                    }
                    if (errorCode != null) {
                        if (errorCode.getErrorCode().equals(Wrapper.NO_ERROR)) {
                            if (positionChild == 0) {
                                getWorkList(currentUrl, true, true, false);
                            } else {
                                getChildWorkList(childUrl, true);
                            }
                        } else {
                            AppMsg.makeText(getActivity(), errorCode.getErrorMessage(), AppMsg.STYLE_ALERT).show();
                        }
                    }
                    if (positionChild == 0) {
                        mainProgressBar.setVisibility(View.GONE);
                    } else {
                        childProgressBar.setVisibility(View.GONE);
                    }
                } else {
                    if (positionChild == 0) {
                        mainProgressBar.setVisibility(View.GONE);
                    } else {
                        childProgressBar.setVisibility(View.GONE);
                    }
                    AppMsg.makeText(getActivity(), getString(R.string.error_send_request), AppMsg.STYLE_ALERT).show();
                }
                super.onPostExecute(result);
            }
        }.execute();
    }

    /**
     * Открывает активити для редактирования работы
     */
    private void openEditWorkActivity() {
        new SendGetRequest("rest/api/workflow/get_dialog_info?type=WORK&locale=" + MyApplication.getLang(), person) {
            @Override
            protected void onPreExecute() {
                if (positionChild == 0) {
                    mainProgressBar.setVisibility(View.VISIBLE);
                } else {
                    childProgressBar.setVisibility(View.VISIBLE);
                }
                super.onPreExecute();
            }

            @Override
            protected void onPostExecute(String result) {
                if (result != null) {
                    // todo временное решение, пока не будут реализованы эти компоненты
                    result = result.replace("REPEAT, ", "").replace("KEYWORDS, ", "").replace("LOAD, ", "");
                    result = result.replace("REPEAT", "").replace("KEYWORDS", "").replace("LOAD", "");
                    if (result.contains(",{\"components\" :\"[]\"}")) {
                        result = result.replace(",{\"components\" :\"[]\"}", "");
                    }
                    // для редактируемой работы удаляем компонент "Комментарий"
                    if (result.contains(",{\"components\" :\"[COMMENT]\"}")) {
                        result = result.replace(",{\"components\" :\"[COMMENT]\"}", "");
                    }
                    if (result.contains("NAME,")) {
                        result = result.replace("NAME,", "NAME, RESPONSIBLE,");
                    }
                    DialogInfoItem dialog = null;
                    try {
                        dialog = RestClient.getGson().fromJson(result, DialogInfoItem.class);
                    } catch (Exception exc) {
                        AppMsg.makeText(getActivity(), getString(R.string.error_parsing), AppMsg.STYLE_ALERT).show();
                    }
                    if (dialog != null) {
                        Intent intent;
                        intent = new Intent(getActivity(), (dialog.getSpecial().equals("true") ? CreateWorkCustomActivity.class : CreateWorkActivity.class));
                        intent.putExtra(ActivityConst.DIALOG_NAME, dialog.getName());
                        intent.putExtra(ActivityConst.DIALOG, dialog);
                        intent.putExtra(ActivityConst.PERSON, person);
                        intent.putExtra(ActivityConst.WORK, (positionChild == 0 ? mainData.get(selectedWork) : childData.get(selectedWork)));
                        startActivityForResult(intent, FragmentConst.UPDATE_WORK_LIST);
                    }
                } else {
                    Intent intent = new Intent(getActivity(), CreateWorkActivity.class);
                    intent.putExtra(ActivityConst.PERSON, person);
                    intent.putExtra(ActivityConst.WORK, (positionChild == 0 ? mainData.get(selectedWork) : childData.get(selectedWork)));
                    startActivityForResult(intent, FragmentConst.UPDATE_WORK_LIST);
                }
                if (positionChild == 0) {
                    mainProgressBar.setVisibility(View.GONE);
                } else {
                    childProgressBar.setVisibility(View.GONE);
                }
                super.onPostExecute(result);
            }
        }.execute();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode != Activity.RESULT_CANCELED) {
            if (requestCode == FragmentConst.UPDATE_WORK_LIST) {
                // обновляем список
                String type = data.getStringExtra(ActivityConst.UPDATE_WORK_LIST);
                if (type != null && type.equals(ActivityConst.UPDATE_WORK_LIST)) {
                    if (positionChild == 0) {
                        getWorkList(currentUrl, true, true, false);
                    } else {
                        getChildWorkList(childUrl, true);
                    }
                }
                // обновляем данные по работе
                WorkItem work = (WorkItem) data.getSerializableExtra(ActivityConst.WORK);
                if (work != null) {
                    for (WorkItem generalWork : mainData) {
                        // если мы нашли нужную нам работу
                        if (generalWork.getActionID().equals(work.getActionID())) {
                            generalWork.setWork_state_label(work.getWork_state_label());
                            generalWork.setWork_state_icon(work.getWork_state_icon());
                            generalWork.setPercent(work.getPercent());
                            // обновляем данные по работе в базе
                            if (Utils.checkSyncEnables(mSettings)) {
                                new WorksTable(getActivity()).updateWork(generalWork);
                            }
                            break;
                        }
                    }
                    mainAdapter.notifyDataSetChanged();
                }
            }
        }
    }

    /**
     * Метод срабатывает при натажии на кнопку "Back"
     */
    private void backPressed() {
        if (positionChild == 1) {
            headChildData.remove(positionChild - 1);
            positionChild = 0;
            childDataSlidingMenu.toggle();
        } else if (positionChild >= 2) {
            headChildData.remove(positionChild - 1);
            childProgressBar.setVisibility(View.VISIBLE);
            getChildWorkList(urlToChildData.get(positionChild - 2), true);
            positionChild--;
        } else {
            SharedPreferences.Editor editor = mSettings.edit();
            editor.putBoolean(Const.BACK_PRESSED_SYNC, false);
            editor.apply();
            getActivity().finish();
        }
    }

    /**
     * Метод загружает сохраненные работы из базы
     */
    public void getOfflineWorks() {
        mainData = new ArrayList<>();
        WorksTable worksTable = new WorksTable(getActivity());
        List<WorkItem> works = worksTable.getWorks();
        // отображаем только нужные нам работы
        for (WorkItem work : works) {
            if (fType != null && fID != null) {
                if (work.getFilterType() != null && work.getFilterID() != null) {
                    if (work.getFilterType().equals(fType) && work.getFilterID().equals(fID)) {
                        mainData.add(work);
                    }
                }
            } else if (fType != null && oID != null) {
                if (work.getFilterType() != null && work.getObjectID() != null) {
                    if (work.getFilterType().equals(fType) && work.getObjectID().equals(oID)) {
                        mainData.add(work);
                    }
                }
            } else {
                if (fID == null && oID == null) {
                    if (work.getFilterType().equals(fType) && work.getFilterID() == null && work.getObjectID() == null) {
                        mainData.add(work);
                    }
                }
            }
        }
        refreshMainList();
    }

    /**
     * Обновление списка работ
     */
    private void refreshMainList() {
        mainAdapter.notifyDataSetChanged();
        mainRefreshLayout.setRefreshing(false);
    }

    /**
     * Обновление списка дочерних работ
     */
    private void refreshChildList() {
        childAdapter.notifyDataSetChanged();
        childRefreshLayout.setRefreshing(false);
    }

    @Override
    public void onDestroy() {
        getActivity().unregisterReceiver(filtersBroadcastReceiver);
        super.onDestroy();
    }
}
