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
{
    public class AttachedElementsEditorsUndoRedoStatesProvider : UndoRedoStatesProviderBase
    {
        private ElementsEditorUndoRedoExecutedEventArgs args;

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

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

        /// <summary>
        /// Initializes a new instance of the <see cref="AttachedElementsEditorsUndoRedoStatesProvider"/> class.
        /// </summary>
        /// <param name="firstElementsEditor">The first elements editor.</param>
        /// <param name="secondElementsEditor">The second elements editor.</param>
        public AttachedElementsEditorsUndoRedoStatesProvider(ElementsEditor firstElementsEditor,ElementsEditor secondElementsEditor)
        {
            ElementsEditor1 = firstElementsEditor;
            ElementsEditor2 = secondElementsEditor;
        }

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

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

            foreach (var element in ElementsEditor2.Elements)
            {
                var setups = element.GetAnimationSetups(TimeSpan.FromSeconds(0), AnimationSetupMode.Discrete);
                state.Date = DateTime.Now;
                state.ElementsSetups2.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)
        {
            ExecuteState(state, ElementsEditor1, (state as AttachedElementsEditorsUndoRedoState).ElementsSetups1);
            ExecuteState(state, ElementsEditor2, (state as AttachedElementsEditorsUndoRedoState).ElementsSetups2);
        }

        /// <summary>
        /// Executes the state.
        /// </summary>
        /// <param name="state">The state.</param>
        /// <param name="ElementsEditor">The elements editor.</param>
        /// <param name="elementsSetups">The elements setups.</param>
        private void ExecuteState(IUndoRedoState state,ElementsEditor ElementsEditor, List<KeyValuePair<IElementEditor, List<AnimationSetup>>> elementsSetups)
        {
            AttachedElementsEditorsUndoRedoState elementsEditorState = state as AttachedElementsEditorsUndoRedoState;

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

            foreach (var elementSetups in 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 => !elementsSetups.Select(y => y.Key).ToList().Contains(x)).ToList();
            elementsToRemove.ForEach(x =>
            {
                ElementsEditor.RemoveElement(x);
            });

            args.RemovedElements = elementsToRemove;
            args.ModifiedElements = 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);
        }
    }
}