#define _CRT_SECURE_NO_DEPRECATE

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <conio.h>
#include "ilcplex/cplex.h" 
#include <windows.h>
#include <winbase.h>

//sta je M u modelu!?
#define M 100000


CPXENVptr env;
CPXLPptr lp;
CPXFILEptr logf;

double *coef;
int *index;

#define IDX(i,k) ((k)*problem->n+(i))
#define YIDX(i,k,l) ((l)*problem->n*problem->n+(k)*problem->n+(i)+problem->n*problem->n)
#define O(i) (problem->o[(i)])
//#define D(i) (problem->d[(i)])
#define G(i) (problem->b[(i)])

#define MAXSTR 80
#define C(i,j) problem->c[(j) * problem->n + (i)]
//A je za minprotok
#define A(i) problem->b[i]
#define D(i,j) hmat(i,j)

//#define sortMat(i,j) problem->sortmat[(i) * problem->n + j]
#define hmat(i,j) problem->hp[(j) * problem->n + (i)]

typedef struct
{
	double distance;
	int index;
} distindex_struct;
typedef struct
{
     char inpf[MAXSTR];
     char mstfile[MAXSTR];
     char outfile[MAXSTR];   
	 char logfile[MAXSTR];
	 char rezfile[MAXSTR];
     int nheur;
     int iheur;
    // heur_struct heur[MAXHEUR];
     int allvariants;
     void (*fimp)(void);
} common_struct;

typedef struct
{
    common_struct com;
    int n;                /* Broj potencijalnih lokacija i klijenata */
    double *hp;      /* Troskovi prevoza od lokacija do klijenata */
    //int *hps;        /* Sortirani indeksi lokacija po ceni za svakog klij. */
    //int *asgn;       /* dodeljeni habovi */
     
    double *f;    /* fiksni troskovi */   
    double *b;    /* kapaciteti pot. lokacija */   
    
    double *c;       /* kolicina robe (i,j) */

	double *o; /* total sum originate from o[i] */
	double *d;/* total sum destined to d[i] */
    //double *sumc;    /* ukupna (zbir) kolicna robe od i-tog cvora do svih ostalih cvorova j */
    //double *tc,*tc2;  /* matrice najkracih puteva */
    double *hpx,*hpy; /* koordinate klijenata i pot. lokacija */
    double col,dis,tr; /* troskovi: do haba, izmedju habova, od haba
                          collection, transfer, distribution cost */
    //int *ts,*tsi;     /* indeksi potencijalnih habova sortirani opadajuce i inverzni niz */

    //void (*fm)(void);  /* pravljenje nizova CC i CCS na pocetku */
    //void (*ft)(void);  /* pravljenje nizova CC i CCS u toku generacija */       
    //void (*fs)(void);  /* sortiranje nizova CC i CCS u toku generacija */                         
    //void (*fdomp)(void); /* racunanje lambda koeficijenata DOMP funkcije */

	double fikskoef; //koeficijent za fiksne troskove
} problem_struct;

problem_struct *problem;

void Error(int status, char *s)
{
	FILE *tmp;
	printf("Greska: %s (%d)\n",s,status);
	getch();

	tmp = fopen("stats.txt","a");
	fprintf(tmp,"%s Greska: %s (%d)\n",problem->com.inpf,s,status);	
	fclose(tmp);

	exit(0);
}

int SortDouble (const void *a, const void *b)
{
	distindex_struct *x = (distindex_struct*) a;
	distindex_struct *y = (distindex_struct*) b;

	if(x->distance<y->distance)
		return -1;
	if(x->distance>y->distance)
		return 1;
	return 0;
}

void pripremiPodatke()
{
	int i,j;
	//double k;
	//problem->posbkp = malloc(problem->n * sizeof(int));

	//     problem->sortmat = malloc(problem->n * problem->n * sizeof(distindex_struct));
	//	 if(problem->sortmat==NULL)
	//	{
 //         printf("Ne moze da se alocira matrica za sortiranje \n");
 //         exit(0);
 //       }
	//for(i=0;i<problem->n;i++)
	//	for(j=0;j<problem->n;j++)
	//	{
	//		sortMat(i,j).distance = hmat(i,j);
	//		sortMat(i,j).index = j;
	//	}

	//for(i=0;i<problem->n;i++)
	//	qsort(&problem->sortmat[i*problem->n],problem->n,sizeof(distindex_struct), SortDouble);

	if(problem->fikskoef != 1)
	{
		for(i=0;i<problem->n;i++)
			problem->f[i] *= problem->fikskoef;
	}

	problem->o = malloc(problem->n * sizeof(double)); 
   problem->d = malloc(problem->n * sizeof(double));      
   if(problem->o == NULL || problem->d == NULL)
   {
	   Error(0,"problem->o ili d");
   }


	for(i=0;i<problem->n;i++)
		O(i)=0;
		//D(i)=0;

	for(i=0;i<problem->n;i++)
	for(j=0;j<problem->n;j++)
	{
		O(i) += C(i,j);///1000;
		//D(j) += C(i,j);///1000;
	}
}

//Uncapacitated hub input za AP instance, tipa ap300l
void uhubAPInput()
{ FILE  *inp;//,*pinp;
  int i,j;//,n;


/* Ucitavanje ulazne datoteke */

   inp = fopen(problem->com.inpf,"rt");
   //pinp = fopen("cab.dat","rt");
   if (inp == NULL)// || pinp==NULL)
    {
      printf("Ulazna datoteka %s ne moze da se otvori\n",problem->com.inpf);
      exit(0);
    }
   //fscanf(pinp,"%d %d %lf %lf %lf",&problem->n,&problem->p,&problem->col,&problem->tr,&problem->dis);
   //fclose(pinp);
   problem->col = 3;
   problem->tr = 0.75;
   problem->dis = 2;
   fscanf(inp,"%d",&problem->n);
   problem->hp = malloc(problem->n * problem->n * sizeof(double));
   problem->hpx = malloc(problem->n * sizeof(double)); 
   problem->hpy = malloc(problem->n * sizeof(double)); 
   problem->f = malloc(problem->n * sizeof(double)); 
   problem->b = malloc(problem->n * sizeof(double));      
   problem->c = malloc(problem->n * problem->n * sizeof(double)); 
 
   if(problem->hp == NULL 
	   //|| problem->hps == NULL 
	   //|| problem->y == NULL 
	   //|| problem->imin == NULL 
	   ||
      problem->hpx == NULL || problem->hpy == NULL || problem->c == NULL)
        {
          printf("Ne moze da se alocira matrica H ili HP, ili niz X ili IMIN \n");
          exit(0);
        }
   for(i=0;i<problem->n;i++)
     for(j=0;j<problem->n;j++) 
       fscanf(inp,"%lf",&C(i,j));	     
   //for(i=0;i<problem->n;i++)
    // fscanf(inp,"%lf %lf",&problem->hpx[i],&problem->hpy[i]);     
   for(i=0;i<problem->n;i++)
     for(j=0;j<problem->n;j++) 
	   //if(i==j) hmat(i,j) = 0;
	   //else 
	     {
	     //	dx = problem->hpx[i] - problem->hpx[j];
	     	//dy = problem->hpy[i] - problem->hpy[j];
	     	//hmat(i,j) = sqrt(dx*dx + dy*dy);
	     	//hmat(j,i) = hmat(i,j);
			 fscanf(inp,"%lf",&hmat(i,j));
	     } 
   for(i=0;i<problem->n;i++)
     for(j=i;j<problem->n;j++) 
	 {
		 if(hmat(i,j)!=hmat(j,i))
		 {
			printf("Matrica udaljenosti nije simetricna \n");
			exit(0);
		 }
		 if(hmat(i,i)!=0)
		 {
			printf("Matrica udaljenosti mora imati 0 na dijagonali \n");
			exit(0);
		 }
	 }

   for(i=0;i<problem->n;i++)
     fscanf(inp,"%lf",&problem->f[i]);
   fclose(inp);
	 pripremiPodatke();
}

void protokInput()
{ FILE  *inp;//,*pinp;
  int i,j;//,n;
  double dx,dy,d;

   inp = fopen(problem->com.inpf,"rt");
   if (inp == NULL)// || pinp==NULL)
    {
      printf("Ulazna datoteka %s ne moze da se otvori\n",problem->com.inpf);
      exit(0);
    }

   problem->n = 0;
   while(!feof(inp))
   {
	   problem->n++;
	   fscanf(inp,"%d %lf,%lf %lf",&i,&dx,&dy,&d);     
   }
   fclose(inp);


  problem->hp = malloc(problem->n * problem->n * sizeof(double));
 	problem->hpx = malloc(problem->n * sizeof(double)); 
   problem->hpy = malloc(problem->n * sizeof(double)); 
   problem->b = malloc(problem->n * sizeof(double));      

   inp = fopen(problem->com.inpf,"rt");
   if (inp == NULL)// || pinp==NULL)
    {
      printf("Ulazna datoteka %s ne moze da se otvori\n",problem->com.inpf);
      exit(0);
    }

   i = 0;
   while(!feof(inp))
   {
	   fscanf(inp,"%d %lf,%lf %lf",&j,&problem->hpx[i],&problem->hpy[i],&problem->b[i]);     
	   i++;
   }
   fclose(inp);
      for(i=0;i<problem->n;i++)
     for(j=i;j<problem->n;j++) 
	   if(i==j) hmat(i,j) = 0;
	   else 
	     {
	     	dx = problem->hpx[i] - problem->hpx[j];
	     	dy = problem->hpy[i] - problem->hpy[j];
	     	hmat(i,j) = sqrt(dx*dx + dy*dy);
	     	hmat(j,i) = hmat(i,j);
	     } 
}

void chubInput()
{ FILE  *inp;//,*pinp;
  int i,j;//,n;
  double dx,dy;


/* Ucitavanje ulazne datoteke */

   inp = fopen(problem->com.inpf,"rt");
   if (inp == NULL)// || pinp==NULL)
    {
      printf("Ulazna datoteka %s ne moze da se otvori\n",problem->com.inpf);
      exit(0);
    }

   problem->col = 3;
   problem->tr = 0.75;
   problem->dis = 2;
   fscanf(inp,"%d",&problem->n);
   problem->hp = malloc(problem->n * problem->n * sizeof(double));
   //problem->hps = malloc(problem->n * problem->n * sizeof(int));   
   //problem->tc = malloc(problem->n * problem->n * sizeof(double));
   //problem->tc2 = malloc(problem->n * problem->n * sizeof(double));
   //problem->y = malloc(problem->n+1);
   //problem->clw = malloc(problem->n * sizeof(double));      
   //problem->imin = malloc( (problem->n) * sizeof(int));   
   //problem->imin2 = malloc( (problem->n) * sizeof(int)); 
   //problem->asgn = malloc( (problem->n) * sizeof(int));   
   problem->hpx = malloc(problem->n * sizeof(double)); 
   problem->hpy = malloc(problem->n * sizeof(double)); 
   problem->f = malloc(problem->n * sizeof(double)); 
   problem->b = malloc(problem->n * sizeof(double));      
   problem->c = malloc(problem->n * problem->n * sizeof(double)); 
   if(problem->hp == NULL
	   //|| problem->hps == NULL 
	   //|| problem->y == NULL 
	   //|| problem->imin == NULL 
	   || problem->hpx == NULL || problem->hpy == NULL || problem->c == NULL)
        {
          printf("Ne moze da se alocira matrica H ili HP, ili niz X ili IMIN \n");
          exit(0);
        }
   for(i=0;i<problem->n;i++)
     fscanf(inp,"%lf %lf",&problem->hpx[i],&problem->hpy[i]);     
   for(i=0;i<problem->n;i++)
     for(j=i;j<problem->n;j++) 
	   if(i==j) hmat(i,j) = 0;
	   else 
	     {
	     	dx = problem->hpx[i] - problem->hpx[j];
	     	dy = problem->hpy[i] - problem->hpy[j];
	     	hmat(i,j) = sqrt(dx*dx + dy*dy);
	     	hmat(j,i) = hmat(i,j);
	     } 
   for(i=0;i<problem->n;i++)
     for(j=0;j<problem->n;j++) 
       fscanf(inp,"%lf",&C(i,j));	     
   
   for(i=0;i<problem->n;i++)
     fscanf(inp,"%lf %lf",&problem->b[i],&problem->f[i]);
   fclose(inp);
   	 pripremiPodatke();
}  /* chubInput */

void Log(int tip, int count)
{
	int i;
	FILE *tmp;

	//nEqu++;
	//return;

	while((i=fopen_s(&tmp,problem->com.logfile,"a"))!=0)
	{
		//printf("Greska (%d) ne mogu da otvorim fajl %s!!!\n",i,problem->com.logfile);
		//getch();
		//exit(i);
	}
	fprintf(tmp,"(%d) ",tip);
	for(i=0;i<count;i++)
		fprintf(tmp,"%d=%.8f ",index[i],coef[i]);

	fprintf(tmp,"\n");

	fflush(tmp);

	fclose(tmp);
}


void main(int argc, char **argv)
{  
	FILE *fajl;
	double obj;
	double *result;
	int count;
	double rhs;
	int zero=0;
	clock_t runstart,runend;
	double tmp;
	int probe=0,emphasis=0;

char *varType;
//char **varName;
			
	int nVar;
	int status;

	int i, j, k,l;
	int K;

	runstart = clock();

	if(argc<3)
	{
	  Error(0,"Nema dovoljno argumenata\\minprotok <ulazna> <K>\n\n");
	}


	problem = malloc(sizeof(problem_struct));
	if(problem==NULL)
    {
       printf("Nema dovoljno memorije na HEAP-u za strukturu PROBLEM!\n");
       exit(0);
    }

	problem->fikskoef = 1;
	//if(argc>=3)
	//	problem->fikskoef = atof(argv[2]);
	K = atoi(argv[2]);

	strcpy(problem->com.inpf,argv[1]);
	strcat(problem->com.inpf,".txt");
	strcpy(problem->com.mstfile,argv[1]);
	strcat(problem->com.mstfile,".mst");
		strcpy(problem->com.logfile,argv[1]);
	strcat(problem->com.logfile,".log");
		
	strcpy(problem->com.outfile,argv[1]);
	strcat(problem->com.outfile,"_out.txt");

	strcpy(problem->com.rezfile,argv[1]);
	strcat(problem->com.rezfile,"_rez.txt");

	if(problem->com.inpf[0]=='a')
		uhubAPInput();
	else
	if(problem->com.inpf[0]=='x')
		protokInput();
	else
		chubInput();


		
	for(i=3;i<argc;i++)
	{
		if(strcmp(argv[i],"bal")==0)
			emphasis = CPX_MIPEMPHASIS_BALANCED;
		if(strcmp(argv[i],"feas")==0)
			emphasis = CPX_MIPEMPHASIS_FEASIBILITY;
		if(strcmp(argv[i],"opt")==0)
			emphasis = CPX_MIPEMPHASIS_OPTIMALITY;
		if(strcmp(argv[i],"probe")==0)
			probe++;
	}


	env = NULL;
	lp = NULL;
	zero = 0; 

	env = CPXopenCPLEX(&status);

		
	status = CPXsetintparam(env, CPX_PARAM_SCRIND, CPX_ON);
	if(status)
	{
		Error(0,"CPLEX ne moze da inicira ekran!!!!\n");
	}  

	status = CPXsetintparam(env, CPX_PARAM_DATACHECK, CPX_ON);
	if(status)
	{
		Error(0,"CPLEX ne moze da cekira podatke!!!!\n");
	}  

			
		status = CPXsetintparam(env, CPX_PARAM_MIPEMPHASIS, emphasis);
		if(status)
		{
			Error(0,"CPLEX ne moze da postavi parametar CPX_PARAM_MIPEMPHASIS!!!!\n");
		}

			
	if(probe>0)
	{
		status = CPXsetintparam(env, CPX_PARAM_PROBE, probe);
		if(status)
		{
			Error(0,"CPLEX ne moze da postavi parametar CPX_PARAM_PROBE!!!!\n");
		}
	}

			
		
	lp = CPXcreateprob(env, &status, "minprotok");
	if(lp==NULL)
	{
		Error(0,"CPLEX ne moze da kreira problem!!!!\n");
	}


	nVar = problem->n*problem->n+problem->n+1; //n^2+n+1 //prvo idu Xovi pa Y pa Lmax
		
	coef = malloc(nVar*sizeof(double));
	index = malloc(nVar*sizeof(int));
	if(coef == NULL || index == NULL)
	{
		Error(0,"Strukture coef i index ne mogu da se alociraju.\n");
	}


	//funkcija cilja je jednostavno Lmax, tj. poslednja promenljiva
	for(i=0;i<nVar;i++)
	{
		coef[i] = 0;
	}
	coef[nVar-1] = 1;


	//for(i=0;i<problem->n;i++)
	//for(k=0;k<problem->n;k++)
	//{
	//	coef[IDX(i,k)] = A(i,k); 
	//	//coef[IDX(i,k)]  /= 1000;
	//}

	for(i=0;i<nVar;i++)
		index[i] = i; //ovo je samo zbog Log
	Log(1,nVar);
	varType = malloc(nVar*sizeof(char));
	for(i=0;i<nVar;i++)
		varType[i] = 'B';
	//Lmax je realna!
	varType[nVar-1] = 'C';
	//USLOV 1 tj ciljna funkcija
	status = CPXnewcols(env, lp, nVar, coef, NULL, NULL, varType, NULL);
	if(status)
	{
		Error(status,"CPLEX ne moze da doda kolone!!!!\n");
	}  


	rhs = 1;
	count = problem->n;
	for(i=0;i<problem->n;i++)
	{
		for(k=0;k<problem->n;k++)
		{
			coef[k] = 1;
			index[k] = IDX(i,k);
		}
		Log(2,count);
   		status = CPXaddrows(env, lp, 0, 1, count, &rhs, "E", &zero, index, coef, NULL, NULL);    
		if(status)
		{
			Error(status,"Uslov 2\n");
		}
	}


	rhs = 0;
	count = 2;
	coef[0] = 1;
	coef[1] = -1;
	for(i=0;i<problem->n;i++)
	{
		for(k=0;k<problem->n;k++)			
		//if(i!=k) //svejedno da li stoji ovo if ili ne
		{
			index[0] = IDX(i,k);
			index[1] = problem->n*problem->n+k;
			Log(3,count);
   			status = CPXaddrows(env, lp, 0, 1, count, &rhs, "L", &zero, index, coef, NULL, NULL);    
			if(status)
			{
				Error(status,"Uslov 3\n");
			}
		}
	}

	//rhs = 0;
	count = problem->n+1;
	for(i=0;i<problem->n;i++)
		for(j=0;j<problem->n;j++)
		{
			for(l=0;l<problem->n;l++)
			{
				index[l] = IDX(i,l);
				coef[l] = D(i,l)/M;
			}

			index[problem->n] = problem->n*problem->n+j; //Yj
			coef[problem->n] = 1;

			rhs = D(i,j)/M+1;

		
			Log(4,count);
   			status = CPXaddrows(env, lp, 0, 1, count, &rhs, "L", &zero, index, coef, NULL, NULL);    
			if(status)
			{
				Error(status,"Uslov 4\n");
			}

		}

		
	rhs = K;
	count = problem->n;
	for(i=0;i<problem->n;i++)
	{
		coef[i] = 1;
		index[i] = problem->n*problem->n+i;
	}
	Log(5,count);
   	status = CPXaddrows(env, lp, 0, 1, count, &rhs, "E", &zero, index, coef, NULL, NULL);    
	if(status)
	{
		Error(status,"Uslov 5\n");
	}

	rhs = 0;
	count = problem->n+1;
	//Lmax
	coef[count-1] = -1;
	index[count-1] = nVar-1;
	for(i=0;i<problem->n;i++)
	{
		for(k=0;k<problem->n;k++)
		{
			coef[k] = A(k);
			index[k] = IDX(k,i);
		}
		Log(6,count);
   		status = CPXaddrows(env, lp, 0, 1, count, &rhs, "L", &zero, index, coef, NULL, NULL);    
		if(status)
		{
			Error(status,"Uslov 6\n");
		}
	}

	status = CPXmipopt(env, lp);
	if(status)
	{
		Error(status,"CPLEX ne moze da pocne resavanje problema!!!!\n");
	}  

	status = CPXmstwrite(env, lp, problem->com.mstfile);
	if(status)
	{
		Error(status,"CPLEX ne moze da stampa mst!!!!\n");
	}  


	status = CPXchgprobtype (env, lp, 3);
	if(status)
	{
		Error(status,"CPLEX ne moze da fiksira resenje!!!!\n");
	}  

	status = CPXlpopt(env, lp);

	if(status)
	{
	Error(status,"CPLEX ne moze da zavrsi resavanje problema!!!!\n");
	}  

	result = malloc(nVar*sizeof(double));
	if(!result)
		Error(0,"Ne mogu da alociram niz za resenje.");

	status = CPXgetx(env, lp, result, 0, nVar-1);
	if(status)
		Error(status,"CPLEX ne moze da uzme resenje problema!!!!\n");


	fajl = fopen(problem->com.rezfile,"w");
	fprintf(fajl,"Filename:%s\ttr:%lf\tcol:%lf\tdis:%lf\tfikskoef:%lf\temphasis: %d\tprobe: %d\n",problem->com.inpf,problem->tr,problem->col,problem->dis,problem->fikskoef,emphasis,probe);

	printf("HUBovi su: ");
	fprintf(fajl,"HUBovi su: ");
	for(i=0;i<problem->n;i++)
		if(result[IDX(i,i)]>0.9)
		{
				fprintf(fajl,"%d ",i+1);
				printf("%d ",i+1);
		}
	printf("\n");
	fprintf(fajl,"\n");


		
	status = CPXwritesol(env, lp, problem->com.outfile, NULL);
	if(status)
	{
	Error(status,"CPLEX ne moze da stampa resenje problema!!!!\n");
	}   

	status = CPXgetobjval(env, lp, &obj); 
	if(status)
	{
	Error(status,"CPLEX ne moze da uzme obj resenje problema!!!!\n");
	}   
	printf("Vrednost je: %lf\n",obj);
	fprintf(fajl,"Vrednost je: %lf\n",obj);


	runend = clock();
    tmp = (double) (runend-runstart)/CLOCKS_PER_SEC;
    printf("Izvrsavanje je trajalo %10.2lf sekundi!\n",tmp);
    fprintf(fajl,"Izvrsavanje je trajalo %10.2lf sekundi!\n",tmp);

		
	if(lp!=NULL) CPXfreeprob(env, &lp);
	if(env!=NULL) CPXcloseCPLEX(&env);

	fclose(fajl);	
	getch();
}