using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Collections.Generic;
using System.Xml.Linq;
using System.Threading;
using Iri.Modernisation.Data.LDTClass;
using System.IO;
namespace Iri.Modernisation.Data.Models
{
    /// <summary>
    /// Classe VideoLivre
    /// </summary>
    public class VideoBook
    {
        /// <summary>
        /// Titre du VideoLivre
        /// </summary>
        public String Title { get; set; }

        /// <summary>
        /// Auteur du VideoLivre
        /// </summary>
        public User Author { get; set; }

        /// <summary>
        /// Chapitre du VideoLivre
        /// </summary>
        public VideoChapter[] Chapters { get; set; }

        /// <summary>
        /// Durée du VideoLivre
        /// </summary>
        public TimeSpan Duration { get; set; }

        /// <summary>
        /// Chemin de la vidéo fini
        /// </summary>
        public String MediaPath { get; set; }

        /// <summary>
        /// Chemin du projet .ldt
        /// </summary>
        public String LdtPath { get; set; }

        /// <summary>
        /// Chemin du .iri
        /// </summary>
        public String IriPath { get; set; }


        public List<PolemicLink> BasicLinks { get; set; }

        public List<PolemicLink> PolemicLinks { get; set; }
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public VideoBook()
        {
            BasicLinks = new List<PolemicLink>();
            PolemicLinks = new List<PolemicLink>();
            Chapters = new VideoChapter[FactoryVideoLivre.VideoChapterDescriptions.Length];
            for (int nbChapitre = 0; nbChapitre < FactoryVideoLivre.VideoChapterDescriptions.Length; nbChapitre++)
            {
                Chapters[nbChapitre] = new VideoChapter(this,
                                                         FactoryVideoLivre.VideoChapterDescriptions[nbChapitre].Id,
                                                         FactoryVideoLivre.VideoChapterDescriptions[nbChapitre].Title,
                                                         FactoryVideoLivre.VideoChapterDescriptions[nbChapitre].Color);

            }
         
        }

        public LDTFile GetLDTFile()
        {
            LDTFile ldt = new LDTFile();
            ldt.Project = new LDTProject()
             {
                 Title = this.Title,
                 User = this.Author.UserName
             };
            ldt.Medias = new List<LDTMedia>()
             {
                 new LDTMedia()
                 {
                     Src = IriPath,
                     
                 }
             };
            foreach (VideoChapter Vc in Chapters)
            {
                ldt.Annotations.Add(
                       new LDTAnnotationsContent()
                       {

                       });
                foreach (Annotation An in Vc.Annotations)
                {
                    LDTAnnotationsDecoupage decoupage = new LDTAnnotationsDecoupage()
                    {
                        Title = Vc.Title,
                        Author = SettingsProject.ActualUser.UserName
                    };
                    decoupage.Elements.Add(
                                            new LDTElement()
                                            {
                                                Id = An.Id,
                                                Title = An.Title,
                                                Abstract = An.Description,
                                                Date = DateTime.Now,
                                                Begin = An.TimerIn.TotalMilliseconds,
                                                Dur = An.Duration.TotalMilliseconds,
                                                Tags = An.Tags,
                                                Author = SettingsProject.ActualUser.UserName,
                                            }
                                                );



                    ldt.Annotations[ldt.Annotations.Count - 1].Content.Add(decoupage);
                }
                foreach (PolemicLink Pl in BasicLinks)
                {
                    ldt.BasicRelations.Add(new LDTRelation()
                    {
                        Type = Pl.Type.Title,
                        IdElementFrom = Pl.FromElement.Id,
                        IdElementTo = Pl.ToElement.Id,
                        Title = Pl.ToElement.Title
                    });
                }
                foreach (PolemicLink Pl in PolemicLinks)
                {
                    ldt.PolemicRelations.Add(new LDTRelation()
                    {
                        Type = Pl.Type.Title,
                        IdElementFrom = Pl.FromElement.Id,
                        IdElementTo = Pl.ToElement.Id,
                        Title = Pl.ToElement.Title
                    });
                   
                }
               
            }
            return ldt;
        }

      

        /// <summary>
        /// Méthode static pour le Loader de la list de videoBook
        /// </summary>
        /// <param name="XDoc">XDoc du fichier pointant tous les chemin .ldt des videoLivre disponible</param>
        /// <returns>List des VideoLivre (non chargé)</returns>
        public static List<VideoBook> GetListVideoBook(XDocument XDoc)
        {
            
            List<VideoBook> ListReturn = new List<VideoBook>();
            
            foreach (XElement XVideoBook in XDoc.Root.Elements())
            {

                VideoBook temp = new VideoBook();
                temp.LdtPath = XVideoBook.Attribute("metafile").Value; ;
                temp.Title = XVideoBook.Attribute("title").Value;
                ListReturn.Add(temp);


            }
            return ListReturn;
        }
           
        
        
    }
    public class VideoBookUploader
    {
        private static Loader<LDTFile> loaderLdt = new Loader<LDTFile>(LDTFile.FromXML);
        private static LDTFile ldt = new LDTFile();
        private static VideoBook videoBookToUpdate;
        private static StreamWriter Sw;
        public static void UpdateAnnotation(VideoBook update,StreamWriter sw)
        {
            Sw = sw;
            videoBookToUpdate = update;
            loaderLdt.LoaderFinished += new EventHandler<EventArgs>(loaderLdt_LoaderFinished);
            loaderLdt.Load(videoBookToUpdate.LdtPath);

        }
        public static void UpdateAnnotation(VideoBook update)
        {
            videoBookToUpdate = update;
            loaderLdt.LoaderFinished += new EventHandler<EventArgs>(loaderLdt_LoaderFinished);
            loaderLdt.Load(videoBookToUpdate.LdtPath);

        }

        static void loaderLdt_LoaderFinished(object sender, EventArgs e)
        {
            ldt = ((LoaderEventArgs<LDTFile>)e).CreatedObject;
            ldt.Annotations.Clear();
            
            foreach (VideoChapter Vc in videoBookToUpdate.Chapters)
            {
                 ldt.Annotations.Add(
                        new LDTAnnotationsContent()
                        {
                         
                        });
                foreach(Annotation An in Vc.Annotations)
                {
                    LDTAnnotationsDecoupage decoupage = new LDTAnnotationsDecoupage()
                    {
                        Title = Vc.Title,
                        Author = SettingsProject.ActualUser.UserName
                    };
                    decoupage.Elements.Add(
                                            new LDTElement()
                                            {
                                                Id = An.Id,
                                                Title = An.Title,
                                                Abstract = An.Description,
                                                Date = DateTime.Now,
                                                Begin = An.TimerIn.TotalMilliseconds,
                                                Dur = An.Duration.TotalMilliseconds,
                                                Tags = An.Tags,
                                                Author = SettingsProject.ActualUser.UserName,
                                            }
                                                );
                  


                    ldt.Annotations[ldt.Annotations.Count - 1].Content.Add(decoupage);
                }
                foreach (PolemicLink Pl in videoBookToUpdate.BasicLinks)
                {
                    ldt.BasicRelations.Add(new LDTRelation()
                        {
                            Type = Pl.Type.Title,
                            IdElementFrom = Pl.FromElement.Id,
                            IdElementTo = Pl.ToElement.Id,
                            Title = Pl.ToElement.Title
                        });
                }
                foreach (PolemicLink Pl in videoBookToUpdate.PolemicLinks)
                {
                    ldt.PolemicRelations.Add(new LDTRelation()
                    {
                        Type = Pl.Type.Title,
                        IdElementFrom = Pl.FromElement.Id,
                        IdElementTo = Pl.ToElement.Id,
                        Title = Pl.ToElement.Title
                    });
                }
            }
           
                     WebClient WebWriter = new WebClient();
            
               
                     WebWriter.OpenWriteCompleted +=new OpenWriteCompletedEventHandler(WebWriter_OpenWriteCompleted);
          WebWriter.OpenWriteAsync(new Uri(videoBookToUpdate.LdtPath, UriKind.RelativeOrAbsolute));
                 //    WebWriter.UploadStringCompleted += new UploadStringCompletedEventHandler(WebWriter_UploadStringCompleted);
                //     WebWriter.UploadStringAsync(new Uri(videoBookToUpdate.LdtPath, UriKind.RelativeOrAbsolute),"azerty");

        }
    

        static void WebWriter_UploadStringCompleted(object sender, UploadStringCompletedEventArgs e)
        {
          
        }


        static void WebWriter_OpenWriteCompleted(object sender, OpenWriteCompletedEventArgs e)
        {
           
            
           /*using (Stream fs = e.Result)
            {

                // Add some information to the file.
                byte[] info = new System.Text.UTF8Encoding(true).GetBytes("This is some text in the file.");

                fs.Write(info, 0, info.Length);

                fs.Close();

            }*/

            StreamWriter fs = Sw;
         
                  
                    fs.Write(ldt.ToString());
                    fs.Close();
               
            
            /*StreamWriter fs = new StreamWriter(e.Result);
            //MessageBox.Show(ldt.ToString());
            fs.Write(ldt.ToString());
            fs.Flush();
            fs.Close();*/
        }
    }
    public class VideoBookLoader
    {
        private Loader<IRIFile> _iriFile;
        private Loader<LDTFile> _ldtFile;
        private IRIFile _loadedIriFile;
        private LDTFile _loadedLdtFile;
        public VideoBookLoader()
        {
            _iriFile = new Loader<IRIFile>(IRIFile.FromXML);
            _ldtFile = new Loader<LDTFile>(LDTFile.FromXML);
            _ldtFile.LoaderFinished += new EventHandler<EventArgs>(_ldtFile_LoaderFinished);
            _iriFile.LoaderFinished += new EventHandler<EventArgs>(_iriFile_LoaderFinished);
        }

        void _iriFile_LoaderFinished(object sender, EventArgs e)
        {
            _loadedIriFile = ((LoaderEventArgs<IRIFile>)e).CreatedObject;
            
            LoaderFinished(this,new LoaderEventArgs<VideoBook>(LDTFileReader.ConvertToVideoBook(_loadedLdtFile,_loadedIriFile)));
        }

        void _ldtFile_LoaderFinished(object sender, EventArgs e)
        {
            _loadedLdtFile = ((LoaderEventArgs<LDTFile>)e).CreatedObject;
            _loadedLdtFile.Path = _ldtFile.Path;
            _iriFile.Load(_loadedLdtFile.Medias[0].Src);
            
        }
        public void Load(String ldtPath)
        {
            _ldtFile.Load(ldtPath);
        }
        public event EventHandler<LoaderEventArgs<VideoBook>> LoaderFinished;

        
    }


    /// <summary>
    /// Comparateur pour Trier les livres
    /// </summary>
    public class VideoBookComparer : IComparer<VideoBook>
    {
        public int Compare(VideoBook x, VideoBook y)
        {
            return x.Title.CompareTo(y.Title);
        }
    }

}