using System;
using System.Runtime.InteropServices;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Représente un pointeur non managé qui implémente IDisposable pour libérer la ressource.
    /// </summary>
    public class DisposablePointer : IDisposable
    {
        /// <summary>
        /// Initialise une nouvelle instance de DisposablePointer, avec la valeur spécifiée et
        /// l'action spécifiée pour libérer le pointeur.
        /// </summary>
        /// <param name="value">Valeur initiale du pointeur</param>
        /// <param name="disposeAction">Action à exécuter pour libérer le pointeur</param>
        public DisposablePointer(IntPtr value, Action<IntPtr> disposeAction)
        {
            this._value = value;
            this._disposeAction = disposeAction;
        }

        private bool _disposed = false;
        private readonly IntPtr _value;
        private Action<IntPtr> _disposeAction;

        /// <summary>
        /// Renvoie la valeur du pointeur
        /// </summary>
        /// <exception cref="ObjectDisposedException">L'objet a été disposé et le pointeur libéré</exception>
        public IntPtr Value
        {
            get
            {
                if (_disposed)
                    throw new ObjectDisposedException("DisposablePointer");
                return _value;
            }
        }

        /// <summary>
        /// Libère la ressource représentée par le pointeur, en appelant l'action spécifiée
        /// en paramètre du constructeur
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Destructeur
        /// </summary>
        ~DisposablePointer()
        {
            this.Dispose(false);
        }

        /// <summary>
        /// Libère la ressource représentée par le pointeur, en appelant l'action spécifiée
        /// en paramètre du constructeur
        /// </summary>
        /// <param name="disposing">Inutilisé</param>
        protected virtual void Dispose(bool disposing)
        {
            if (_disposeAction != null && _value != IntPtr.Zero)
                _disposeAction(_value);
            _disposed = true;
        }

#if !SILVERLIGHT // Marshal.AllocHGlobal n'est pas supporté en SL

        /// <summary>
        /// Alloue la quantité spécifiée de mémoire non managée, et renvoie le pointeur obtenu
        /// sous forme d'un DisposablePointer.
        /// </summary>
        /// <param name="size">Quantité de mémoire à allouer</param>
        /// <returns>Un DisposablePointer représentant la zone mémoire allouée</returns>
        public static DisposablePointer AllocHGlobal(int size)
        {
            return new DisposablePointer(Marshal.AllocHGlobal(size), Marshal.FreeHGlobal);
        }
#endif

        /// <summary>
        /// Méthode d'extension qui crée un wrapper IDisposable pour un pointeur
        /// </summary>
        /// <param name="value">Le pointeur à wrapper</param>
        /// <param name="disposeAction">L'action à effectuer pour libérer la ressource</param>
        /// <returns>Un objet IDisposable qui wrappe le pointeur</returns>
        public static DisposablePointer AsDisposable(IntPtr value, Action<IntPtr> disposeAction)
        {
            return new DisposablePointer(value, disposeAction);
        }
    }
}