//#include "iostream"
#include <signal.h>
#include <sys/stat.h>
#include "mman.h"
#include <fcntl.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#include "winbase.h"
#include "string.h"
#include "stdbool.h"
#include "ecc-sw.h"
#include <stdint.h>
#include "string.h"
#include <locale.h>
#include <inttypes.h>
#include <limits.h>
#include <malloc.h>
//#include "unistd.h"
#include <sys/types.h>
#include <float.h>
#include <stddef.h>
#include <inttypes.h>
#include "bch.h"
//#include "linuxtypes.h"
//#include <uapi_linux_types.h>
#include <math.h>
#include "bch_global.c"
//#include <linux/module.h>
//#include <linux/mtd/nand.h>
//#include <linux/mtd/nand-ecc-sw-hamming.h>
//#include <linux/slab.h>
//#include <asm/byteorder.h>
//#ifndef STANDALONE


enum
{
	no_error,
	error_file_open_fail,
	error_mem_alloc,
	error_file_read_error
};

#define inputfile "Dump.bin" // Nand Dump.bin

#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE
#define _FILE_OFFSET_BITS 64
#define mem_size 65536
#define mem_size_block 135168
#define mem_size_page 2112
#define bytes 4096
#define ESC 27
#define uninitialized_var(x) x = x


int main(int argc, unsigned char** argv) {
	setlocale(LC_ALL, "de_DE.UTF-8");
	system("cls");  // Display leeren
	// Kopf
	printf("************************************************************************************************************\n");
	printf("***************************************Nand Tool - BCH ECC Code*********************************************\n");
	printf("************************************************************************************************************\n");
	printf("************************************************************************************************************\n\n");
	printf("***** Bitte legen Sie das Programm XXXX.exe und die Datei <Dump.bin> in den ECC-Ordner der Festplatte C*****\n");
	printf("************************************************************************************************************\n\n");

	/* Nand Flash Geometrie */



	int Page_without_Spare, Spare, Bloks_per_Device, Block_size, Pages_per_Device, Page_with_Spare;
	int bytes_ecc;
	int size;
	long long offset_main, offset_spare, pos, pos_block, pos_page, pos_spare, spare_to_ecc, pos_ecc;
	int eccsize;
	//char buffer_name[64];
	long long Blocksize_in_Bytes, x;
	int z, y, step_per_page;
	z = 0;
	x = 0;
	y = 0;
	size = 1;
	//uint8_t Buf_In, Buf_In1;
	//p = 0;
	pos = 0;
	pos_spare = 0;
	pos_page = 0;
	//bytes_data = 256;
	spare_to_ecc = 8;
	bytes_ecc = 13;
	eccsize = 512;
	offset_main = 4;
	offset_spare = 6;

	//uint32_t bp;
	//uint32_t u32;

	//printf("Hallo\n");

		/* Eingaben */
	printf("\n");
	printf("Geben Sie den Parameter an <Page Size without Spare> in <Bytes> : \n");
	scanf("%d", &Page_without_Spare);

	step_per_page = Page_without_Spare / eccsize;
	pos_ecc = offset_main + eccsize;

	printf("Geben Sie den Parameter an <Spare Size> in <Bytes> : \n");
	scanf("%d", &Spare);

	printf("Geben Sie den Parameter an <Block size> in <Pages> : \n");
	scanf("%d", &Block_size);

	printf("\n");
	Page_with_Spare = Page_without_Spare + Spare;


	// Berechnen Dateigroesse in Bites */
	off64_t fileSize = 0;
	FILE* f = fopen64(inputfile, "rb");
	if (f == NULL) {
		printf("Datei-Öffnungsfehler\n");
		//_getch();
		//system("pause");
		printf("Bestätigen Sie mit einer beliebigen Taste.");
		return 0;
		//exit(0);
	}
	fseeko64(f, 0, SEEK_END);
	fileSize = ftello64(f);
	fclose(f);


	printf("\nZusaetzliche Datei-Informationen:");
	printf("Komplette Dateigroesse <Dump.bin>: %lld Bytes\n", fileSize);
	// ********************** */

	printf("Parameter <Page Size with Spare>: %d Bytes\n", Page_with_Spare);
	printf("Parameter <step_per_page>: %d Bytes\n", step_per_page);
	//n = fileSize / Page_with_Spare;
	//Blocksize_in_Bytes = Page_with_Spare * Block_size;
	//printf("Die Blockgröße in Byte ist gleich: %lld Bytes\n", Blocksize_in_Bytes);

	//SizeMain = n * Page_without_Spare;
	//SizeSpare = n * Spare;

	Bloks_per_Device = fileSize / Blocksize_in_Bytes;
	printf("Anzahl <Block per Device>: %d Blocks\n", Bloks_per_Device);

	Pages_per_Device = fileSize / Page_with_Spare;

	printf("Anzahl der Seiten pro Device <Pages per Device>: %d Pages\n\n", Pages_per_Device);

	/* Zuweisung von Speicherplatz für Block */
	uint8_t* block_buf = malloc(mem_size_block); /* Buffer fuer Daten pro 1 Block */
	if (block_buf) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}

	/* Zuweisung von Speicherplatz für Page */
	uint8_t* page_buf = malloc(mem_size_page); /* Buffer fuer Daten pro 1 Page komplett mit Spare */
	if (page_buf) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}

	/* Zuweisung von Speicherplatz für Page */
	uint8_t* buf_bp = malloc(eccsize); /* Zwischenbuffer fuer Daten 512 Bytes pro eccsize */
	if (buf_bp) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}

	/* Zuweisung von Speicherplatz für Berechnungsblock */
	uint32_t* bp = malloc(eccsize); /* Buffer fuer Daten 512 Bytes pro eccsize */
	if (bp) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}

	/* Zuweisung von Speicherplatz für ECC*/
	unsigned char* code = malloc(mem_size); /* Buffer fuer Daten ECC 13 Bytes, aus Dump */
	if (code) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}

	/* Zuweisung von Speicherplatz für ECC*/
	uint32_t* buf_ecc = malloc(mem_size); /* Buffer fuer berechnete ECC 13 Bytes, */
	if (buf_ecc) {
		printf("");
	}
	else {
		printf("Allocation Error.\n");
		return 1;
	}


	// Lesen der Datei */
	FILE* in = fopen64("C:/ECC/Dump.bin", "rb");
	if (in == NULL) {
		printf("Datei-Oeffnungsfehler\n");
		//system("pause");
		printf("Bestaetigen Sie mit einer beliebigen Taste.");
		return 0;
		//exit(0);
	}

	// Anlegen einer Datei */
	FILE* out = fopen64("C:/ECC/Dump_New.bin", "wb");
	if (in == NULL) {
		printf("Datei-Oeffnungsfehler\n");
		system("pause");
		exit(1);
	}

	while (z != 1) {
		fseeko64(in, pos, SEEK_SET); /* Position mit Offset in der eingelesenen Datei */
		fread(block_buf, fileSize, 1, in); /* Daten werden in den Buffer block_buf uebergeben */

		pos_block = 0;
		while (x < Pages_per_Device) {
			
			memcpy((uint8_t*)page_buf, (uint8_t*)block_buf + pos_block, Page_with_Spare); /* Daten werden in den Buffer page_buf kopiert */
		
			pos_page = offset_main;
			
			while (y < step_per_page) {
				
				if (y == step_per_page - 1) {
					memcpy((uint8_t*)buf_bp, (uint8_t*)page_buf + (offset_main+ (eccsize+ bytes_ecc)*y), 469); /* Daten mit offset werden in den Buffer buf_bp kopiert */
					memcpy((uint8_t*)buf_bp + 469, (uint8_t*)page_buf + (offset_main + (eccsize + bytes_ecc) * y +469 +6), 43); /* Daten mit offset werden in den Buffer buf_bp kopiert */
					memcpy((uint8_t*)code, (uint8_t*)page_buf + (offset_main + (eccsize + bytes_ecc) * y + 469 + 6 + 43), bytes_ecc); /* Daten mit offset werden in den Buffer code kopiert */


					goto weiter;

				}

				memcpy((uint8_t*)buf_bp, (uint8_t*)page_buf + pos_page, eccsize); /* Daten mit offset werden in den Buffer buf_bp kopiert */
				memcpy((uint8_t*)code, (uint8_t*)page_buf + pos_ecc, bytes_ecc); /* Daten mit offset werden in den Buffer code kopiert */

weiter:

				printf("\n");
				printf("Datablock %d je 512 Bytes fuer ECC Berechnung.\n", y);
				printf("Offset Datablock: %d \n", pos_page);
				//_getch();

				printf("\n");

				printf("Buffer buf_bp0-buf_bp3: %X %X %X %X \n", buf_bp[0], buf_bp[1], buf_bp[2], buf_bp[3]);
				printf("Buffer buf_bp465-buf_bp468: %X %X %X %X \n", buf_bp[465], buf_bp[466], buf_bp[467], buf_bp[468]);

				printf("Buffer buf_bp469-buf_bp473: %X %X %X %X  \n", buf_bp[469], buf_bp[470], buf_bp[471], buf_bp[472]);
				printf("Buffer buf_bp508-buf_bp511: %X %X %X %X  \n", buf_bp[508], buf_bp[509], buf_bp[510], buf_bp[511]);

				printf("\n");
				printf("\n");
				_getch();

				y = y + 1;
				pos_page = pos_page + eccsize + bytes_ecc;
				pos_ecc = pos_ecc + eccsize + bytes_ecc;
				
							
			}

			if (y == step_per_page) {
				y = 0;
				//printf("Nulen yyyyyyyyyyyyyyyyyy  %d \n", y);
			}
			x = x + 1;
			pos_block = pos_block + Page_with_Spare;
			
		}




		//t = t + Page_with_Spare;
		//pos = pos + Blocksize_in_Bytes;
		z = z + 1;
		//printf("\n");
		//printf("Offset pos in Page zzzzzzzzzzzzzzzz  %d \n", z);
		//_getch();
	}

	free(block_buf);
	block_buf = NULL;

	free(page_buf);
	page_buf = NULL;

	free(buf_bp);
	buf_bp = NULL;

	free(bp);
	bp = NULL;

	free(code);
	code = NULL;

	free(buf_ecc);
	buf_ecc = NULL;

	fclose(in);
	//fclose(out);
	printf("\nErledigt. Druecken Sie eine beliebige Taste.");
	_getch();
	//system("pause>nul");
	return 0;

}