using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Animation;
using Tango.Editors;

namespace Tango.Editors
{
    /// <summary>
    /// Represents an <see cref="ElementsEditor"/> undo/redo states provider.
    /// </summary>
    /// <seealso cref="Tango.Editors.UndoRedoStatesProviderBase" />
    public class ElementsEditorUndoRedoStatesProvider : UndoRedoStatesProviderBase
    {
        private ElementsEditorUndoRedoExecutedEventArgs args;

        /// <summary>
        /// Gets or sets the elements editor.
        /// </summary>
        public ElementsEditor ElementsEditor { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="ElementsEditorUndoRedoStatesProvider"/> class.
        /// </summary>
        /// <param name="editor">The editor.</param>
        public ElementsEditorUndoRedoStatesProvider(ElementsEditor editor)
        {
            ElementsEditor = editor;
        }

        /// <summary>
        /// Creates the a new undo/redo state.
        /// </summary>
        /// <returns></returns>
        public override IUndoRedoState CreateUndoRedoState()
        {
            ElementsEditorUndoRedoState state = new ElementsEditorUndoRedoState();

            foreach (var element in ElementsEditor.Elements)
            {
                var setups = element.GetAnimationSetups(TimeSpan.FromSeconds(0), AnimationSetupMode.Discrete);
                state.Date = DateTime.Now;
                state.ElementsSetups.Add(new KeyValuePair<IElementEditor, List<AnimationSetup>>(element, setups));
            }

            return state;
        }

        /// <summary>
        /// Executes the an undo/redo state.
        /// </summary>
        /// <param name="state">The state.</param>
        public override void ExecuteState(IUndoRedoState state)
        {
            ElementsEditorUndoRedoState elementsEditorState = state as ElementsEditorUndoRedoState;

            args = new ElementsEditorUndoRedoExecutedEventArgs();
            args.State = elementsEditorState;

            foreach (var elementSetups in elementsEditorState.ElementsSetups)
            {
                var element = elementSetups.Key;
                var setups = elementSetups.Value;

                if (!ElementsEditor.Elements.Contains(element)) //Add elements missing on editor.
                {
                    ElementsEditor.Elements.Add(element);
                    args.RestoredElements.Add(element);
                }

                Storyboard story = new Storyboard();

                foreach (var setup in setups)
                {
                    story.Children.Add(setup.Animation);
                    String name = UIHelper.GetRandomAnimationName();
                    ElementsEditor.RegisterName(name, setup.DependencyObject);
                    Storyboard.SetTargetName(setup.Animation, name);
                    Storyboard.SetTargetProperty(setup.Animation, new System.Windows.PropertyPath(setup.DependencyProperty));
                }

                story.Completed += (x, y) =>
                {
                    List<KeyValuePair<AnimationSetup, object>> setupValues = new List<KeyValuePair<AnimationSetup, object>>();

                    foreach (var setup in setups)
                    {
                        KeyValuePair<AnimationSetup, object> setupvalue = new KeyValuePair<AnimationSetup, object>(setup, setup.DependencyObject.GetValue(setup.DependencyProperty));
                        setupValues.Add(setupvalue);
                    }

                    foreach (var setupValue in setupValues)
                    {
                        if (setupValue.Key.DependencyObject is IAnimatable)
                        {
                            (setupValue.Key.DependencyObject as IAnimatable).BeginAnimation(setupValue.Key.DependencyProperty, null);
                        }
                        setupValue.Key.DependencyObject.SetValue(setupValue.Key.DependencyProperty, setupValue.Value);
                    }

                };

                story.Duration = TimeSpan.FromMilliseconds(10);
                story.Begin(ElementsEditor);
            }

            //Remove elements that does not exist on state.
            var elementsToRemove = ElementsEditor.Elements.Where(x => !elementsEditorState.ElementsSetups.Select(y => y.Key).ToList().Contains(x)).ToList();
            elementsToRemove.ForEach(x => 
            {
                ElementsEditor.RemoveElement(x);
            });

            args.RemovedElements = elementsToRemove;
            args.ModifiedElements = elementsEditorState.ElementsSetups.
                Select(x => x.Key).
                ToList().
                Where(x => !args.RestoredElements.Contains(x) && !args.RemovedElements.Contains(x)).ToList();
        }

        /// <summary>
        /// Raises the <see cref="E:StateExecuted" /> event.
        /// </summary>
        /// <param name="e">The <see cref="T:Tango.Editors.UndoRedoStateExecutedEventArgs" /> instance containing the event data.</param>
        public override void OnStateExecuted(UndoRedoStateExecutedEventArgs e)
        {
            args.Mode = e.Mode;
            base.OnStateExecuted(args);
        }
    }
}