#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

#pragma pack(push,1) // alignment
// BMP file header
struct BMPHeader {
	uint16_t file_type{ 0 };	// type of the file, for BMP should be 0x4D42
	uint32_t file_size{ 0 };	// size of the files in bytes
	uint16_t reserved_1{ 0 };	// reserved
	uint16_t reserved_2{ 0 };	// reserved
	uint32_t offset{ 0 };		// offset for pixel data from beginning of file
};
// info
struct DIBHeader {
	uint32_t size{ 0 };		// size of DIB-header in bytes
	int32_t width{ 0 };		// width in pixels
	int32_t height{ 0 };		// height in pixels

	uint16_t planes{ 1 };		// number of color planes used
	uint16_t bit_count{ 0 };	// number of bits per pixel
	uint32_t compression{ 0 };	// compression
	uint32_t size_image{ 0 };	// size of the raw bitmap data (including padding)

	int32_t x_pixels_per_meter{ 0 };	// horizontal resolution of the image (pixel per meter, signed int)
	int32_t y_pixels_per_meter{ 0 };	// vertical resolution of the image (pixel per meter, signed int)
	uint32_t colors_used{ 0 };		// number of colors in the color palette    
	uint32_t colors_important{ 0 };		// number of important colors used
};
// mask for colors
struct BMPColorHeader {
	uint32_t red_mask{ 0x00FF0000 };         // bit mask for the red channel
	uint32_t green_mask{ 0x0000FF00 };       // bit mask for the green channel
	uint32_t blue_mask{ 0x000000FF };        // bit mask for the blue channel
	uint32_t alpha_mask{ 0xFFF000000 };       // bit mask for the alpha channel
	uint32_t color_space_type{ 0x73524742 }; // default "sRGB" (0x73524742)
	uint32_t unused[16]{ 0 };                // unused data for sRGB color space
};
#pragma pack(pop)

struct BMP {

	BMPHeader file_header;
	DIBHeader dib_header;
	BMPColorHeader bmp_color_header;
	vector<uint32_t> data; // data

	gck::Sprite* read(const string filename)
	{	// read file
		ifstream f{ filename, ios_base::binary };

		if (f)
		{
			f.read((char*)&file_header, sizeof(file_header));
			// bad file
			if (file_header.file_type != 0x4D42)
				throw runtime_error("Error! Not BMP file");

			f.read((char*)&dib_header, sizeof(dib_header));
			// resize vector to total number of pixels
			data.resize(dib_header.width * dib_header.height);
			// jump to pixel data location
			f.seekg(file_header.offset, f.beg);

			int bBit;
			// how many bits
			switch (dib_header.bit_count)
			{
			case 24: // 24 bits (no alpha)
				bBit = 3;
				break;
			case 32: // 32 bits (with alpha)
				bBit = 4;
				break;
			default:
				throw runtime_error("Error! Only 24 and 32 bits are supported!");
			}
			// store data in data
			for (size_t i = 0; i < dib_header.width * dib_header.height; i++)
			{	// minimal base
				uint32_t pixel{ NULL };
				f.read((char*)&pixel, bBit);
				data[i] = pixel; // store pixel
			}

			gck::Sprite* spr = nullptr;
			spr = new gck::Sprite(dib_header.width, dib_header.height);

			for (int x = 0; x < dib_header.width; x++)
				for (int y = 0; y < dib_header.height; y++)
					spr->SetPixel(gck::vi2d(x, y), gck::Pixel(x, y, data[y * dib_header.width + x]));

			return spr;
		}
	}
};