using System;

using System.Collections.Generic;

using System.IO;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Navigation;

using System.Windows.Controls.Primitives;

using Microsoft.Surface.Presentation;

using Microsoft.Surface.Presentation.Controls;

using System.Windows.Threading;

using FingersDance.Data;

using FingersDance.ViewModels;

using FingersDance.Views;

using FingersDance.Control.Close;

namespace FingersDance.Control.TimeLine

{

	public partial class UserControlTimeLine

    {

        #region Variables

        private DispatcherTimer timer;

        private bool isDragging = false;

        private bool finishedDragging = false;

        #endregion

        public event EventHandler DragStarted;

        public event EventHandler DragCompleted;

        public event EventHandler TimerTick;

        //SAR

        public event EventHandler OnSuccessAnnotation;

        //ENDSAR

        private double totalmilliseconds;

        private List<Annotation> AnnotList = new List<Annotation>();

        private float AnnotWidth = 850 + 15; // The surfaceListBox adds 15 pixels between each item

        private CuttingViewModel CuttingVM;

        private Boolean AnnotWaiting = false;

        private float AnnotTcBegin;

        private Color CurrentColor;

        private AnnotationViewModel canceledAnnotationVM;

        #region Properties

        public SurfaceSlider Slider

        {

            get

            {

                return slider;

            }

            set

            {

                slider = value;

            }

        }

        public bool IsDragging

        {

            get

            {

                return isDragging;

            }

            set

            {

                isDragging = value;

            }

        }

        public bool FinishedDragging

        {

            get

            {

                return finishedDragging;

            }

            set

            {

                finishedDragging = value;

            }

        }

        public DispatcherTimer Timer

        {

            get

            {

                return timer;

            }

            set

            {

                timer = value;

            }

        }

        #endregion

        #region Constructors

        public UserControlTimeLine()

		{

			this.InitializeComponent();

			// Insert code required on object creation below this point.

        }

        #endregion

        public void initslider(double totalmillisecondsPar)

        {

            totalmilliseconds = totalmillisecondsPar;

            slider.Maximum = totalmilliseconds;

            // When the timeline is resized, we catch the resize event to define TimelineView's good scale

            this.SizeChanged += new SizeChangedEventHandler(UserControlTimeLine_SizeChanged);

            tv.listview.PreviewContactDown += listview_PreviewContactDown;

            SurfaceDragDrop.AddDragCanceledHandler(tv.listview, onDragCanceled);

            UserControlTimeLine_SizeChanged(null, null);

            slider_ContactTapGesture(this, null);

        }

        void UserControlTimeLine_SizeChanged(object sender, SizeChangedEventArgs e)

        {

            // When scaleX = 1, 1 second = 1 pixel. To calculate the new scale, we take the real width in account.

            tv.ScaleX = (this.ActualWidth-30) / (totalmilliseconds / 1000);

            //tv.Width = this.ActualWidth - 30;

        }

        #region Timer

        {

            timer = new DispatcherTimer();

            timer.Interval = new TimeSpan(0, 0, 0, 0, 100);

            timer.Tick += new EventHandler(timer_Tick);

            CurrentColor = col;

            // DATA BINDING from the cutting sent in parameter (initialised before by the userPanel with the global project)

            AnnotList = new List<Annotation>();

            AnnotList.Add(new Annotation(0, 10, "Axe Cam 1", CurrentColor));

            //AnnotList.Add(new Annotation(100 - (1 * AnnotWidth), 70, "Mvt Cam 2"));

            //AnnotList.Add(new Annotation(200 - (2 * AnnotWidth), 50, "Saut 3"));

            //AnnotList.Add(new Annotation(100 - (3 * AnnotWidth), 20, "Saut 4"));

            //AnnotList.Add(new Annotation(120 - (4 * AnnotWidth), 50, "Saut 5"));

            tv.DataContext = CuttingVM;

        }

        public void timerStart()

        {

            if (timer != null)

                timer.Start();

        }

        void timer_Tick(object sender, EventArgs e)

        {

            OnTimerTick();

            if (!isDragging)

            {

                //slider.Value = media.Position.TotalMilliseconds;

            }

            if (finishedDragging)

            {

                //int SliderValue = (int)slider.Value;

                //TimeSpan ts = new TimeSpan(0, 0, 0, 0, SliderValue);

               // media.Position = ts;

               // media.Play();

               // isDragging = false;

                //finishedDragging = false;

            }

        }

        protected virtual void OnTimerTick()

        {

            if (TimerTick != null)

                TimerTick(this, new EventArgs());

        }

        #endregion

        #region SliderDrag

        private void sliderPosition_DragStarted(object sender, DragStartedEventArgs e)

        {

            isDragging = true;

            OnDragStarted();

           // media.Pause();

        }

        protected virtual void OnDragStarted()

        {

            if (DragStarted != null)

                DragStarted(this, new EventArgs());

        }

        private void sliderPosition_DragCompleted(object sender, DragCompletedEventArgs e)

        {

            finishedDragging = true;

            OnDragCompleted();

        }

        protected virtual void OnDragCompleted()

        {

            if (DragCompleted != null)

                DragCompleted(this, new EventArgs());

        }

        private void slider_ContactTapGesture(object sender, Microsoft.Surface.Presentation.ContactEventArgs e)

        {

            //startOrEndAnnotation();

        }

        #endregion

        public void thumbRotation(bool isplaying)

        { 

            //Templateslider.Style.Setters["Template"]

            if(isplaying)

                slider.Style = FindResource("FingersDance.Control.Slider") as Style;

            else

                slider.Style = FindResource("SurfaceSliderStylePause") as Style;

        }

        public Boolean isAnnotationAccepted(AnnotationViewModel avm)

        {

            Boolean annotOk = true;

            // We check if the annotation's begin and end timecodes allow a new annotation creation

            if (CuttingVM != null && AnnotWaiting == false)

            {

                foreach (Annotation a in AnnotList)

                {

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", avm.TcBegin = " + avm.TcBegin + ", tcOut = " + (a.TcBegin + a.Dur));

                    // Check begin TC

                    if (a.TcBegin <= avm.TcBegin && avm.TcBegin <= (a.TcBegin + a.Dur))

                    {

                        annotOk = false;

                    }

                    // Check end tc and if the new annotation will not cover any other

                    float endTC = avm.TcBegin + avm.Dur;

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", tcOut = " + (a.TcBegin + a.Dur) + ", AnnotTcBegin = " + AnnotTcBegin + ", currentTC = " + currentTC);

                    if (a.TcBegin <= endTC && endTC <= (a.TcBegin + a.Dur) || (avm.TcBegin < a.TcBegin && (a.TcBegin + a.Dur) < endTC))

                    {

                        annotOk = false;

                    }

                }

            }

            else

            {

                annotOk = false;

            }

            return annotOk;

        }

        public void addAnnotation(AnnotationViewModel avm)

        {

            //Console.WriteLine("addAnnotation = " + avm.TcBegin + ", " + avm.Dur + ", " + avm.GestureType);

            Boolean annotOk = true;

            // We check if the annotation's begin and end timecodes allow a new annotation creation

            if (CuttingVM != null && AnnotWaiting == false)

            {

                foreach (Annotation a in AnnotList)

                {

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", avm.TcBegin = " + avm.TcBegin + ", tcOut = " + (a.TcBegin + a.Dur));

                    // Check begin TC

                    if (a.TcBegin <= avm.TcBegin && avm.TcBegin <= (a.TcBegin + a.Dur))

                    {

                        annotOk = false;

                    }

                    // Check end tc and if the new annotation will not cover any other

                    float endTC = avm.TcBegin + avm.Dur;

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", tcOut = " + (a.TcBegin + a.Dur) + ", AnnotTcBegin = " + AnnotTcBegin + ", currentTC = " + currentTC);

                    if (a.TcBegin <= endTC && endTC <= (a.TcBegin + a.Dur) || (avm.TcBegin < a.TcBegin && (a.TcBegin + a.Dur) < endTC))

                    {

                        annotOk = false;

                    }

                }

                // If everything's fine, we create the new one

                if (annotOk == true)

                {

                    AnnotList.Add(new Annotation(avm.TcBegin, avm.Dur, avm.GestureType, avm.Color));

                    CuttingVM.setListFromAnnotations(AnnotList, AnnotWidth, tv.ScaleX);

                    tv.DataContext = null;

                    tv.DataContext = CuttingVM;

                    AnnotWaiting = false;

                }

            }

            //Raise Event to display Annotation in all Openned UserPanels

            if (annotOk)

                OnSuccessAnnotation(this, new EventArgs());

        }

        public void startOrEndAnnotation()

        {

            Boolean annotOk = true;

            // We open a new annotation

            if (CuttingVM != null && AnnotWaiting == false)

            {

                AnnotTcBegin = (float)slider.Value / 1000;

                // First we check if the new annotation will not cover any

                foreach (Annotation a in AnnotList)

                {

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", AnnotTcBegin = " + AnnotTcBegin + ", tcOut = " + (a.TcBegin + a.Dur));

                    if (a.TcBegin <= AnnotTcBegin && AnnotTcBegin <= (a.TcBegin + a.Dur))

                    {

                        annotOk = false;

                    }

                }

                // if not, we mark the beginning

                if (annotOk == true)

                {

                    AnnotList.Add(new Annotation(AnnotTcBegin, 0, AnnotList.Count.ToString(), CurrentColor));

                    CuttingVM.setListFromAnnotations(AnnotList, AnnotWidth, tv.ScaleX);

                    tv.DataContext = null;

                    tv.DataContext = CuttingVM;

                    AnnotWaiting = true;

                }

            }

            // We close the current opened annotation...

            else if (CuttingVM != null && AnnotWaiting == true && (((float)slider.Value/1000)>AnnotTcBegin))

            {

                // ... by setting setting the good beginning and the good duration

                float currentTC = (float)slider.Value / 1000;

                float currentDuration = currentTC - AnnotTcBegin;

                // First we check if the new annotation will not cover any (AnnotTcBegin was already checked)

                foreach (Annotation a in AnnotList)

                {

                    //Console.WriteLine("a.TcBegin = " + a.TcBegin + ", tcOut = " + (a.TcBegin + a.Dur) + ", AnnotTcBegin = " + AnnotTcBegin + ", currentTC = " + currentTC);

                    if (a.TcBegin <= currentTC && currentTC <= (a.TcBegin + a.Dur) || (AnnotTcBegin < a.TcBegin && (a.TcBegin + a.Dur) < currentTC))

                    {

                        annotOk = false;

                    }

                }

                if (annotOk == true)

                {

                    AnnotList.RemoveAt(AnnotList.Count - 1);

                    AnnotList.Add(new Annotation(AnnotTcBegin, currentDuration, AnnotList.Count.ToString(), CurrentColor));

                    CuttingVM.setListFromAnnotations(AnnotList, AnnotWidth, tv.ScaleX);

                    //Console.WriteLine("currentTimecode = " + AnnotTcBegin + ", curDur = " + currentDuration + ", nb = " + AnnotList.Count + ", res = " + (AnnotTcBegin - (AnnotList.Count * AnnotWidth)));

                    tv.DataContext = null;

                    tv.DataContext = CuttingVM;

                    AnnotWaiting = false;

                }

                //Raise Event to display Annotation in all Openned UserPanels

                if (annotOk)

                    OnSuccessAnnotation(this, new EventArgs());

            }

        }

        private void listview_PreviewContactDown(object sender, Microsoft.Surface.Presentation.ContactEventArgs e)

        {

            FrameworkElement findSource = e.OriginalSource as FrameworkElement;