#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

#include "turbo_code_Log_MAP.h"
#include "other_functions.h"

#define FRAME_LENGTH	320

extern float rate_coding;
extern TURBO_G turbo_g;

void main()
{
/*-----------------------------------------------------------------*/
	int *trafficflow_source = NULL;
	float *coded_trafficflow_source = NULL;
	int traffic_source_length;

	float *trafficflow_for_decode = NULL;
	int *trafficflow_decoded = NULL;
	int trafficflow_length;

	int *supflow_source = NULL;
	float *coded_supflow_source = NULL;
	int supflow_source_length;

	float *supflow_for_decode = NULL;
	int *supflow_decoded = NULL;
	int supflow_length;

	float EbN0dB = 0;

	float en, sgma;

//	double Eb_N0_dB[8] = {0.0, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05};
//	double Eb_N0_dB[8] = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4};
	double Eb_N0_dB[8] = {0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75};
//	double Eb_N0_dB[8] = {0.0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1};
//	double Eb_N0_dB[8] = {0.0, 0.4, 0.8, 1.2, 1.6, 2.0, 2.4, 2.8};

//	int error_limit[8] = {20000, 10000, 5000, 2000, 1000, 800, 600, 300};
//	int error_limit[8] = {5000, 3000, 2000, 1000, 500, 300, 200, 100};
//	int error_limit[8] = {1000, 1000, 500, 300, 200, 100, 50, 20};
	int error_limit[8] = {500, 500, 300, 200, 100, 50, 20, 2};


	int err_bit_num_traffic[8];
	float err_bit_rate_traffic[8];

	int err_bit_num_sup[8];
	float err_bit_rate_sup[8];

	clock_t start, end;

	int i, j, nf, ien;

	FILE *stream;	/* point to "simu_report.txt" which is used to record the results */

	if ((trafficflow_source=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_source \n");
	  exit(1);  
	}
	if ((coded_trafficflow_source=(float *)malloc(2*FRAME_LENGTH*sizeof(float)))==NULL)
	{
	  printf("\n fail to allocate memory of coded_trafficflow_source \n");
	  exit(1);  
	}

	if ((trafficflow_for_decode=(float *)malloc(2*FRAME_LENGTH*sizeof(float)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_for_decode \n");
	  exit(1);  
	}
	if ((trafficflow_decoded=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_decoded\n");
	  exit(1);  
	}

	if ((supflow_source=(int *)malloc(320*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of supflow_source \n");
	  exit(1);  
	}
	if ((coded_supflow_source=(float *)malloc(640*sizeof(float)))==NULL)
	{
	  printf("\n fail to allocate memory of coded_supflow_source \n");
	  exit(1);  
	}

	if ((supflow_for_decode=(float *)malloc(640*sizeof(float)))==NULL)
	{
	  printf("\n fail to allocate memory of supflow_for_decode\n");
	  exit(1);  
	}
	if ((supflow_decoded=(int *)malloc(320*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of supflow_decoded\n");
	  exit(1);  
	}

	if ((stream=fopen( "simu_report.txt", "w" )) == NULL)
    {
	  printf("\nError! Can not open file simu_report.txt\n");
	  exit(1);
    }
	traffic_source_length = FRAME_LENGTH;
/*-----------------------------------------------------------------*/	
/*-----------------------------------------------------------------*/
	TurboCodingInit();
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/	
	for (ien=0; ien<8; ien++)
	{
		EbN0dB = (float)Eb_N0_dB[ien];
		
		en = (float)pow(10,(EbN0dB)/10);
		sgma = (float)(1.0/sqrt(2*rate_coding*en));
		
		err_bit_num_traffic[ien] = 0;
		err_bit_num_sup[ien] = 0;
		
		err_bit_rate_traffic[ien] = 0.0;
		err_bit_rate_sup[ien] = 0.0;
		
		/*====   output the simulation parameters	=====*/
		/*	to screen	*/
		printf("/*=================================*/\n");
		printf("Turbo code simulation:\n");
		printf("/*=================================*/\n");
		printf("====log map decoder====\n");
		printf("frame length : %d \n", traffic_source_length);
		printf("g = \n");
		for (i=0; i<turbo_g.N_num_row; i++)
		{
			for (j=0; j<turbo_g.K_num_col; j++)
			{
				printf("%d ", *(turbo_g.g_matrix+i*turbo_g.K_num_col+j));
			}
			printf("\n");
		}
		printf("Eb/N0 = %f \n", EbN0dB);
		if (TURBO_PUNCTURE)
		{
			printf("punctured to rate 1/2\n");
		}
		else
		{
			printf("unpunctured\n");
		}
		printf("iteration number : %d \n", N_ITERATION);
		printf("/*=================================*/\n");

		/*	to "simu_report.txt"	*/
		fprintf(stream, "/*=================================*/\n");
		fprintf(stream, "Turbo code simulation:\n");
		fprintf(stream, "/*=================================*/\n");
		fprintf(stream, "====log map decoder====\n");
		fprintf(stream, "frame length : %d \n", traffic_source_length);
		fprintf(stream, "g = \n");
		for (i=0; i<turbo_g.N_num_row; i++)
		{
			for (j=0; j<turbo_g.K_num_col; j++)
			{
				fprintf(stream, "%d ", *(turbo_g.g_matrix+i*turbo_g.K_num_col+j));
			}
			fprintf(stream, "\n");
		}
		fprintf(stream, "Eb/N0 = %f \n", EbN0dB);
		if (TURBO_PUNCTURE)
		{
			fprintf(stream, "punctured to rate 1/2\n");
		}
		else
		{
			fprintf(stream, "unpunctured\n");
		}
		fprintf(stream, "iteration number : %d \n", N_ITERATION);
		fprintf(stream, "/*=================================*/\n");
		/*=================================================================*/


		for (nf=0; err_bit_num_traffic[ien]<error_limit[ien]; nf++)
		//for (nf=0; nf<20; nf++)
		{
			start=clock();

			traffic_source_length = FRAME_LENGTH;
			supflow_source_length = 320;

			gen_source(trafficflow_source, traffic_source_length);
			gen_source(supflow_source, supflow_source_length);
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
			TurboCodingTraffic(trafficflow_source, coded_trafficflow_source, &traffic_source_length);
			TurboCodingSupflow(supflow_source, coded_supflow_source, &supflow_source_length);
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/

			AWGN(coded_trafficflow_source, trafficflow_for_decode, sgma, 2*FRAME_LENGTH);
			AWGN(coded_supflow_source, supflow_for_decode, sgma, 640);

			trafficflow_length = 2*FRAME_LENGTH;
			supflow_length = 640;
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
			TurboDecodingTraffic(trafficflow_for_decode, trafficflow_decoded, &trafficflow_length, EbN0dB);
			TurboDecodingSupflow(supflow_for_decode, supflow_decoded, &supflow_length, EbN0dB);
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
			printf("%d %s", nf+1, "frames transmitted\n");

			end=clock();
		    printf( "\n%5f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);

			for (i=0; i<FRAME_LENGTH; i++)
			{
				if (*(trafficflow_source+i) != *(trafficflow_decoded+i))
				{
					err_bit_num_traffic[ien] = err_bit_num_traffic[ien]+1;
				}
			}
			for (i=0; i<320; i++)
			{
				if (*(supflow_source+i) != *(supflow_decoded+i))
				{
					err_bit_num_sup[ien] = err_bit_num_sup[ien]+1;
				}
			}
		}
		
		err_bit_rate_traffic[ien] = (float)err_bit_num_traffic[ien]/(nf*FRAME_LENGTH);
		err_bit_rate_sup[ien] = (float)err_bit_num_sup[ien]/(nf*320);

	}
	
	for (i=0; i<8; i++)
	{
		printf("%d ",err_bit_num_traffic[i]);
	}
	printf("\n");
	for (i=0; i<8; i++)
	{
		printf("%f ",err_bit_rate_traffic[i]);
	}
	printf("\n");

	for (i=0; i<8; i++)
	{
		printf("%d ",err_bit_num_sup[i]);
	}
	printf("\n");
	for (i=0; i<8; i++)
	{
		printf("%f ",err_bit_rate_sup[i]);
	}

/*-----------------------------------------------------------------*/	
/*-----------------------------------------------------------------*/	
	TurboCodingRelease();
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/	

	fclose(stream);

	free(trafficflow_source);
	free(coded_trafficflow_source);

	free(trafficflow_for_decode);
	free(trafficflow_decoded);

	free(supflow_source);
	free(coded_supflow_source);

	free(supflow_for_decode);
	free(supflow_decoded);
}