using esoft.Class;
using esoft.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace esoft.Pages
{
    /// <summary>
    /// Логика взаимодействия для TaskLists.xaml
    /// </summary>
    public partial class TaskLists : Page
    {
        ActualContext actualContext = new ActualContext();
        TaskFill tasks = new TaskFill();
        List<TaskFill> taskContext = new List<TaskFill>();

        public TaskLists()
        {
            InitializeComponent();
            LViewTask.ItemsSource = Class.TaskFill.TaskFills();
            FillForm();
            LoadAndSortTasks();
            LoadUserRule();
        }

        private void LoadUserRule()
        {
            taskContext = Class.TaskFill.TaskFills();

            var currentUser = GetCurrent.CurrentUser;
            var isManager = actualContext.Manager.Any(manager => manager.ID == currentUser.ID);
 
            if (isManager)
            {
                // Логика сортировки для менеджеров
                var subordinateExecutors = actualContext.Executor.Where(executor => executor.ManagerID == currentUser.ID).Select(executor => executor.ID).ToList();

                taskContext = taskContext
                    .Where(task => subordinateExecutors.Contains(task.ExecutorID))
                    .OrderByDescending(task => task.CreateDateTime)
                    .ToList();

                cbExecutor.Visibility = Visibility.Visible;
                cbManager.Visibility = Visibility.Visible;
                btnClearFilter.Visibility = Visibility.Visible;
                Search.Visibility = Visibility.Visible;
                BtnDeleteTask.Visibility = Visibility.Visible;
                BtnAddTask.Visibility = Visibility.Visible;
                BtnUpdate.Visibility = Visibility.Visible;
            }
            else
            {
                // Логика сортировки для исполнителей
                taskContext = taskContext
                    .Where(task => task.ExecutorID == currentUser.ID)
                    .OrderByDescending(task => task.CreateDateTime)
                    .ToList();

                cbExecutor.Visibility = Visibility.Hidden;
                cbManager.Visibility = Visibility.Hidden;
                btnClearFilter.Visibility = Visibility.Hidden;
                Search.Visibility = Visibility.Hidden;
                BtnDeleteTask.Visibility = Visibility.Hidden;
                BtnAddTask.Visibility = Visibility.Hidden;
                BtnUpdate.Visibility = Visibility.Hidden;
            }

            LViewTask.ItemsSource = taskContext;
        }

        private void LoadAndSortTasks()
        {
            // Сортируем задачи по убыванию даты создания
            taskContext = Class.TaskFill.TaskFills();
            taskContext = taskContext.OrderByDescending(task => task.CreateDateTime).ToList();
            LViewTask.ItemsSource = taskContext;
        }

        private void FillForm()
        {
            cbStatus.ItemsSource = StatusTask.FillStatus();

            List<User> usersExecutor = actualContext.Users.Where(user => actualContext.Executor.Any(ex => ex.ID == user.ID)).ToList(); // Получение списка исполнителей
            cbExecutor.ItemsSource = UserInFIO.GroupUser(usersExecutor);

            List<User> usersManager = actualContext.Users.Where(user => actualContext.Manager.Any(manager => manager.ID == user.ID)).ToList(); // Получение списка менеджеров
            cbManager.ItemsSource = UserInFIO.GroupUser(usersManager);
        }

        private void BtnAddTask_Click(object sender, RoutedEventArgs e)
        {
            TaskFill newTask = new TaskFill();
            AddEditServicePage editPage = new AddEditServicePage(newTask);
            NavigationService.Navigate(editPage);
        }

        private void BtnDeleteTask_Click(object sender, RoutedEventArgs e)
        {
            taskContext = Class.TaskFill.TaskFills();

            var currentUser = GetCurrent.CurrentUser;
            var isManager = actualContext.Manager.Any(manager => manager.ID == currentUser.ID);


            if (LViewTask.SelectedItem is TaskFill selectedTask)
            {
                // Проверка роли пользователя
                if (isManager)
                {
                    var ShortName = UserInFIO.SoloUser(currentUser);
                    if (selectedTask.FioManager != ShortName)
                    {
                        MessageBox.Show("Извините, но вы не можете удалить задачу, к которой вы не прикреплены в качестве менеджера!", "Внимание", MessageBoxButton.OK, MessageBoxImage.Information);
                    }
                    else
                    {
                        try
                        {
                            MessageBoxResult result = MessageBox.Show("Вы уверены, что хотите удалить выбранную задачу?",
                                                                          "Подтверждение удаления",
                                                                          MessageBoxButton.YesNo,
                                                                          MessageBoxImage.Question);
                            if (result == MessageBoxResult.Yes)
                            {
                                var context = esoftEntities.GetContext();
                                var taskToDelete = context.Task.FirstOrDefault(task => task.ID == selectedTask.ID);
                                
                                if (taskToDelete != null)
                                {
                                    taskToDelete.IsDeleted = true;
                                    context.SaveChanges();
                                    LViewTask.ItemsSource = Class.TaskFill.TaskFills();

                                    taskContext = Class.TaskFill.TaskFills().Where(task => !task.IsDeleted).ToList();
                                    LViewTask.ItemsSource = taskContext;
                                    LoadAndSortTasks();
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show($"Ошибка при удалении задачи: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                        }
                    }
                }
            }
            else
            {
                MessageBox.Show("Выберите задачу для удаления.", "Внимание", MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private void BtnUpdate_Click(object sender, RoutedEventArgs e)
        {
            LViewTask.ItemsSource = Class.TaskFill.TaskFills();
            LoadAndSortTasks();
            LoadUserRule();
        }

        private void FilterTasks()
        {
            // Получение актуальных данных задач из базы или контекста приложения
            taskContext = Class.TaskFill.TaskFills();

            if (cbStatus.SelectedItem != null)
            {
                var currentUser = GetCurrent.CurrentUser;
                var isManager = actualContext.Manager.Any(manager => manager.ID == currentUser.ID);
                string selectedStatus = ((StatusTask)cbStatus.SelectedItem).Name;

                if (isManager)
                {
                    // Получаем ID подчиненных исполнителей для данного менеджера
                    var subordinateExecutors = actualContext.Executor.Where(executor => executor.ManagerID == currentUser.ID).Select(executor => executor.ID).ToList();

                    // Фильтрация задач подчиненных исполнителей менеджера по статусу
                    taskContext = taskContext.Where(task => subordinateExecutors.Contains(task.ExecutorID) && task.Status == selectedStatus).ToList();
                }
                else // Если текущий пользователь - исполнитель
                {
                    // Фильтрация задач текущего исполнителя по статусу
                    taskContext = taskContext.Where(task => task.ExecutorID == currentUser.ID && task.Status == selectedStatus).ToList();
                }
            }

            if (cbExecutor.SelectedItem != null)
            {
                string selectedExecutor = cbExecutor.SelectedItem.ToString();
                taskContext = taskContext.Where(task => task.FioUser == selectedExecutor).ToList();
            }

            if (cbManager.SelectedItem != null)
            {
                string selectedManager = cbManager.SelectedItem.ToString();
                taskContext = taskContext.Where(task => task.FioManager == selectedManager).ToList();
            }

            if (!string.IsNullOrEmpty(Search.Text))
            {
                // Преобразование текста поиска к нижнему регистру (для удобства сравнения)
                string searchText = Search.Text.ToLower();

                // Фильтрация задач по содержанию текста в полях Title
                taskContext = taskContext.Where(task => task.Title.ToLower().Contains(searchText)).ToList();
            }

            LViewTask.ItemsSource = taskContext;
        }

        private void cbStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            FilterTasks();
        }

        private void cbExecutor_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            FilterTasks();
        }

        private void cbManager_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            FilterTasks();
        }

        private void Search_TextChanged(object sender, TextChangedEventArgs e)
        {
            FilterTasks();
        }

        private void btnClearFilter_Click(object sender, RoutedEventArgs e)
        {
            // Очистка выбранных значений комбо боксов
            cbStatus.SelectedItem = null;
            cbExecutor.SelectedItem = null;
            cbManager.SelectedItem = null;
            Search.Text = string.Empty;

            // Очистка фильтров и отображение всех задач без фильтрации
            LViewTask.ItemsSource = Class.TaskFill.TaskFills();
            LoadAndSortTasks();
            LoadUserRule();
        }

        private void BtnExecutorList_Click(object sender, RoutedEventArgs e)
        {
            // Перенаправление пользователя на страницу с задачами
            NavigationService.Navigate(new Pages.ExecutorsListPage());
        }

        private void LViewTask_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (LViewTask.SelectedItem is TaskFill selectedTask)
            {
                // Проверяем, не является ли статус задачи "выполнена" или "отменена"
                if (selectedTask.Status != "выполнена" && selectedTask.Status != "отменена")
                {
                    AddEditServicePage editPage = new AddEditServicePage(selectedTask); // Передаем выбранную задачу в окно редактирования
                    NavigationService.Navigate(editPage); // Открываем окно редактирования
                }
                else
                {
                    MessageBox.Show("Нельзя редактировать задачи со статусом '" + selectedTask.Status + "'", "Внимание", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }
            else
            {
                MessageBox.Show("Выберите задачу для редактирования.", "Внимание", MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private void LViewTask_Loaded(object sender, RoutedEventArgs e)
        {
            taskContext = Class.TaskFill.TaskFills().Where(task => !task.IsDeleted).ToList();
            LViewTask.ItemsSource = taskContext;
            FillForm();
            LoadAndSortTasks();
            LoadUserRule();
        }
    }
}
