#pragma once
#ifndef BITMAPFILEHEADER_H_
#define BITMAPFILEHEADER_H_
#include <cstdint> // Helps gaurantee 32 bit ints for portability.
using namespace std;

#pragma pack(2) // Pre-proccessor directive which gets rid of any padding that C++ will automatically 
// add to the struct. Struct needs to look exactly as is otherwise there will be extra padding bytes.


namespace caveofprogramming
{
	struct BitmapFileHeader
	{
		char header[2]{ 'b','m' }; // Tells the app that opens this file that it's a bitmap file.
		int32_t fileSize;
		int32_t reserved{ 0 };
		int32_t dataOffSet; // Says how long into the fiel that data begins.

	};

}


#endif 

#pragma once
#ifndef BITMAPINFOHEADER_H_
#define BITMAPINFOHEADER_H_
#include <cstdint>
#pragma pack(2) // Gets rid of extra padding.

// Could use int or short, but int32_t gaurantees to be the right size.
namespace caveofprogramming {

	struct BitmapInfoHeader
	{
		int32_t headerSize{ 40 }; // Size of this struct
		int32_t width;
		int32_t height;
		int16_t planes{ 1 };
		int16_t bitsPerPixel{ 24 }; // 8x3=24 so there are 8 bytes per pixel.
		int32_t compression{ 0 }; // Set compression to 0 otherwise it becomes more complicated.
		int32_t dataSize{ 0 }; // Going to set size later. Good to initialize to 0 for now.
		int32_t horizontalResolution{ 2400 };
		int32_t verticalResolution{ 2400 };
		int32_t colors{ 0 };
		int32_t importantColors{ 0 };

		// If you get this wrong you won't find out until you try to write your bitmap and can't open it.
	};

}
#endif; 

#pragma once
#ifndef BITMAP_h_
#define BITMAP_h_

#include <string>
#include <cstdint>
#include <memory> // Needed for unique ptr
#include <iostream>
using namespace std;

namespace caveofprogramming
{ 
	class Bitmap
	{
	private:
		int m_width{ 0 };
		int m_height{ 0 };
		unique_ptr< uint8_t[] > m_pixels{ nullptr }; // Using a unique ptr allows us to avoid using the 
		// destructor to deallocate memory (unlike a regular ptr). This is a ptr to an area of memory
		// big enogh to hold all the pixels.

	public:
		Bitmap(int width, int height);
		bool write(string fileName);
		virtual ~Bitmap();
		void setPixel(int x, int y, uint8_t red, uint8_t green, uint8_t blue); // Unsigned 8 bit char 0 - 255.
			
	};
}



#endif; 

#include <iostream>
#include <fstream>
#include <cerrno>
#include <cstring>

int main(int arc, char **argv)
{
    std::ofstream file;
    file.open(argv[1], std::ios::in | std::ios::binary);
    if (!file) {
	std::cout << "Can't open " << argv[1] << ": " << strerror(errno) << '\n';
    }
}

#include <fstream>
#include <vector>
using namespace std;
#pragma pack(1) //if you do not do this your compiler may decide to inject padding
//which will break things badly.   you can also push and pop this to change it for a sec, 
//then revert to the default or current setting. 

struct bmphdr
{
  uint16_t bm{0x4d42};
  uint32_t thisfilesize{};
  uint32_t two16bitzeros{};
  uint32_t pixeladdr{};  
};

struct dibhdr //old school
{
  uint32_t forty{40};
  uint32_t widthpxls{};
  uint32_t heightpxls{};
  uint16_t one{1};
  uint16_t bpp{24}; //bits per pixel
  uint32_t comp{0};
  uint32_t rawsize{};
  uint32_t hres{2835};
  uint32_t vres{2835};
  uint32_t zero{};
  uint32_t zero2{};  
};

struct bmp
{
  bmphdr hdr;
  dibhdr dib;
  vector<uint8_t> pixels;
};

int main()
{
  bmp b;
  b.pixels.reserve(100*50*3);
  b.dib.widthpxls = 50;
  b.dib.heightpxls = 100;
  b.hdr.thisfilesize = sizeof(bmphdr)+sizeof(dibhdr)
                     + b.dib.widthpxls* b.dib.heightpxls*3;
  b.hdr.pixeladdr = sizeof(bmphdr)+sizeof(dibhdr);
  b.dib.rawsize = 100*50*3;
    
  for(int i = 0; i < 100*50*3; i++)
	b.pixels[i] = i*100+i>>3; //whatever image data here
  
  ofstream ofs("tst.bmp", ios::binary);
  ofs.write((char*)(&b.hdr), sizeof(bmphdr));
  ofs.write((char*)(&b.dib), sizeof(dibhdr));
  ofs.write((char*)&b.pixels[0], 3* b.dib.widthpxls* b.dib.heightpxls);
}

#include <iostream>
#include <fstream>
#include "bitmap.h"
#include "bitmapFileHeader.h"
#include "bitmapInfoHeader.h"

using namespace std;
using namespace caveofprogramming;

int main()
{
	int const WIDTH = 800;
	int const HEIGHT = 600;
	Bitmap bitmap(WIDTH, HEIGHT); // 800, 600 about standard screen resolution

	bitmap.setPixel(WIDTH / 2, HEIGHT / 2, 255, 255, 255);
	bitmap.write("test.bmp");

	cout << "Finished!" << endl;

}

#include <fstream>
#include "bitmap.h"
#include "bitmapInfoHeader.H"
#include "bitmapFileHeader.H"

#include <iostream>
#include <cstdint> // For unsigned 
using namespace std;

namespace caveofprogramming
{// Curly brackets at the end of m_pixels initiallizes it to all zero
	Bitmap::Bitmap(int width, int height) : m_width(width), m_height(height), m_pixels(new uint8_t[height * width * 3]{}) // Every pixel has 3 bytes
	{

	}

	// We're creating a bitmap, setting pixels in it and writing to it with this function.
	// Writing to files is errror prone, so we'll make it bool to return false if it does'nt work.
	bool Bitmap::write(string fileName)
	{
		BitmapFileHeader fileHeader;
		BitmapInfoHeader infoHeader;

		fileHeader.fileSize = sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + m_width * m_height * 3;

		// Distance from beginning of file to where data actually starts.
		fileHeader.dataOffSet = sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader);

		infoHeader.width = m_width;
		infoHeader.height = m_height;

		ofstream file;
		file.open(fileName, ios::out | ios::binary);

		if (!file) {
			cout << "File not open." << endl;
			return false;
		}
		

		// First arg always has to be a char star ptr to the address of the struct (or class).
		file.write((char*)&fileHeader, sizeof(fileHeader));
		file.write((char*)&infoHeader, sizeof(infoHeader));
		// Can't cast a unique ptr (m_pixels) to a char * so need the get() method to return it as a regular ptr.
		file.write((char*)m_pixels.get(), m_width*m_height*3);

		file.close();

		if (!file) {
			return false;
		}

		return true;
	}


	Bitmap::~Bitmap()
	{

	}

	// Allows us to set pixels in a bitmap to specify colors. There is one byte of info for each pixel.
	// x and y are used to specify a particular pixel.
	void Bitmap::setPixel(int x, int y, uint8_t red, uint8_t green, uint8_t blue) // Unsigned 8 bit char 0 - 255.
	{
		// Pointer to a particular pixel specified by x and y.
		uint8_t* pixel = m_pixels.get(); //Can't assign a unique pointer to a regualr pointer, but we can with the get() method.

		// y * m_width is th number of pixels in each byte (if each pixel is one byte) in all the rows before the 
		// one we are intersted in as specified by y. Once we get it in the right row, we then move it forward
		// to the correct column with x. Since each pixel is taking up 3 bytes we have to mult x and y by 3.
		// If we add the value one to this ptr that would move it forward by one byte.
		pixel += (y * 3) * m_width + (x * 3);

		// We can now use the array subscipts to reference the red, blue, and green bytes following the one 
		// that ptr "pixel" points at.
		pixel[0] = blue;
		pixel[1] = green;
		pixel[2] = red;

		// Hexadecimal number: FF for red, 88 for blue, 33 for green. Takes exactly 3 bytes; 3 digits for each number.
		// The last digits in a hexadecimal number represent the first area in memory.
		0xFF8833;



	}

}