using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using NPOI.HSSF.Util;
using Syncfusion.Windows.Tools.Controls;

namespace PRSDesktop
{
    public class JobSelectorData
    {
        public String Filter { get; set; }
        
        // FullGuid => All Jobs
        public Guid[] Jobs { get; set; }
        
        public JobSelectorData( String filter, Guid[] jobs)
        {
            Filter = filter;
            Jobs = jobs;
        }

        public JobSelectorData() : this("", new[] { CoreUtils.FullGuid })
        {
        }
    }

    public class JobSelectorSettings
    {
        public JobSelectorSettings()
        {
        }
    }
    
    public class JobSelectorSettingsChangedArgs : EventArgs
    {
        public JobSelectorSettings Settings { get; private set; }

        public JobSelectorSettingsChangedArgs(JobSelectorSettings settings)
        {
            Settings = settings;
        }
    }
    
    public delegate void JobSelectorSettingsChanged(object sender, JobSelectorSettingsChangedArgs args);
    
    public class JobSelectorSelectionChangedArgs : EventArgs
    {
        public JobSelectorData Selection { get; private set; }

        public JobSelectorSelectionChangedArgs(JobSelectorData selection)
        {
            Selection = selection;
        }
    }

    public delegate void JobSelectorSelectionChanged(object sender, JobSelectorSelectionChangedArgs args);


    public partial class JobSelector : UserControl
    {

        private enum Suppress
        {
            This
        }

        private class ListEntry
        {
            public Guid Key { get; set; }
            public String Value { get; set; }
        }

        public JobSelectorSettings Settings { get; set; }

        public event JobSelectorSettingsChanged SettingsChanged;
        public event JobSelectorSelectionChanged SelectionChanged;
        
        private void UpdateSettings()
        {
            bool changed = false;

            if (changed && (!EventSuppressor.IsSet(Suppress.This)))
                SettingsChanged?.Invoke(this, new JobSelectorSettingsChangedArgs(Settings));
        }
        
        private CoreTable _jobs;
        private DynamicGridFilters _filters;
        
        public T[] GetJobData<T>(Func<CoreRow, T> transform)
        {
            List<T> result = new List<T>();
            var seljobs = GetSelectedJobs();
            var rows = _jobs.Rows.Where(r => seljobs.Contains(CoreUtils.FullGuid) || seljobs.Contains(r.Get<Job, Guid>(c => c.ID)));
            foreach (var row in rows)
                result.Add(transform.Invoke(row));
            return result.ToArray();
        }

        public JobSelector()
        {
            Settings = new JobSelectorSettings();
            using (new EventSuppressor(Suppress.This))
                InitializeComponent();
        }
        
        public void Setup()
        {
            using (new EventSuppressor(Suppress.This))
            {
                _filters = new GlobalConfiguration<DynamicGridFilters>("Job").Load();
                JobFilter.ItemsSource = _filters;
            }
        }

        private String GetSelectedJobFilter()
        {
            return (JobFilter.SelectedValue is DynamicGridFilter filter) ? filter.Name : "";
        }

        private Guid[] GetSelectedJobs()
        {
            return SelectedJobs.SelectedItems
                .OfType<JobModel>()
                .Select(x => x.ID)
                .ToArray();
        }

        public JobSelectorData Selection
        {
            get => GetSelectionData();
            set => SelectJobs(value);
        }
        
        private JobSelectorData GetSelectionData()
        {
            return new JobSelectorData(
                GetSelectedJobFilter(),
                GetSelectedJobs()
            );
        }
        
        private void SelectJobs(JobSelectorData selection)
        {
            using (new EventSuppressor(Suppress.This))
            {
                var selectedfilter = _filters.FirstOrDefault(x => String.Equals(x.Name, selection.Filter));
                JobFilter.SelectedValue = selectedfilter;
                LoadJobs(selectedfilter?.Filter, selection.Jobs);
            }            
        }

        private void LoadJobs(string? filter, Guid[]? jobs)
        {
            Filter<Job>? jobfilter = String.IsNullOrWhiteSpace(filter)
                ? new Filter<Job>(x => x.ID).IsEqualTo(Guid.Empty)
                : Serialization.Deserialize<Filter<Job>>(filter);
            _jobs = new Client<Job>().Query(
                jobfilter, 
                JobModel.Columns,
                new SortOrder<Job>(x => x.JobNumber)
            );
            var models = _jobs.Rows.Select(r => new JobModel(r)).ToArray();
            using (new EventSuppressor(Suppress.This))
            {
                SelectedJobs.ItemsSource = new ObservableCollection<JobModel>(models);
                SelectedJobs.SelectedItems.Clear();
                var sels = models.Where(x => jobs == null || !jobs.Any() || jobs.Contains(CoreUtils.FullGuid) || jobs.Contains(x.ID));
                foreach (var sel in sels)
                    SelectedJobs.SelectedItems.Add(sel);
                SelectAll.Content = SelectedJobs.SelectedItems.Count == SelectedJobs.Items.Count ? "None" : "All";
                UpdateSettings();
                SelectionChanged?.Invoke(this, new JobSelectorSelectionChangedArgs(GetSelectionData()));
            }
        }
        
        private void JobFilter_Changed(object sender, SelectionChangedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            using (new EventSuppressor(Suppress.This))
            {
                var sel = GetSelectionData();
                var selectedfilter = _filters.FirstOrDefault(x => String.Equals(x.Name, sel.Filter));
                LoadJobs(selectedfilter?.Filter, sel?.Jobs);
            }
        }

        private void SelectedJobs_OnItemChecked(object? sender, ItemCheckedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            using (new EventSuppressor(Suppress.This))
            {
                SelectAll.Content = SelectedJobs.SelectedItems.Count == SelectedJobs.Items.Count ? "None" : "All";
                UpdateSettings();
                SelectionChanged?.Invoke(this, new JobSelectorSelectionChangedArgs(GetSelectionData()));
            }
        }

        private void JobFilterSelector_OnClick(object sender, RoutedEventArgs e)
        {
            var selfilter = (JobFilter.SelectedValue as DynamicGridFilter)?.Name ?? "";
            var window = new DynamicGridFilterEditor(_filters, typeof(Job));
            if (window.ShowDialog() == true)
            {
                new GlobalConfiguration<DynamicGridFilters>("Job").Save(_filters);
                using (new EventSuppressor(Suppress.This))
                    JobFilter.SelectedValue = _filters.FirstOrDefault(x => String.Equals(x.Name, selfilter));
            }
        }

        private void SelectAll_OnClick(object sender, RoutedEventArgs e)
        {
            using (new EventSuppressor(Suppress.This))
            {
                var selected = SelectedJobs.SelectedItems
                    .OfType<JobModel>()
                    .Select(x=>x.ID)
                    .ToArray();
                
                var items = SelectedJobs.Items
                    .OfType<JobModel>()
                    .ToArray();

                if (items.Length == selected.Length)
                {
                    SelectedJobs.SelectedItems.Clear();
                    SelectAll.Content = "All";
                }
                else
                {
                    var unselected = items.Where(p => !selected.Contains(p.ID));
                    foreach (var item in unselected)
                        SelectedJobs.SelectedItems.Add(item);
                    SelectAll.Content = "None";
                }
                UpdateSettings();
                SelectionChanged?.Invoke(this, new JobSelectorSelectionChangedArgs(GetSelectionData()));
            }           
        }
    }
}