/*

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

  Copyright (C) 2009-2010 Michael Möller <mmoeller@openhardwaremonitor.org>

*/

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.IO;

using System.Text;

namespace OpenHardwareMonitor.Utilities {

  public class IconFactory {

    private struct BITMAPINFOHEADER {

      public uint Size;

      public int Width;

      public int Height;

      public ushort Planes;

      public ushort BitCount;

      public uint Compression;

      public uint SizeImage;

      public int XPelsPerMeter;

      public int YPelsPerMeter;

      public uint ClrUsed;

      public uint ClrImportant;

      public BITMAPINFOHEADER(int width, int height, int bitCount) {

        this.Size = 40;

        this.Width = width;

        this.Height = height;

        this.Planes = 1;

        this.BitCount = (ushort)bitCount;

        this.Compression = 0;

        this.SizeImage = 0;

        this.XPelsPerMeter = 0;

        this.YPelsPerMeter = 0;

        this.ClrUsed = 0;

        this.ClrImportant = 0;

      }

      public void Write(BinaryWriter bw) {

        bw.Write(Size);

			  bw.Write(Width);

			  bw.Write(Height);

			  bw.Write(Planes);

			  bw.Write(BitCount);

			  bw.Write(Compression);

			  bw.Write(SizeImage);

			  bw.Write(XPelsPerMeter);

			  bw.Write(YPelsPerMeter);

			  bw.Write(ClrUsed);

			  bw.Write(ClrImportant);

      }

    }

    private struct ICONIMAGE {

      public BITMAPINFOHEADER Header;

      public byte[] Colors;

      public byte[] XOR;

      public byte[] AND;

      public ICONIMAGE(int width, int height, byte[] colors) {

        this.Header = new BITMAPINFOHEADER(width, height << 1, 

          (8 * colors.Length) / (width * height));

        this.Colors = colors;

        int maskSize = (width * height) >> 3;

        this.XOR = new byte[maskSize];

        this.AND = new byte[maskSize];

      }

      public void Write(BinaryWriter bw) {

        Header.Write(bw);

        int stride = Header.Width << 2;

        for (int i = (Header.Height >> 1) - 1; i >= 0; i--)

          bw.Write(Colors, i * stride, stride);

        bw.Write(XOR);        

        bw.Write(AND);

      }

    }

    private struct ICONDIRENTRY {

      public byte Width;

      public byte Height;

      public byte ColorCount;

      public byte Reserved;

      public ushort Planes;

      public ushort BitCount;

      public uint BytesInRes;

      public uint ImageOffset;

      public ICONDIRENTRY(ICONIMAGE image, int imageOffset) {

        this.Width = (byte)image.Header.Width;

        this.Height = (byte)(image.Header.Height >> 1);

        this.ColorCount = 0;

        this.Reserved = 0;

        this.Planes = image.Header.Planes;

        this.BitCount = image.Header.BitCount;

        this.BytesInRes = (uint)(image.Header.Size +

          image.Colors.Length + image.XOR.Length + image.AND.Length);

        this.ImageOffset = (uint)imageOffset;

      }

      public void Write(BinaryWriter bw) {

        bw.Write(Width);

        bw.Write(Height);

        bw.Write(ColorCount);

        bw.Write(Reserved);

        bw.Write(Planes);

        bw.Write(BitCount);

        bw.Write(BytesInRes);

        bw.Write(ImageOffset);

      }

      public uint Size {

        get { return 16; }

      }

    }

    private struct ICONDIR {

      public ushort Reserved;

      public ushort Type;

      public ushort Count;

      public ICONDIRENTRY[] Entries;

      public ICONDIR(ICONDIRENTRY[] entries) {

        this.Reserved = 0;

        this.Type = 1;

        this.Count = (ushort)entries.Length;

        this.Entries = entries;

      }

      public void Write(BinaryWriter bw) {

        bw.Write(Reserved);

        bw.Write(Type);

        bw.Write(Count);

        for (int i = 0; i < Entries.Length; i++)

          Entries[i].Write(bw);

      }

      public uint Size {

        get { return (uint)(6 + Entries.Length * 

          (Entries.Length > 0 ? Entries[0].Size : 0)); } 

      }

    }

    public static Icon Create(byte[] colors, int width, int height, 

      PixelFormat format) {

      if (format != PixelFormat.Format32bppArgb)

        throw new NotImplementedException();

      ICONIMAGE image = new ICONIMAGE(width, height, colors);

      ICONDIR dir = new ICONDIR(

        new ICONDIRENTRY[] { new ICONDIRENTRY(image, 0) } );

      dir.Entries[0].ImageOffset = dir.Size;

      Icon icon;

      using (BinaryWriter bw = new BinaryWriter(new MemoryStream())) {

				dir.Write(bw);

        image.Write(bw);

				bw.BaseStream.Position = 0;

        icon = new Icon(bw.BaseStream);

			}

      return icon;

    }

  }

}