using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

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>
        /// Quand cette méthode est redéfinie dans une classe dérivée,
        /// exécute l'opération correspondant à l'objet courant
        /// </summary>
        public abstract void Execute();

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

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

        internal int ProgressCallback(
            long totalFileSize,
            long totalBytesTransferred,
            long streamSize,
            long streamBytesTransferred,
            int dwStreamNumber,
            int dwCallbackReason,
            IntPtr hSourceFile,
            IntPtr hDestinationFile,
            IntPtr lpData)
        {
            var args = new FileOperationProgressEventArgs(
                OperationType,
                Source,
                Destination,
                totalBytesTransferred,
                totalFileSize);
            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 ERROR_REQUEST_ABORTED = 1235;

        #endregion

    }
}