#include "IO.h"

#include "Assembleur.h"
#include <algorithm>
#include <bitset>
#include <cstring>
#include <fstream>
#include <iomanip>

static std::uint32_t reverseInt(std::uint32_t a_Int) {
	std::uint32_t result = 0;
	for (int i = 0; i < 32; i++) {
		result |= a_Int & 0x1;
		result <<= 1;
		a_Int >>= 1;
	}
	return result;
}

static void reverseDataByte(BinaryData& a_Data) {
	for (std::uint32_t& element : a_Data) {
		element = reverseInt(element);
	}
}

BinaryData ParseFile(const std::string& fileName) {
	std::ifstream file{fileName};
	std::uint32_t lineNumber = 0, realLineNumber = 0;
	std::string currentLine;

	std::vector<std::string> lines;

	Assembleur assembleur;

	BinaryData output;

	// parsing labels
	while (getline(file, currentLine)) {
		lines.push_back(currentLine);
		lineNumber++;
		realLineNumber++;

		if (currentLine.find(":") != std::string::npos) {
			std::string label = currentLine.substr(0, currentLine.size() - 1);
			assembleur.AddLabel(label, lineNumber);
			lineNumber--;
		}
	}

	lineNumber = realLineNumber = 0;

	// parsing instructions
	for (std::string line : lines) {
		lineNumber++;
		realLineNumber++;

		if (line.find(":") == std::string::npos) {
			output.push_back(assembleur.ParseInstruction(line, lineNumber, realLineNumber));
		} else {
			lineNumber--;
		}
	}

	return output;
}

void OutputFileBinary(BinaryData& a_Data, const std::string& fileName, bool a_Reverse) {
	std::ofstream file{fileName};
	if (a_Reverse)
		reverseDataByte(a_Data);
	file.write(reinterpret_cast<const char*>(a_Data.data()), a_Data.size() * sizeof(a_Data.at(0)));
}

void OutputFileIntegers(BinaryData& a_Data, const std::string& fileName, bool a_Reverse) {
	std::ofstream file{fileName};
	if (a_Reverse)
		reverseDataByte(a_Data);
	for (std::uint32_t number : a_Data) {
		file << number << "\n";
	}
}

void OutputFileBinIntegers(BinaryData& a_Data, const std::string& fileName, bool a_Reverse) {
	std::ofstream file{fileName};
	if (a_Reverse)
		reverseDataByte(a_Data);
	for (std::uint32_t number : a_Data) {
		file << std::bitset<8>(number >> 24) << " " << std::bitset<8>(number >> 16) << " " << std::bitset<8>(number >> 8) << " "
			 << std::bitset<8>(number) << "\n";
	}
}

void OutputFileLogisim(BinaryData& a_Data, const std::string& fileName, const std::string& a_Header, bool a_Reverse) {
	std::ofstream file{fileName};
	file << a_Header << "\n";
	std::uint64_t cursor = 0;
	if (a_Reverse)
		reverseDataByte(a_Data);
	for (std::uint32_t number : a_Data) {
		if (cursor % 8 == 0) {
			file << std::setfill('0') << std::setw(4) << std::hex << cursor << std::dec << ": ";
			file << std::bitset<8>(number >> 24) << " " << std::bitset<8>(number >> 16) << " " << std::bitset<8>(number >> 8) << " "
				 << std::bitset<8>(number) << " ";
		} else {
			file << std::bitset<8>(number >> 24) << " " << std::bitset<8>(number >> 16) << " " << std::bitset<8>(number >> 8) << " "
				 << std::bitset<8>(number) << "\n";
		}
		cursor += 4;
	}
}