using esoft.Class;
using esoft.Entities;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
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>
    /// Логика взаимодействия для AddExecutorPage.xaml
    /// </summary>
    public partial class AddExecutorPage : Page
    {
        ActualContext actualContext = new ActualContext();   // Контекст таблиц
        List<TaskFill> taskContext = new List<TaskFill>();
        private ExecuterFill selectedExecutor;
        private bool isEditing = false;

        public AddExecutorPage(ExecuterFill executor)
        {
            InitializeComponent();
            LViewTask.ItemsSource = Class.TaskFill.TaskFills();
            selectedExecutor = executor;
            if (selectedExecutor.FioUser != null)
            {
                isEditing = true;
            }
            FillForm();
            LoadAndSortTasks();
            LoadUserRule(selectedExecutor);
        }

        private void FillForm()
        {
            cbGrade.ItemsSource = GetGrade.FillGrade();

            if (isEditing && selectedExecutor != null)
            {
                TBoxSurname.Text = selectedExecutor.MiddleName;
                TBoxName.Text = selectedExecutor.Name;
                TBoxLastName.Text = selectedExecutor.LastName;
                if (cbGrade.ItemsSource is IEnumerable<GetGrade> gradeList)
                {
                    cbGrade.SelectedItem = gradeList.FirstOrDefault(executor => executor.Name == selectedExecutor.Grade);
                }
            }
        }

        private void LoadUserRule(ExecuterFill selectedExecutor)
        {

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

            var currentUser = GetCurrent.CurrentUser;
            var isManager = actualContext.Manager.Any(manager => manager.ID == currentUser.ID);
            
            if (isManager)
            {
                TBoxSurname.IsReadOnly = false;
                TBoxName.IsReadOnly = false;
                TBoxLastName.IsReadOnly = false;
                
                cbGrade.IsEnabled = true;
            }
            else // Если текущий пользователь - исполнитель
            {
                TBoxSurname.IsReadOnly = true;
                TBoxName.IsReadOnly = true;
                TBoxLastName.IsReadOnly = true;

                cbGrade.IsEnabled = false;
            }

            // Фильтрация задач по выбранному исполнителю
            if (selectedExecutor != null)
            {
                var executingTasks = taskContext.Where(task => task.FioUser == selectedExecutor.FioUser && task.Status == "исполняется").ToList();
                if (executingTasks.Any())
                {
                    LViewTask.ItemsSource = executingTasks;
                }
                else
                {
                    LViewTask.ItemsSource = taskContext.Where(task => task.FioUser == selectedExecutor.FioUser).ToList();
                }
            }
            else
            {
                LViewTask.ItemsSource = taskContext; // Если исполнитель не выбран, отображаем все задачи
            }
        }

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

        private void BtnSaveExecutor_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string firstName = TBoxName.Text;
                string middleName = TBoxSurname.Text;
                string lastName = TBoxLastName.Text;
                string login = TBoxLogin.Text;
                string password = TBoxPassword.Text;

                if (string.IsNullOrWhiteSpace(firstName) || string.IsNullOrWhiteSpace(lastName) || string.IsNullOrWhiteSpace(login) || string.IsNullOrWhiteSpace(password))
                {
                    MessageBox.Show("Пожалуйста, заполните все обязательные поля!", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                var context = esoftEntities.GetContext();

                if (isEditing && selectedExecutor != null)
                {
                    var existingUser = context.User.FirstOrDefault(u => u.ID == selectedExecutor.ID);

                    if (existingUser != null)
                    {
                        existingUser.FirstName = firstName;
                        existingUser.MiddleName = middleName;
                        existingUser.LastName = lastName;
                        existingUser.Login = login;
                        existingUser.Password = password;

                        context.SaveChanges();

                        MessageBoxResult result = MessageBox.Show("Информация о пользователе успешно обновлена!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                        if (result == MessageBoxResult.OK)
                        {
                            if (isEditing)
                            {
                                // Получите соответствующего исполнителя для редактируемого пользователя
                                var executor = context.Executor.FirstOrDefault(exec => exec.ID == existingUser.ID);

                                if (executor != null)
                                {
                                    executor.Grade = cbGrade.Text;   // Обновите Grade исполнителя
                                    context.SaveChanges();          // Сохраните изменения в исполнителе
                                }
                            }

                            NavigationService.GoBack();
                        }
                    }
                }
                else // Добавление нового пользователя
                {
                    User newUser = new User
                    {
                        FirstName = firstName,
                        MiddleName = middleName,
                        LastName = lastName,
                        Login = login,
                        Password = password
                    };

                    context.User.Add(newUser);
                    context.SaveChanges();

                    MessageBoxResult result = MessageBox.Show("Пользователь успешно добавлен!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                    if (result == MessageBoxResult.OK)
                    {
                        CreateExecutorForNewUser(newUser, cbGrade.Text);
                        NavigationService.GoBack();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при обработке пользователя: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        
        // Функция для получения ID менеджера
        private int GetManagerID()
        {
            // Получение ID менеджера текущего пользователя
            var currentUser = GetCurrent.CurrentUser;

            // Предполагается, что ManagerID указывает на ID менеджера
            return currentUser?.ID ?? 0;
        }

        public void CreateExecutorForNewUser(User newUser, string grade)
        {
            try
            {
                var context = esoftEntities.GetContext();
                 
                esoft.Entities.Executor newExecutor = new esoft.Entities.Executor
                {
                    ManagerID = GetManagerID(),     // Получаем ID менеджера текущего пользователя
                    Grade = grade,                 //
                    ID = newUser.ID               // Используем ID только что добавленного пользователя
                };
                
                context.Executor.Add(newExecutor);
                context.SaveChanges();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при создании исполнителя: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        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 FilterExecuter(object sender, RoutedEventArgs e)
        {
            FilterTasks();
        }

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

            List<string> selectedStatuses = new List<string>();

            if (ckbPlan.IsChecked == true)
            {
                selectedStatuses.Add("запланирована");
            }
            if (ckbExecuted.IsChecked == true)
            {
                selectedStatuses.Add("исполняется");
            }
            if (ckbDone.IsChecked == true)
            {
                selectedStatuses.Add("выполнена");
            }
            if (ckbСancelled.IsChecked == true)
            {
                selectedStatuses.Add("отменена");
            }

            if (selectedExecutor != null || selectedStatuses.Any())
            {
                // Фильтрация задач по выбранному исполнителю и статусам
                var filteredTasks = taskContext.Where(task =>
                    (selectedExecutor == null || task.FioUser == selectedExecutor.FioUser) &&
                    (selectedStatuses.Count == 0 || selectedStatuses.Contains(task.Status))).ToList();

                LViewTask.ItemsSource = filteredTasks;
            }
            else
            {
                // Если исполнитель не выбран и не выбрано ни одного статуса, показать все задачи
                LViewTask.ItemsSource = taskContext;
            }
        }
    }
}
