using System;
using System.Linq;
using System.Windows.Input;
using Syncfusion.SfDataGrid.XForms;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;

namespace comal.timesheets
{

    public enum MobileGridSelectionMode
    {
        None,
        Single,
        Multiple
    }

    public class PullToRefreshCommand : ICommand
    {

        private MobileGrid _grid;
        
        public bool CanExecute(object parameter)
        {
            return _grid.PullToRefresh;
        }

        public void Execute(object parameter)
        {
            _grid.RequestRefresh();
        }

        public event EventHandler CanExecuteChanged;

        public PullToRefreshCommand(MobileGrid grid)
        {
            _grid = grid;
        }
    }

    public class MobileGridSelectionArgs : EventArgs
    {
        public object[] Selection { get; private set; }

        public MobileGridSelectionArgs(object[] selection)
        {
            Selection = selection;
        }
    }
        
    public delegate void MobileGridSelectionChanged(object sender, MobileGridSelectionArgs args);
    
    public class MobileGridRefreshRequestArgs : EventArgs { }
    
    public delegate void MobileGridRefreshRequested(object sender, MobileGridRefreshRequestArgs args);

    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class MobileGrid : ContentView
    {

        public MobileGridColumns Columns { get; private set; }
        
        public object ItemsSource
        {
            get => Grid.ItemsSource;
            set => Dispatcher.BeginInvokeOnMainThread(() => Grid.ItemsSource = value);
        }

        public object[] SelectedItems => Grid.SelectedItems.ToArray();

        private bool _canSearch = true;
        public bool CanSearch 
        { 
            get => _canSearch;
            set
            {
                _canSearch = value;
                CheckSearchVisibility();
            }
        }
        
        public bool PullToRefresh { get; set; }
        
        public MobileGridSelectionMode SelectionMode
        {
            
            get => Grid.SelectionMode == Syncfusion.SfDataGrid.XForms.SelectionMode.Multiple
                ? MobileGridSelectionMode.Multiple
                : Grid.SelectionMode == Syncfusion.SfDataGrid.XForms.SelectionMode.Single
                    ? MobileGridSelectionMode.Single
                    : MobileGridSelectionMode.None;
            
            set => Grid.SelectionMode = value == MobileGridSelectionMode.Multiple
                ? Syncfusion.SfDataGrid.XForms.SelectionMode.Multiple
                : value == MobileGridSelectionMode.Single 
                    ? Syncfusion.SfDataGrid.XForms.SelectionMode.SingleDeselect
                    : Syncfusion.SfDataGrid.XForms.SelectionMode.None;
        }

        public event MobileGridSelectionChanged SelectionChanged;
        
        public event MobileGridRefreshRequested RefreshRequested;

        internal void RequestRefresh()
        {
            RefreshRequested?.Invoke(this, new MobileGridRefreshRequestArgs());
        }
        
        bool DoSearch(object data)
        {
            if (String.IsNullOrWhiteSpace(Search.Text))
                return true;
            
            bool result = false;
            var cols = Grid.Columns.OfType<GridTextColumn>().ToArray();
            foreach (var col in cols)
            {
                var property = data.GetType().GetProperty(col.MappingName);
                if (property != null)
                {
                    var value = property.GetValue(data) as String;
                    if ((value != null) && value.ToUpper().Contains(Search.Text.ToUpper()))
                        return true;
                }
            }
            return false;
        }
        
        public MobileGrid()
        {
            InitializeComponent();
            Columns = new MobileGridColumns(Grid);
            SelectionMode = MobileGridSelectionMode.Single;
            CanSearch = true;
            Grid.PullToRefreshCommand = new PullToRefreshCommand(this);
        }

        private void Search_OnTextChanged(object sender, TextChangedEventArgs e)
        {
            Grid.View.RefreshFilter();
        }

        private void Grid_OnGridViewCreated(object sender, GridViewCreatedEventArgs e)
        {
            CheckSearchVisibility();
        }

        private void CheckSearchVisibility()
        {
            var searchables = Grid.Columns.OfType<GridTextColumn>().ToArray();
            if (searchables.Any() && CanSearch)
            {
                _searchGrid.IsVisible = true;
                Grid.View.Filter = DoSearch;
            }
            else
                _searchGrid.IsVisible = false;
        }

        private void Grid_OnSelectionChanged(object sender, GridSelectionChangedEventArgs e)
        {
            SelectionChanged?.Invoke(this, new MobileGridSelectionArgs(Grid.SelectedItems.ToArray()));
        }

        private void Grid_OnGridTapped(object sender, GridTappedEventArgs e)
        {
            if (SelectionMode == MobileGridSelectionMode.Multiple)
                return;
            var column = Columns[e.RowColumnIndex.ColumnIndex];
            column.Tapped?.Invoke(column, e.RowData);
        }
    }
}