/* File: FI.C */

#include <math.h>
#include <stdlib.h>
#include <fstream.h>

#define DIM         6
#define H0          0.6
#define CUST_QUANT  150
#define TIME_CUST   0.2

char sprt[] = "\t" ;
int number_of_variables = DIM;

ofstream logFile("duomenys.txt"), modFile("model.txt") ;

#define BaseRand ((((float)rand())/32767.0)+1e-7)

//----------------------------------------------------------------------------
double E(double a)
{
 if(a<=0) return 0;
 return(-log(BaseRand)/(a));
}

//----------------------------------------------------------------------------
class Queue
{
 public:
  Queue():elements(0.0) { };
  Queue& addElement(double value)
   { elements+=value; return *this; }
  Queue& update(double time)
   { if((elements -= time)<0.0)
      elements = 0.0;
     return *this; }
  Queue& reset()
   { elements=0.0; return *this; }
  double left() { return elements; }

 private:
  double elements;

};

//----------------------------------------------------------------------------
class NetParams
{
 friend ostream& operator << ( ostream& os, const NetParams& ) ;

 public:
  NetParams():lx1(0),ly1(0),hx1(0),hy1(0),sx1(0),sy1(0),
	      lx2(0),ly2(0),hx2(0),hy2(0),sx2(0),sy2(0),
	      lx3(0),ly3(0),hx3(0),hy3(0),sx3(0),sy3(0) { };
  NetParams(const char* fileName);
  NetParams& reset()
   { lx1=ly1=hx1=hy1=sx1=sy1=lx2=ly2=hx2=hy2=sx2=sy2=lx3=ly3=hx3=hy3=sx3=sy3=0;
     return *this; }
  NetParams& read(const char* fileName);

 protected:
  double lx1,ly1,hx1,hy1,sx1,sy1;
  double lx2,ly2,hx2,hy2,sx2,sy2;
  double lx3,ly3,hx3,hy3,sx3,sy3;
  friend class NetModel;
};

//----------------------------------------------------------------------------
class Server
{
 public:
  Server():x(0),y(0),a(0),bestx(0),besty(0),besta(0) { };
  Server& setXY(double _x, double _y)
   { x=_x; y=_y; return *this; }
  Server& setBest(double _x, double _y)
   { bestx=_x; besty=_y; return *this; }
  Server& setBestPoint()
   { bestx=x; besty=y; return *this; }
  Server& setBestA()
   { besta=a; return *this; }
  Server& reset()
   { a=0; queue.reset(); return *this; }
  Server& client()
   { a++; queue.addElement(E(x)); return *this; }
  Server& run(double time)
   { queue.update(time); return *this; }
  double bestX() { return bestx; }
  double bestY() { return besty; }
  double bestA() { return besta; }
  double getX() { return x; }
  double getY() { return y; }
  double h() { return y+queue.left(); }
  double u() { return a*y-x; }

  double a, besta;

 private:
  double x, y;
  double bestx, besty;
  Queue queue;
};

//----------------------------------------------------------------------------
class NetModel
{
 public:
  NetModel();
  NetModel& run(const double *p);
  Server* server1() { return &serverNo1; }
  Server* server2() { return &serverNo2; }
  Server* server3() { return &serverNo3; }

 protected:
  int serverToGo();
  NetModel& dispatchCustomers();

 private:
  Server serverNo1, serverNo2, serverNo3;
  NetParams params;
};

//----------------------------------------------------------------------------
NetParams::NetParams(const char* fileName)
{
 read(fileName);
}

//----------------------------------------------------------------------------
NetParams& NetParams::read(const char* fileName)
{
 ifstream file(fileName);
 if(file.fail())
  {
  cerr << "Error: can't open data file." << endl;
  exit(-1);
  }
 file >> lx1 >> ly1 >> hx1 >> hy1 >> sx1 >> sy1 >> lx2 >> ly2 >> hx2 >> hy2 >> sx2 >> sy2 >> lx3 >> ly3 >> hx3 >> hy3 >> sx3 >> sy3;
 file.close();
 return *this ;
}

//----------------------------------------------------------------------------
ostream& operator << ( ostream& os, const NetParams& np )
{
 os << "Model parameters: " << endl
    << "LX1=" << np.lx1 << "  LY1=" << np.ly1 << "  HX1=" << np.hx1 << endl
    << "HY1=" << np.hy1 << "  SX1=" << np.sx1 << "  SY1=" << np.sy1 << endl;
 os << endl
    << "LX2=" << np.lx2 << "  LY2=" << np.ly2 << "  HX2=" << np.hx2 << endl
    << "HY2=" << np.hy2 << "  SX2=" << np.sx2 << "  SY2=" << np.sy2 << endl;
 os << endl
    << "LX3=" << np.lx3 << "  LY3=" << np.ly3 << "  HX3=" << np.hx3 << endl
    << "HY3=" << np.hy3 << "  SX3=" << np.sx3 << "  SY3=" << np.sy3 << endl
    << endl ;
 return os ;
}

//----------------------------------------------------------------------------
int NetModel::serverToGo()
{
 double minH = H0;
 int server = 3;

 if( serverNo1.h() < minH)
  {
  minH = serverNo1.h();
  server = 0;
  }
 if( serverNo2.h() < minH)
  {
  minH = serverNo2.h();
  server = 1;
  }
 if( serverNo3.h() < minH)
  {
  minH = serverNo3.h();
  server = 2;
  }
 return server;
}

//----------------------------------------------------------------------------
NetModel& NetModel::dispatchCustomers()
{
 for(int i =0;i<CUST_QUANT;i++)
  {
  double comminTime = E(TIME_CUST);
  switch(serverToGo())
   {
   case 0: {
	   serverNo1.client();
	   break;
	   }
   case 1: {
	   serverNo2.client();
	   break;
	   }
   case 2: {
	   serverNo3.client();
	   break;
	   }
   }
  serverNo1.run(comminTime);
  serverNo2.run(comminTime);
  serverNo3.run(comminTime);
  }
 return *this;
}

//----------------------------------------------------------------------------
NetModel& NetModel::run(const double *p)
{
 double maxProfit = 0.0, coalProfit;
 double i,j;

 // maximize the first server
 serverNo2.setXY(*p,*(p+1));
 serverNo3.setXY(*(p+2),*(p+3));
 // serverNo3.setXY(*(p+4),*(p+a5));
 for( i = params.lx1 ; i<params.hx1; i+=params.sx1)
   for(j = params.ly1; j< params.hy1; j+=params.sy1)
    {
    serverNo1.setXY(i,j).reset();
 //   serverNo2.setXY(i,j).reset();
    serverNo2.reset();
    serverNo3.reset();
    dispatchCustomers();
    if(serverNo1.u() > maxProfit)
     {
     serverNo1.setBestPoint();
     serverNo1.setBestA();
     // serverNo2.setXY( serverNo1.getX(), serverNo1.getY() ) ;
     // serverNo2.setBestPoint();
     maxProfit = serverNo1.u();
     }
    }
 coalProfit = maxProfit; maxProfit = 0.0;
// maximize the second server
 serverNo1.setXY(*p,*(p+1));
 serverNo3.setXY(*(p+2),*(p+3));
 // serverNo3.setXY(*(p+4),*(p+a5));
 for( i = params.lx2 ; i<params.hx2; i+=params.sx2)
   for(j = params.ly2; j< params.hy2; j+=params.sy2)
    {
    serverNo2.setXY(i,j).reset();
    serverNo1.reset();
    serverNo3.reset();
    dispatchCustomers();
    if(serverNo2.u() > maxProfit)
     {
     serverNo2.setBestPoint();
     serverNo2.setBestA();
     // serverNo2.setXY( serverNo1.getX(), serverNo1.getY() ) ;
     // serverNo2.setBestPoint();
     maxProfit = serverNo2.u();
     }
    }
 coalProfit = coalProfit + maxProfit;

 modFile << p[0] << sprt << p[1] << endl
	 << "1-o pelnas be koal.: " << serverNo1.bestA()*p[1] - p[0] << endl
	 << "2-o pelnas be koal.: " << serverNo2.bestA()*p[1] - p[0] << endl
	 << "Koal. pelnas: " << coalProfit << endl
	 << "Pelnas vienam koal. nariui: " << coalProfit/2  << endl;

 // maximize the third server
 maxProfit = 0.0;
 serverNo1.setXY(*p,*(p+1));
 serverNo2.setXY(*p,*(p+1));
 for( i=params.lx3;i<params.hx3;i+=params.sx3)
   for (j=params.ly3;j<params.hy3;j+=params.sy3)
    {
    serverNo3.setXY(i,j).reset();
    serverNo1.reset();
    serverNo2.reset();
    dispatchCustomers();
    if (serverNo3.u() > maxProfit)
     {
     serverNo3.setBestPoint();
     serverNo3.setBestA();
     maxProfit = serverNo3.u();
     }
    }

 modFile << p[2] << sprt << p[3] << endl
	 << "3-o pelnas: " << maxProfit << endl;

 return *this;
}

//----------------------------------------------------------------------------
NetModel::NetModel() : params((const char*)"params.txt")
{
 if (logFile.bad())
  {
  cerr << "Error: can't open log file." << endl ;
  exit( -2 ) ;
  }
 if (modFile.bad())
  {
  cerr << "Error: can't open modelling results file." << endl ;
  exit( -3 ) ;
  }
 logFile << params ;
}

//----------------------------------------------------------------------------
NetModel network;

//#ifdef __cplusplus
//extern "C" {
//#endif

/* Goal function definition */

//----------------------------------------------------------------------------
double fi(const double *x, int n)
{
 double ret = 0;

 network.run(x);
 double tmp = network.server1() -> bestX() - *(x);
 ret += tmp * tmp;
 tmp = network.server1() -> bestY() - *(x+1);
 ret += tmp * tmp;
 tmp = network.server2() -> bestX() - *(x);
 ret += tmp * tmp;
 tmp = network.server2() -> bestY() - *(x+1);
 ret += tmp * tmp;
 tmp = network.server3() -> bestX() - *(x+2);
 ret += tmp * tmp;
 tmp = network.server3() -> bestY() - *(x+3);
 ret += tmp * tmp;
 modFile << "f(x)=" << ret << endl << endl;
 return ret;
}

//----------------------------------------------------------------------------
/* Definition of constraints */
void constr (const double *x, int n, double *g, int ng)
{

}

//#ifdef __cplusplus
//}
//#endif