using System;

namespace Quik.Media.Color
{
    public static class FormatConvert
    {
        public static void Premultiply(QImageLock image)
        {
            switch (image.Format)
            {
            case QImageFormat.RaF:
            case QImageFormat.RaU8:
            case QImageFormat.RgbF:
            case QImageFormat.RgbU8:
            case QImageFormat.RgbaF:
            case QImageFormat.RgbaU8:
                break;
            default:
                return;
            }

            int count = image.Width * image.Height * image.Depth;

            if (image.Format.IsFloat())
            {
                LockIOF io = new LockIOF(image);

                for (int i = 0; i < count; i++)
                {
                    QColorF color = io[i];

                    color.R *= color.A;
                    color.G *= color.A;
                    color.G *= color.A;

                    io[i] = color;
                }
            }
            else
            {
                LockIO io = new LockIO(image);

                for (int i = 0; i < count; i++)
                {
                    QColor color = io[i];
                    float a = color.A/255.0f;

                    color.R = (byte)(color.R * a);
                    color.G = (byte)(color.G * a);
                    color.B = (byte)(color.B * a);

                    io[i] = color;
                }
            }
        }

        public static void Convert(QImageLock dst, QImageLock src)
        {
            if (dst.Format.IsU8() && src.Format.IsU8())
            {
                LockIO dstIO = new LockIO(dst);
                LockIO srcIO = new LockIO(src);

                int count = dst.Width * dst.Height * dst.Depth;
                for (int i = 0; i < count; i++)
                {
                    dstIO[i] = srcIO[i];
                }
            }
            else if (dst.Format.IsU8() && src.Format.IsFloat())
            {
                LockIO dstIO = new LockIO(dst);
                LockIOF srcIO = new LockIOF(src);

                int count = dst.Width * dst.Height * dst.Depth;
                for (int i = 0; i < count; i++)
                {
                    dstIO[i] = (QColor)srcIO[i];
                }
            }
            else if (dst.Format.IsFloat() && src.Format.IsU8())
            {
                LockIOF dstIO = new LockIOF(dst);
                LockIO srcIO = new LockIO(src);

                int count = dst.Width * dst.Height * dst.Depth;
                for (int i = 0; i < count; i++)
                {
                    dstIO[i] = (QColorF)srcIO[i];
                }
            }
            else if (dst.Format.IsFloat() && src.Format.IsFloat())
            {
                LockIOF dstIO = new LockIOF(dst);
                LockIOF srcIO = new LockIOF(src);

                int count = dst.Width * dst.Height * dst.Depth;
                for (int i = 0; i < count; i++)
                {
                    dstIO[i] = srcIO[i];
                }
            }
            else
            {
                throw new Exception("Congratulations you have broken image formats!");
            }
        }
    }
}