using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using Developpez.Dotnet.Collections;
using Developpez.Dotnet.System.Properties;

namespace Developpez.Dotnet.System
{
    /// <summary>
    /// Classe de base abstraite pour des opérations de copie et de déplacement
    /// de fichier qui peuvent signaler leur progression.
    /// </summary>
    public abstract class FileOperationBase
    {
        /// <summary>
        /// Initialise une nouvelle instance de FileOperationBase
        /// </summary>
        /// <param name="source">Fichier source</param>
        /// <param name="destination">Fichier destination</param>
        protected FileOperationBase(string source, string destination)
        {
            Source = source;
            Destination = destination;
        }

        /// <summary>
        /// Exécute l'opération correspondant à l'objet courant
        /// </summary>
        public void Execute()
        {
            if (_executing)
                throw new InvalidOperationException(ExceptionMessages.OperationAlreadyInProgress);

            Execute(true, SynchronizationContext.Current);
        }

        /// <summary>
        /// Quand cette méthode est redéfinie dans une classe dérivée,
        /// exécute l'opération correspondant à l'objet courant
        /// </summary>
        protected abstract void ExecuteCore();

        /// <summary>
        /// Exécute l'opération de façon asynchrone. Cette méthode retourne
        /// immédiatement. L'évènement Completed est déclenché à la fin de
        /// l'opération.
        /// </summary>
        public void ExecuteAsync()
        {
            if (_executing)
                throw new InvalidOperationException(ExceptionMessages.OperationAlreadyInProgress);

            var synchronizationContext = SynchronizationContext.Current;
            var thread = new Thread(() => Execute(false, synchronizationContext));
            thread.Start();
        }

        /// <summary>
        /// Quand cette propriété est redéfinie dans une classe dérivée,
        /// renvoie le type d'opération correspondant à l'objet courant
        /// </summary>
        public abstract FileOperationType OperationType { get; }

        /// <summary>
        /// Renvoie ou définit une valeur indiquant si le fichier cible
        /// doit être remplacé s'il existe déjà. Si cette propriété est <c>false</c>
        /// et que le fichier cible existe, une exception est levée.
        /// </summary>
        public bool ReplaceExisting { get; set; }

        /// <summary>
        /// Renvoie le nom du fichier source
        /// </summary>
        public string Source { get; private set; }

        /// <summary>
        /// Renvoie le nom du fichier de destination
        /// </summary>
        public string Destination { get; private set; }

        /// <summary>
        /// Se produit quand l'opération signale sa progression
        /// </summary>
        public event FileOperationProgressEventHandler ProgressChanged;

        /// <summary>
        /// Se produit quand l'opération est terminée.
        /// </summary>
        public event FileOperationCompletedEventHandler Completed;

        /// <summary>
        /// Déclenche l'évènement ProgressChanged
        /// </summary>
        /// <param name="e">Un FileOperationProgressEventArgs qui contient les données de l'évènement</param>
        protected virtual void OnProgressChanged(FileOperationProgressEventArgs e)
        {
            var handler = ProgressChanged;
            if (handler != null)
                handler(this, e);
        }

        /// <summary>
        /// Déclenche l'évènement Completed
        /// </summary>
        /// <param name="e">Un FileOperationCompletedEventArgs qui contient les données de l'évènement</param>
        protected virtual void OnCompleted(FileOperationCompletedEventArgs e)
        {
            var handler = Completed;
            if (handler != null)
                handler(this, e);
        }

        internal void CheckError(bool result)
        {
            if (!result)
            {
                int error = Marshal.GetLastWin32Error();
                if (error != ErrorRequestAborted)
                {
                    int hr = Marshal.GetHRForLastWin32Error();
                    throw Marshal.GetExceptionForHR(hr);
                }
            }
        }

        private SynchronizationContext _synchronizationContext;
        private bool _executing;

        private void Execute(bool rethrow, SynchronizationContext synchronizationContext)
        {
            try
            {
                _synchronizationContext = synchronizationContext;
                _executing = true;
                _progressBuffer.Clear();
                _stopwatch.Start();
                ExecuteCore();
                _stopwatch.Stop();
                ExecuteOnSynchronizationContext(() => OnCompleted(new FileOperationCompletedEventArgs(_stopwatch.Elapsed, null)));
            }
            catch (Exception ex)
            {
                _stopwatch.Stop();
                ExecuteOnSynchronizationContext(() => OnCompleted(new FileOperationCompletedEventArgs(_stopwatch.Elapsed, ex)));
                if (rethrow)
                    throw;
            }
            finally
            {
                _synchronizationContext = null;
                _executing = false;
            }
        }

        private void ExecuteOnSynchronizationContext(Action action)
        {
            if (SynchronizationContext.Current == _synchronizationContext || _synchronizationContext == null)
            {
                action();
            }
            else
            {
                _synchronizationContext.Send(_ => action(), null);
            }
        }

        private class ProgressState
        {
            public ProgressState(TimeSpan elapsed, long transferred)
            {
                _elapsed = elapsed;
                _transferred = transferred;
            }

            private readonly TimeSpan _elapsed;
            public TimeSpan Elapsed
            {
                get { return _elapsed; }
            }

            private readonly long _transferred;
            public long Transferred
            {
                get { return _transferred; }
            }
        }

        private readonly Stopwatch _stopwatch = new Stopwatch();
        private readonly LinkedList<ProgressState> _progressBuffer = new LinkedList<ProgressState>();

        internal int ProgressCallback(
            long totalFileSize,
            long totalBytesTransferred,
            long streamSize,
            long streamBytesTransferred,
            int dwStreamNumber,
            int dwCallbackReason,
            IntPtr hSourceFile,
            IntPtr hDestinationFile,
            IntPtr lpData)
        {
            TimeSpan elapsed = _stopwatch.Elapsed;

            _progressBuffer.AddLast(new ProgressState(elapsed, totalBytesTransferred));
            if (_progressBuffer.Count > 20)
                _progressBuffer.RemoveFirst();

            var deltas = _progressBuffer.Zip(_progressBuffer.Prepend(new ProgressState(TimeSpan.Zero, 0)),
                                             (current, previous) =>
                                             new
                                             {
                                                 Elapsed = current.Elapsed - previous.Elapsed,
                                                 Transferred = current.Transferred - previous.Transferred
                                             });
            long speed = (long)deltas.Average(x => x.Transferred / x.Elapsed.TotalSeconds);

            var args = new FileOperationProgressEventArgs(
                OperationType,
                Source,
                Destination,
                totalBytesTransferred,
                totalFileSize,
                elapsed,
                speed);
            ExecuteOnSynchronizationContext(() => OnProgressChanged(args));
            return (int) args.Action;
        }

        #region Interop declarations

        internal delegate int CopyProgressRoutine(
            long totalFileSize,
            long totalBytesTransferred,
            long streamSize,
            long streamBytesTransferred,
            int dwStreamNumber,
            int dwCallbackReason,
            IntPtr hSourceFile,
            IntPtr hDestinationFile,
            IntPtr lpData);

        internal const int ErrorRequestAborted = 1235;

        #endregion
    }
}