using System.Collections.Generic;

namespace Palettizer
{
	public class Palette
	{
		public Dictionary<byte, Color> GrayscaleToColorMap { get; }
		public Color[] GrayscaleToColor { get; }
        public Dictionary<Color, byte> ColorToGrayscaleMap { get; }
        public int GrayscaleCount { get; set; }
        public List<byte[]> AlternateColorRows { get; }

		public int Width { get => 256; }
		public int Height { get => AlternateColorRows.Count + 2; }

		public Palette()
		{
			GrayscaleToColorMap = new Dictionary<byte, Color>();
			ColorToGrayscaleMap = new Dictionary<Color, byte>();
            GrayscaleCount = 0;
            AlternateColorRows = new List<byte[]>();
		}

		public void AddColor(Color color)
		{
            var average = (color.R + color.G + color.B) / 3;
			if (GrayscaleToColorMap.ContainsKey((byte)average))
			{
                var increment = 1;
                for (var i = 0; i < 256 - GrayscaleCount; i += 1)
				{
                    average += increment;

					if (!GrayscaleToColorMap.ContainsKey((byte)average))
					{
                        break;
                    }

                    increment = ((increment > 0) ? (increment + 1) : (increment - 1)) * -1;
                }

            }

            GrayscaleToColorMap.Add((byte)average, color);
            ColorToGrayscaleMap.Add(color, (byte)average);
            GrayscaleCount += 1;
        }

		public void AddAlternateColorRow(Color[] colors)
		{
			var byteArray = new byte[256 * 4];

            for (var i = 0; i < 256; i += 1)
			{
                byteArray[i * 4] = colors[i].R;
                byteArray[i * 4 + 1] = colors[i].G;
                byteArray[i * 4 + 2] = colors[i].B;
                byteArray[i * 4 + 3] = colors[i].A;
            }

            AlternateColorRows.Add(byteArray);
		}

		public byte[] CreateIndexedPaletteBitmap()
		{
			var paletteBitmap = new byte[256 * (AlternateColorRows.Count + 2) * 4];

            for (var i = 0; i < 256; i += 1)
			{
                paletteBitmap[i * 4]     = (byte)i;
                paletteBitmap[i * 4 + 1] = (byte)i;
                paletteBitmap[i * 4 + 2] = (byte)i;
                paletteBitmap[i * 4 + 3] = 255;
            }

            for (var i = 0; i < 256; i += 1)
			{
                var color = new Color();
				if (GrayscaleToColorMap.ContainsKey((byte)i))
				{
                    color = GrayscaleToColorMap[(byte)i];
                }
                paletteBitmap[(256 + i) * 4]     = color.R;
                paletteBitmap[(256 + i) * 4 + 1] = color.G;
                paletteBitmap[(256 + i) * 4 + 2] = color.B;
                paletteBitmap[(256 + i) * 4 + 3] = color.A;
            }

            for (var i = 0; i < 256; i += 1)
			{
                for (var j = 0; j < AlternateColorRows.Count; j += 1)
				{
                    paletteBitmap[(i + (256 * (j + 2))) * 4]     = AlternateColorRows[j][i * 4];
                    paletteBitmap[(i + (256 * (j + 2))) * 4 + 1] = AlternateColorRows[j][i * 4 + 1];
                    paletteBitmap[(i + (256 * (j + 2))) * 4 + 2] = AlternateColorRows[j][i * 4 + 2];
                    paletteBitmap[(i + (256 * (j + 2))) * 4 + 3] = AlternateColorRows[j][i * 4 + 3];
                }
            }

			return paletteBitmap;
		}
	}
}