using System;
using System.Drawing;
using System.Drawing.Imaging;

namespace Developpez.Dotnet.Drawing
{
    /// <summary>
    /// Permet l'accès direct et rapide aux pixels d'une image.
    /// Pour obtenir une instance de cette classe, utilisez la méthode <see cref="BitmapExtensions.LockPixels(Bitmap, Rectangle, ImageLockMode)"/>.
    /// </summary>
    /// <remarks>
    /// Cette classe offre des fonctionnalités similaires à <see cref="System.Drawing.Imaging.BitmapData"/>, avec les différences suivantes:
    /// <list type="bullet">
    /// <item>PixelData implémente IDisposable ; l'appel à Dispose (explicitement ou via l'instruction using) libère les pixels verrouillés avec LockPixels.</item>
    /// <item>PixelData fournit un indexeur pour obtenir ou définir facilement la couleur d'un pixel</item>
    /// <item>PixelData ne supporte qu'un seul format de pixel : <see cref="System.Drawing.Imaging.PixelFormat.Format32bppArgb"/></item>
    /// </list>
    /// </remarks>
    public sealed class PixelData : IDisposable
    {
        private readonly Bitmap _bitmap;
        private readonly BitmapData _data;
        private readonly int _pixelSize;

        internal PixelData(Bitmap bitmap, Rectangle rect, ImageLockMode flags)
        {
            if (bitmap == null)
                throw new ArgumentNullException("bitmap");
            _bitmap = bitmap;
            _data = bitmap.LockBits(rect, flags, PixelFormat.Format32bppArgb);
            _pixelSize = _data.Stride / _data.Width;
        }

        /// <summary>
        /// Libère les pixels verrouillés par LockPixels
        /// </summary>
        public void Dispose()
        {
            _bitmap.UnlockBits(_data);
        }

        /// <summary>
        /// Obtient l'adresse des premières données en pixels dans la bitmap. Cela peut également être représenté comme la première ligne de numérisation dans la bitmap.
        /// </summary>
        public IntPtr Scan0
        {
            get { return _data.Scan0; }
        }

        /// <summary>
        /// Obtient la largeur de numérisation de l'objet Bitmap.
        /// </summary>
        public int Stride
        {
            get { return _data.Stride; }
        }

        /// <summary>
        /// Obtient la largeur en pixels de l'objet Bitmap. Cela peut également être représenté comme le nombre de pixels dans une ligne de numérisation.
        /// </summary>
        public int Width
        {
            get { return _data.Width; }
        }

        /// <summary>
        /// Obtient la hauteur en pixels de l'objet Bitmap. Il y est également parfois fait référence en tant que nombre de lignes de numérisation.
        /// </summary>
        public int Height
        {
            get { return _data.Height; }
        }

        /// <summary>
        /// Obtient ou définit le format des informations en pixels dans l'objet Bitmap qui a retourné cet objet PixelData.
        /// </summary>
        public PixelFormat PixelFormat
        {
            get { return _data.PixelFormat; }
        }

        /// <summary>
        /// Obtient ou définit la couleur du pixel aux coordonnées spécifiées
        /// </summary>
        /// <param name="x">Position horizontale du pixel</param>
        /// <param name="y">Position verticale du pixel</param>
        /// <returns>La couleur du pixel</returns>
        public unsafe Color this[int x, int y]
        {
            get
            {
                byte* ptr = GetPixelPointer(x, y);
                return Color.FromArgb(ptr[3], ptr[2], ptr[1], ptr[0]);
            }
            set
            {
                byte* ptr = GetPixelPointer(x, y);
                ptr[0] = value.B;
                ptr[1] = value.G;
                ptr[2] = value.R;
                ptr[3] = value.A;
            }
        }

        private unsafe byte* GetPixelPointer(int x, int y)
        {
            x.CheckArgumentOutOfRange("x", 0, Width - 1);
            y.CheckArgumentOutOfRange("y", 0, Height - 1);
            int offset = y * _data.Stride + x * _pixelSize;
            return ((byte*)_data.Scan0) + offset;
        }
    }
}