using System;
using System.Collections.Generic;
using System.Linq;
using InABox.Core;
using InABox.Mobile;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using Xamarin.Forms.Xaml.Internals;

namespace PRS.Mobile
{

    public class SelectionViewConfigureArgs : EventArgs
    {
        public MobileGridColumns Columns { get; private set; }
        
        public MobileButtonStripItems Filters { get; set; }
        
        public SelectionViewConfigureArgs(MobileGridColumns columns, MobileButtonStripItems filters)
        {
            Filters = filters;
            Columns = columns;
        }
    }

    public delegate void SelectionViewConfigureEvent(object sender, SelectionViewConfigureArgs args);

    public class SelectionViewRefreshArgs : EventArgs
    {
        public bool Force { get; private set; }
        
        public string Filter { get; private set; }
        
        public DateTime LastUpdated { get; set; }

        public SelectionViewRefreshArgs(bool force, string filter)
        {
            Force = force;
            Filter = filter;
        }
    }
    
    public delegate object SelectionViewRefreshEvent(object sender, SelectionViewRefreshArgs args);
    
    public class SelectionViewSelectionChangedArgs : EventArgs
    {
        public object[] SelectedItems { get; private set; }

        public SelectionViewSelectionChangedArgs(object[] selecteditems)
        {
            SelectedItems = selecteditems;
        }
    }
    
    public delegate void SelectionViewSelectionChangedEvent(object sender, SelectionViewSelectionChangedArgs args);
    
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class SelectionView
    {
        
        public static View Execute<T>(Action<MobileGridColumns> columns, Func<SelectionViewRefreshArgs, object> refresh, Action<T[]> selected, SelectionPageMode mode = SelectionPageMode.Immediate)
        {
            SelectionView selection = new SelectionView
            {
                VerticalOptions = LayoutOptions.Fill,
                HorizontalOptions = LayoutOptions.Fill
            };
            selection.Configure += (sender, args) =>
            {
                args.Columns
                    .BeginUpdate()
                    .Clear();
                columns(args.Columns);
                args.Columns.EndUpdate();
            };
            selection.Refresh += (sender, args) =>
            {
                var result = refresh(args);
                if (result is ICoreRepository repository)
                    selection.Items.LastUpdated = repository.LastUpdated;
                return result;
            };
            selection.SelectionChanged += (sender, args) =>
            {
                selected(args.SelectedItems.OfType<T>().ToArray());
            };
            selection.Mode = mode;
            selection.Load();
            return selection;
        }
        
        private SelectionPageMode _mode = SelectionPageMode.Immediate;

        public SelectionPageMode Mode
        {
            get => _mode;
            set
            {
                _mode = value;
                Items.SelectionMode = value == SelectionPageMode.MultiSelect
                    ? MobileGridSelectionMode.Multiple
                    : MobileGridSelectionMode.Single;
            }
        }

        public object[] SelectedItems => Items.SelectedItems;
        public event SelectionViewConfigureEvent Configure;
        public event SelectionViewRefreshEvent Refresh;
        public event SelectionViewSelectionChangedEvent SelectionChanged;

        public bool CanSearch
        {
            get => Items.CanSearch;
            set => Items.CanSearch = value;
        }

        public bool PullToRefresh
        {
            get => Items.PullToRefresh;
            set
            {
                Items.ShowRecordCount = value;
                Items.PullToRefresh = value;
            }
        }
        
        public SelectionView()
        {
            Mode = SelectionPageMode.Immediate;
            InitializeComponent();
            PullToRefresh = true;
            
        }

        public void Load()
        {
            
            Configure?.Invoke(this, new SelectionViewConfigureArgs(Items.Columns, Filters.Items));

            Filters.IsVisible = Filters.Items.Count > 1;
            
            Items.SelectionMode = Mode == SelectionPageMode.MultiSelect
                ? MobileGridSelectionMode.Multiple
                : MobileGridSelectionMode.Single;
            
            var args = new SelectionViewRefreshArgs(false, Filters.SelectedItem?.Text ?? string.Empty);
            Items.ItemsSource = Refresh?.Invoke(this, args);
            Items.LastUpdated = PullToRefresh ? args.LastUpdated : DateTime.MinValue;
        }
        
        public void AddButton(String text, Action clicked)
        {
            MobileButton button = new MobileButton() { Text = text };
            button.Clicked += (sender, args) => clicked?.Invoke();
            button.HeightRequest = 40;
            button.SetValue(Grid.ColumnProperty, Buttons.Children.Count);
            Buttons.Children.Add(button);
            Buttons.IsVisible = true;
        }
        
        private void Items_OnRefreshRequested(object sender, MobileGridRefreshRequestArgs args)
        {
            DoRefresh();
        }
        
        private void Filters_OnSelectionChanged(object sender, EventArgs e)
        {
            DoRefresh();
        }

        private void DoRefresh()
        {
            var args = new SelectionViewRefreshArgs(true, Filters.SelectedItem?.Text ?? string.Empty);
            var items = Refresh?.Invoke(this, args);
            Items.ItemsSource = null;
            Items.ItemsSource = items;
            Items.LastUpdated = args.LastUpdated;        
        }

        private void Items_OnSelectionChanged(object sender, MobileGridSelectionArgs args)
        {
            if (Mode == SelectionPageMode.Immediate)
                SelectionChanged?.Invoke(this, new SelectionViewSelectionChangedArgs(Items.SelectedItems));
        }
        
    }
}