using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using Syncfusion.UI.Xaml.Kanban;
using Syncfusion.Windows.Tools.Controls;

namespace PRSDesktop
{
    public class UserTasksHeaderImageConverter : IValueConverter
    {
        public static Dictionary<Guid, byte[]> Images { get; set; }
        public static Dictionary<Guid, Guid> Employees { get; set; }

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var anonymous = Resources.anonymous.AsBitmapImage();

            if (Images == null)
                return anonymous;

            if (Employees == null)
                return anonymous;

            var dataContext = value as ColumnTag;
            if (dataContext == null)
                return anonymous;

            var getter = dataContext.GetType().GetProperty("Column", BindingFlags.NonPublic | BindingFlags.Instance);
            if (getter == null)
                return anonymous;

            var column = (KanbanColumn)getter.GetValue(dataContext);
            if (column == null)
                return anonymous;

            if (!Guid.TryParse(column.Categories, out var empid))
                return anonymous;

            if (!Employees.TryGetValue(empid, out var imageid))
                return anonymous;

            if (!Images.TryGetValue(imageid, out var data))
                return anonymous;

            return ImageUtils.LoadImage(data);
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    public class UserTasksHeaderTimeConverter : IValueConverter
    {
        public static IEnumerable<TaskModel> Kanbans { get; set; }

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (Kanbans == null)
                return "0:00";

            var dataContext = value as ColumnTag;
            if (dataContext == null)
                return "0:00";

            var getter = dataContext.GetType().GetProperty("Column", BindingFlags.NonPublic | BindingFlags.Instance);
            if (getter == null)
                return "0:00";

            var column = (KanbanColumn)getter.GetValue(dataContext);
            if (column == null)
                return "0:00";

            double result = 0.0F;
            foreach (var kanban in Kanbans.Where(x => Equals(x.Category, column.Categories)))
                result += kanban.EstimatedTime.TotalHours;
            return string.Format("{0:F2}", result);
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

//public class TaskHeaderWidthConverter : IValueConverter
//{

//    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
//    {
//        var dataContext = (value as ColumnTag);
//        if (dataContext == null)
//            return 150;

//        PropertyInfo getter = dataContext.GetType().GetProperty("Column", BindingFlags.NonPublic | BindingFlags.Instance);
//        if (getter == null)
//            return 150;

//        KanbanColumn column = (KanbanColumn)getter.GetValue(dataContext);
//        if (column == null)
//            return 150;

//        return Math.Max(150, column.Width) - 20 ;

//    }

//    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
//    {
//        throw new NotImplementedException();
//    }
//}

    /// <summary>
    ///     Interaction logic for TaskListPanel.xaml
    /// </summary>
    public partial class TasksByUserControl : UserControl, ITaskControl
    {
        private List<TaskModel> _models = new();

        public TasksByUserControl()
        {
            InitializeComponent();
        }
        
        public bool IsReady { get; set; }

        private void TaskType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
        }

        private void IncludeLocked_Checked(object sender, RoutedEventArgs e)
        {
            if (!IsReady)
                return;

            SaveSettings();
            Refresh(true);
        }

        private void IncludeManaged_Checked(object sender, RoutedEventArgs e)
        {
            if (!IsReady)
                return;

            SaveSettings();
            Refresh(true);
        }
        private void IncludeObserved_Checked(object sender, RoutedEventArgs e)
        {
            if (!IsReady)
                return;

            SaveSettings();
            Refresh(true);
        }

        private void IncludeCompleted_Checked(object sender, RoutedEventArgs e)
        {
            if (!IsReady)
                return;

            SaveSettings();
            Refresh(true);
        }

        private void Search_KeyUp(object sender, KeyEventArgs e)
        {
            FilterKanbans();
        }

        private void Export_Click(object sender, RoutedEventArgs e)
        {
        }

        private void Kanban_CardDragStart(object sender, KanbanDragStartEventArgs e)
        {
            var models = SelectedModels(e.SelectedCard.Content as TaskModel).ToList();
            if (models.Any(x => x.Locked || x.EmployeeID != Guid.Parse(x.Category.ToString())) || !Host.CanChangeTasks(models))
                e.IsCancel = true;
        }


        private void Kanban_CardDragEnd(object sender, KanbanDragEndEventArgs e)
        {
            using (new WaitCursor())
            {
                var target = e.TargetColumn.Categories;
                var targetCategory = e.TargetKey;
                var models = SelectedModels(e.SelectedCard.Content as TaskModel).Where(x => !Equals(x.Category, target)).ToList();
                if (!models.Any())
                    return;
                var kanbans = Host.LoadKanbans(models, new Columns<Kanban>(x => x.ID, x => x.EmployeeLink.ID, x => x.Private, x => x.Number));
                var subscribers = new ClientKanbanSubscriberSet(kanbans.Select(x => x.ID));
                var targetID = Guid.Parse(target);

                var updated = new List<Kanban>();
                foreach (var kanban in kanbans)
                {
                    if (!kanban.Private)
                    {
                        kanban.EmployeeLink.ID = targetID;
                        subscribers.EnsureAssignee(kanban.ID, kanban.EmployeeLink.ID);
                        updated.Add(kanban);
                    }
                    else
                    {
                        MessageBox.Show($"Cannot change assignee for task {kanban.Number} because it is private.");
                        models.RemoveAll(x => x.ID == kanban.ID.ToString());
                    }
                }

                new Client<Kanban>().Save(updated, string.Format("Task Employee Updated to {0}", target), (o, err) => { });
                subscribers.Save(false);
                foreach (var model in models)
                {
                    model.Checked = false;
                    model.Category = target;
                    model.EmployeeID = targetID;
                }

                FilterKanbans();
            }
        }

        private void Kanban_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            e.Handled = true;
        }
    }
}