using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
 
namespace SspMain
{
    public abstract class UiEditableCollection2<TListItem, TEditItem, TKey> : UiEditableCollectionBase<TListItem>
        where TListItem : class
        where TEditItem : class
    {
        #region SingleRowID Property
 
        public static readonly DependencyProperty SingleRowIDProperty =
            DependencyProperty.Register(
                "SingleRowID",
                typeof(object),
                typeof(UiEditableCollection2<TListItem, TEditItem, TKey>),
                new FrameworkPropertyMetadata((s, e) => ((UiEditableCollection2<TListItem, TEditItem, TKey>)s).SingleRowIDChanged(e))
            );
 
        public object SingleRowID
        {
            get { return (object)GetValue(SingleRowIDProperty); }
            set { SetValue(SingleRowIDProperty, value); }
        }
 
        void SingleRowIDChanged(DependencyPropertyChangedEventArgs e)
        {
            CommandManager.InvalidateRequerySuggested();
        }
 
        #endregion
 
        #region Add / Edit
 
        protected abstract FrameworkElement GetEditor();
 
        protected override void ActAddExecute()
        {
            GetNewEditItem()
                .LockUi()
                .ContinueWithSync(t =>
                {
                    var data = new EditorData<TEditItem> { Mode = UpdateAction.Insert, Data = t.Result };
                    var editor = GetEditor();
                    editor.DataContext = data;
                    ViewHelper.SetHeader(editor, "Новая запись");
                    WindowHelper.ShowAcceptDialog(editor, () => EditorAccepting(data));
                })
                .LogExceptions();
        }
 
        protected override bool ActAddCanExecute()
        {
            return base.ActAddCanExecute() && SingleRowID == null;
        }
 
        protected override void ActEditExecute()
        {
            GetEditItemByID(GetListItemID(Current))
                .LockUi()
                .ContinueWithSync(t =>
                {
                    var data = new EditorData<TEditItem> { Mode = UpdateAction.Update, Data = t.Result };
                    var editor = GetEditor();
                    editor.DataContext = data;
                    ViewHelper.SetHeader(editor, "Редактирование");
                    WindowHelper.ShowAcceptDialog(editor, () => EditorAccepting(data));
                })
                .LogExceptions();
        }
 
        protected virtual Task<bool> EditorAccepting(EditorData<TEditItem> data)
        {
            return SaveEditItem(data.Data, data.Mode)
                .ContinueWithSync(t => GetListItemByID(t.Result))
                .Unwrap()
                .ContinueWithSync(t =>
                {
                    AddOrReplace(t.Result, data.Mode);
                    OnDataChangeCompleted();
                    return true;
                });
        }
 
        #endregion
 
        #region Delete
 
        protected override void ActDeleteExecute()
        {
            if (CommonDialogs.AskForDeleteRow())
                DeleteByID(GetListItemID(Current))
                    .LockUi()
                    .ContinueWithSync(t =>
                    {
                        t.ThrowIfException();
                        RemoveCurrent();
                        OnDataChangeCompleted();
                    })
                    .LogExceptions();
        }
 
        #endregion
 
        #region RefreshCurrentItem
 
        #region ActRefreshCurrentItem
 
        public RelayCommand ActRefreshCurrentItem
        {
            get
            {
                if (_ActRefreshCurrentItem == null)
                    _ActRefreshCurrentItem = new RelayCommand(ActRefreshCurrentItemExecute, ActRefreshCurrentItemCanExecute);
                return _ActRefreshCurrentItem;
            }
        }
        RelayCommand _ActRefreshCurrentItem;
 
        void ActRefreshCurrentItemExecute()
        {
            RefreshCurrentItem()
                .LockUi()
                .LogExceptions();
        }
 
        bool ActRefreshCurrentItemCanExecute()
        {
            return HasItems;
        }
 
        #endregion
 
        public Task RefreshCurrentItem()
        {
            return GetListItemByID(GetListItemID(Current))
                .ContinueWithSync(t => ReplaceCurrent(t.Result));
        }
 
        #endregion
 
        #region Storage Actions
 
        protected abstract TKey GetListItemID(TListItem item);
        protected abstract Task<TEditItem> GetNewEditItem();
        protected abstract Task<TEditItem> GetEditItemByID(TKey id);
        protected abstract Task<TListItem> GetListItemByID(TKey id);
        protected abstract Task<TKey> SaveEditItem(TEditItem editItem, UpdateAction action);
        protected abstract Task DeleteByID(TKey id);
 
        #endregion
    }
}