#include "BetterBootstrapping.h"

/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
//Function Declarations:

void ReadDates(int NoDates, char *DatesFile, int *Dates);
void ReadParams(char *ParamFile, double *kappa_opt, double *eta_opt);
void CalcVarianceMat(int NoDates, int *Dates, double kappa, double eta, double **matrix);
//void CalcVarianceMatContinuous(int NoDates, int *Dates, double kappa, double eta, 
//							   double **matrix);	
	double weibullPDF(double x, double kappa, double eta);
	double weibull(double t, double kappa, double eta);
void SampleKappaEta(int i, double kappa_opt, double eta_opt, double **matrix, double *kappa, 
					double *eta);
double CalcNeg2LogLikelihood(int NoDates, int *Dates, double kappa, double eta);
void OutputKappaEta(int SampleSize, char *OutFile, double *kappa, double *eta, 
					double *neg2lnL);

/*-------------------------------------------------------------------------------------------*/
//Global variables:

long seed, rcount;
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	char DatesFile[255], ParamFile[255], OutFile[255];
	int NoDates, *Dates;
	double kappa_opt, eta_opt;
	double **variance_matrix;
	int SampleSize;
	double *kappa, *eta, *neg2lnL;
	int i;

	if(argc<7) 
		ERR_CRITICAL(
		"Syntax: <NoDates> <DatesFile> <ParamFile> <OutFile> <SampleSize> <seed>.\n");
	sscanf_s(argv[1], "%d", &NoDates);
	sscanf_s(argv[2], "%s", DatesFile, sizeof(DatesFile));
	sscanf_s(argv[3], "%s", ParamFile, sizeof(ParamFile));
	sscanf_s(argv[4], "%s", OutFile, sizeof(OutFile));
	sscanf_s(argv[5], "%d", &SampleSize);
	sscanf_s(argv[6], "%d", &seed);

	if(seed>0) seed=-seed;
	if(seed==0) {
		seed=(long)time(NULL);
		if(seed>0) seed=-seed;
	}
	ran3(&seed);

	if( (variance_matrix=dmatrix(0, 2, 0, 2))==0 )
		ERR_CRITICAL("main: Unable to allocate memory for variance_matrix.\n");
	if( (Dates=(int *) calloc(NoDates, sizeof(int)))==0 )
		ERR_CRITICAL("main: Unable to allocate memory for Dates.\n");
	if( (kappa=(double *) calloc(SampleSize, sizeof(double)))==0 )
		ERR_CRITICAL("main: Unable to allocate memory for kappa.\n");
	if( (eta=(double *) calloc(SampleSize, sizeof(double)))==0 )
		ERR_CRITICAL("main: Unable to allocate memory for eta.\n");
	if( (neg2lnL=(double *) calloc(SampleSize, sizeof(double)))==0 )
		ERR_CRITICAL("main: Unable to allocate memory for neg2lnL.\n");


	ReadDates(NoDates, DatesFile, Dates);
	ReadParams(ParamFile, &kappa_opt, &eta_opt);
	CalcVarianceMat(NoDates, Dates, kappa_opt, eta_opt, variance_matrix);

	printf("Variance matrix:\n\t%lg\t%lg\n\t%lg\t%lg\n", 
		variance_matrix[0][0], variance_matrix[1][0], 
		variance_matrix[0][1], variance_matrix[1][1]); 

	for(i=0;i<SampleSize;i++) {
		SampleKappaEta(i, kappa_opt, eta_opt, variance_matrix, kappa, eta);
		neg2lnL[i]=CalcNeg2LogLikelihood(NoDates, Dates, kappa[i], eta[i]);
	}

	OutputKappaEta(SampleSize, OutFile, kappa, eta, neg2lnL);

	printf("dataset %s sampled.\n\n", DatesFile);

	free(Dates);
	free(kappa);
	free(eta);
	free(neg2lnL);
	free_dmatrix(variance_matrix, 0, 2, 0, 2);

	return 0;
}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
void ReadDates(int NoDates, char *DatesFile, int *Dates)
{
	FILE *indat;
	int i;
	int eofind=1;

	if(fopen_s(&indat, DatesFile, "r")!=0)
		ERR_CRITICAL("ReadDates: Unable to open file for input.\n");

	for(i=0;i<NoDates && eofind>=0;i++){
		eofind=fscanf_s(indat, "%d", &Dates[i]);
	}
	if(eofind<0) 
		ERR_CRITICAL("ReadDates: dates input file does not contain enough dates.\n");
	fclose(indat);

	printf("dataset %s\n", DatesFile);
	printf("Successfully read list of dates.\n");

}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
void ReadParams(char *ParamFile, double *kappa_opt, double *eta_opt)
{
	FILE *indat;

	if( fopen_s(&indat, ParamFile, "r")!=0 )
		ERR_CRITICAL("ReadParam: Unable to open OptParamFile for input.\n");
	fscanf_s(indat, "%lg %lg", kappa_opt, eta_opt);
	fclose(indat);


	printf("Successfully read Params.\n");
}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
void CalcVarianceMat(int NoDates, int *Dates, double kappa, double eta, double **matrix)
{
	int i, j;
	double lnL_kappa2=0.0, lnL_kappa_eta=0.0, lnL_eta2=0.0;
	double lnL=0.0, lnL_kappa=0.0, lnL_eta=0.0;
	double sum_Ep, sum_bkp, sum_bep, sum_bkkp, sum_bkep, sum_beep; 
	double sum_Em, sum_bkm, sum_bem, sum_bkkm, sum_bkem, sum_beem;
	double Ep, Em, bkp, bkm, bep, bem, bkkp, bkkm, bkep, bkem, beep, beem;
	int T;
	double lnetaTp, lnetaTm, etaTptokappa, etaTmtokappa;
	double det;

	for(j=1;j<NoDates;j++) {
		sum_Ep = sum_bkp = sum_bep = sum_bkkp = sum_bkep = sum_beep = 0.0;
		sum_Em = sum_bkm = sum_bem = sum_bkkm = sum_bkem = sum_beem = 0.0;
		for(i=0;i<NoDates;i++) if(i!=j && Dates[i]<Dates[j]) {
			T = Dates[j]-Dates[i];
			lnetaTp = log(eta*(T+0.5));
			lnetaTm = log(eta*(T-0.5));
			etaTptokappa = pow(eta*(T+0.5), kappa);
			etaTmtokappa = pow(eta*(T-0.5), kappa);

			Ep = exp(-etaTptokappa);
			if(T<=0.5) Em = 1.0; 
			else Em = exp(-etaTmtokappa);

			bkp = -etaTptokappa*lnetaTp;
			bep = -kappa/eta * etaTptokappa;
			bkkp = bkp*bkp - etaTptokappa * lnetaTp*lnetaTp;
			bkep = bkp*bep - etaTptokappa/eta *(1+kappa*lnetaTp);
			beep = bep*bep - kappa/(eta*eta) * etaTptokappa *(kappa-1.0);

			if(T==0) bkm = bem = bkkm = bkem = beem = 0.0;
			else {
				bkm = -etaTmtokappa*lnetaTm;
				bem = -kappa/eta * etaTmtokappa;
				bkkm = bkm*bkm - etaTmtokappa * lnetaTm*lnetaTm;
				bkem = bkm*bem - etaTmtokappa/eta *(1+kappa*lnetaTm);
				beem = bem*bem - kappa/(eta*eta) * etaTmtokappa *(kappa-1.0);
			}

			sum_Ep += Ep;
			sum_bkp += bkp*Ep;
			sum_bep += bep*Ep;
			sum_bkkp += bkkp*Ep;
			sum_bkep += bkep*Ep;
			sum_beep += beep*Ep;
			sum_Em += Em;
			sum_bkm += bkm*Em;
			sum_bem += bem*Em;
			sum_bkkm += bkkm*Em;
			sum_bkem += bkem*Em;
			sum_beem += beem*Em;

		}
		if(sum_Em!=sum_Ep) {
			lnL_kappa2 += ((sum_bkkm-sum_bkkp)/(sum_Em-sum_Ep) 
				- pow( (sum_bkm-sum_bkp)/(sum_Em-sum_Ep), 2));
			lnL_kappa_eta += ( (sum_bkem-sum_bkep)/(sum_Em-sum_Ep) 
				- (sum_bkm-sum_bkp)*(sum_bem-sum_bep)/pow(sum_Em-sum_Ep, 2));
			lnL_eta2 += ( (sum_beem-sum_beep)/(sum_Em-sum_Ep)
				- pow( (sum_bem-sum_bep)/(sum_Em-sum_Ep), 2));
			lnL_kappa += (sum_bkm-sum_bkp)/(sum_Em-sum_Ep);
			lnL_eta += (sum_bem-sum_bep)/(sum_Em-sum_Ep);
			lnL += log(sum_Em-sum_Ep);
		}
	}

	lnL_kappa2=-lnL_kappa2;
	lnL_kappa_eta=-lnL_kappa_eta;
	lnL_eta2=-lnL_eta2;
	
	printf("-2lnL =\t%lg\n", -2*lnL);
	printf("first derivatives:\n\td/d kappa lnL =\t%lg\n\td/d eta lnL =\t%lg\n", 
		lnL_kappa, lnL_eta);
	printf("information matrix:\n\t%lg\t%lg\n\t%lg\t%lg\n", 
		lnL_kappa2, lnL_kappa_eta, lnL_kappa_eta, lnL_eta2);
	//Invert the information matrix in order to get the variance-covariance matrix:
	det=lnL_kappa2*lnL_eta2-lnL_kappa_eta*lnL_kappa_eta;
	matrix[0][0]=lnL_eta2/det;
	matrix[1][0]=matrix[0][1]=-lnL_kappa_eta/det;
	matrix[1][1]=lnL_kappa2/det;

	printf("Calculated the variance matrix.\n");

}
/*-------------------------------------------------------------------------------------------*/
/*void CalcVarianceMatContinuous(int NoDates, int *Dates, double kappa, double eta, 
							   double **matrix)
{
	int i, j;
	double lnL_kappa2=0.0, lnL_kappa_eta=0.0, lnL_eta2=0.0;
	double lnL=0.0, lnL_kappa=0.0, lnL_eta=0.0;
	double sum_w, sum_ak_w, sum_ae_w, sum_akk_w, sum_ake_w, sum_aee_w;
	double w, ak, ae, akk, ake, aee;
	int T;
	double lnetaT, etaTtokappa;
	double det;

	for(j=1;j<NoDates;j++) {
		sum_w = sum_ak_w = sum_ae_w = sum_akk_w = sum_ake_w = sum_aee_w = 0.0;
		for(i=0;i<NoDates;i++) if(i!=j && Dates[i]<=Dates[j]) {
			T = Dates[j]-Dates[i];
			lnetaT=log(eta*T);
			etaTtokappa=pow(eta*T, kappa);

			w = weibullPDF(T, kappa, eta);
			if(T==0) {
				ak=0.0;
				ae=0.0; //not numerically necessary
				akk=0.0;
				ake=0.0;
				aee=0.0; //not numerically necessary
			}
			else {
				ak = 1.0/kappa + lnetaT*(1.0-etaTtokappa);
				ae = kappa/eta*(1.0-etaTtokappa);
				akk = ak*ak -(1.0/(kappa*kappa) + pow(lnetaT, 2)*etaTtokappa);
				ake = ak*ae + (1.0 - (1.0+kappa*lnetaT)*etaTtokappa)/eta;
				aee = ae*ae - kappa/(eta*eta) *(1.0 + (kappa-1.0)*etaTtokappa);
			}

			sum_w += w;
			sum_ak_w += ak*w;
			sum_ae_w += ae*w;
			sum_akk_w += akk*w;
			sum_ake_w += ake*w;
			sum_aee_w += aee*w;
		}
		if(sum_w!=0.0) {
			lnL_kappa2 += (sum_akk_w/sum_w - sum_ak_w*sum_ak_w/(sum_w*sum_w));
			lnL_kappa_eta += (sum_ake_w/sum_w - sum_ak_w*sum_ae_w/(sum_w*sum_w));
			lnL_eta2 += (sum_aee_w/sum_w - sum_ae_w*sum_ae_w/(sum_w*sum_w));
			lnL_kappa += sum_ak_w/sum_w;
			lnL_eta += sum_ae_w/sum_w;
			lnL += log(sum_w);
		}
	}

	lnL_kappa2=-lnL_kappa2;
	lnL_kappa_eta=-lnL_kappa_eta;
	lnL_eta2=-lnL_eta2;
	
	printf("-2lnL = %lg\n", -2*lnL);
	printf("first derivatives:\n\td/d kappa lnL = %lg\n\td/d eta lnL = %lg\n", 
		lnL_kappa, lnL_eta);
	printf("information matrix:\n\t%lg\t%lg\n\t%lg\t%lg\n", 
		lnL_kappa2, lnL_kappa_eta, lnL_kappa_eta, lnL_eta2);
	//Invert the information matrix in order to get the variance-covariance matrix:
	det=lnL_kappa2*lnL_eta2-lnL_kappa_eta*lnL_kappa_eta;
	matrix[0][0]=lnL_eta2/det;
	matrix[1][0]=matrix[0][1]=-lnL_kappa_eta/det;
	matrix[1][1]=lnL_kappa2/det;

	printf("Calculated the variance matrix.\n");

}
/*-------------------------------------------------------------------------------------------*/
double weibullPDF(double x, double kappa, double eta)
{ 
	double PDF;
	//mean = 1/eta*exp(gammaln(1+1/kappa));
	//variance = 1/(eta*eta)*(exp(gammaln(1+2/kappa))-pow(exp(gammaln(1+1/kappa)), 2));
	if(x<=0.5) PDF = 1.0 - exp(-pow(eta*(x+0.5), kappa));
	else PDF = exp(-pow(eta*(x-0.5), kappa)) - exp(-pow(eta*(x+0.5), kappa));
	return PDF;
	//return kappa*pow(eta, kappa)*pow(x, kappa-1)*exp(-pow(x*eta, kappa));
}
/*-------------------------------------------------------------------------------------------*/
double weibull(double t, double kappa, double eta)
{
	return kappa*pow(eta, kappa)*pow(t, kappa-1.0)*exp(-pow(eta*t, kappa));
}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
void SampleKappaEta(int i, double kappa_opt, double eta_opt, double **matrix, double *kappa, 
					double *eta)
{
	double mean, var;

	kappa[i]=gennor(kappa_opt, sqrt(matrix[0][0]));
	mean = eta_opt + matrix[1][0]/matrix[0][0]*(kappa[i]-kappa_opt);
	//The cheated version: 
	//mean = eta_opt - matrix[1][0]/matrix[0][0]*(kappa[i]-kappa_opt);
	var = matrix[1][1] - matrix[1][0]*matrix[0][1]/matrix[0][0] ;
	eta[i] = gennor(mean, sqrt(var));
	//printf("kappa=%lg\teta = %lg", kappa[i], eta[i]);
	//printf("\n");

}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
double CalcNeg2LogLikelihood(int NoDates, int *Dates, double kappa, double eta)
{
	int i, j;
	int T;
	double lnL=0.0, sum_w;

	for(j=0;j<NoDates;j++) {
		sum_w=0.0;
		for(i=0;i<NoDates && i!=j; i++) {
			T=Dates[j]-Dates[i];
			if(T>0) sum_w += exp(-pow(eta*(T-0.5), kappa)) - exp(-pow(eta*(T+0.5), kappa));
		}
		if(sum_w>0.0) lnL += log(sum_w);
	}
	return -2*lnL;
}
/*-------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/
void OutputKappaEta(int SampleSize, char *OutFile, double *kappa, double *eta, double *neg2lnL)
{
	FILE *out;
	int i;

	if( fopen_s(&out, OutFile, "w")!=0 )
		ERR_CRITICAL("OutputKappaEta: Unable to open file for output.\n");

	fprintf(out, "neg2lnL\tkappa\teta\n");
	for(i=0;i<SampleSize;i++) fprintf(out, "%lg\t%lg\t%lg\n", neg2lnL[i], kappa[i], eta[i]);
	fclose(out);

}