#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ga/ga.h>
#include <ga/std_stream.h>
#include <ga/GA1DArrayGenome.h>

#define cout STD_COUT
#define cerr STD_CERR
#define istream STD_ISTREAM
#define ostream STD_OSTREAM
#define ifstream STD_IFSTREAM

class activitydata
{
public:    
    int duration;
    int facduration;
    int startdate;
    int minr1;
	int maxr1;
	int facr1;
    int minr2;
	int maxr2;
	int facr2;
	int pred1;
    int pred2;
   //int pred3;
	int delay;
	int delay1;
    int priority;
	int priority1;
	char predtype1[10];    
	char predtype2[10];
	char predtype3[10]; 
};
activitydata  *act = new activitydata [1000];
activitydata  *predone = new activitydata [1000];
activitydata  *predtwo = new activitydata [1000];

int resource1,resource2;
int minprojectduration;

int r1avail[1000],r1profile[1000];
int r2avail[1000],r2profile[1000];
int rprofile [1000];
int i1,highest,i,no_act,highest1 , highpriority;
int m,k1,k2,k,j,length;
int temp=6;

int scheduledact[1000];
int eligibleact[1000];
//declaration of functions 
// check the availability &shift start  
void start();
//stores pred activities info
void perd();
void input();

class SubhaGenome : public GAGenome {
public:
  GADefineIdentity("SubhaGenome", 201);
  static void SubhaInitializer(GAGenome&);
  static int SubhaMutator(GAGenome&, float);
  static float SubhaComparator(const GAGenome&, const GAGenome&);
  static int SubhaCrossover(const GAGenome&, const GAGenome&,
				GAGenome*, GAGenome*);
public:
  SubhaGenome(int, GAGenome::Evaluator f=NULL, void* u=NULL);
  SubhaGenome(const SubhaGenome & orig);
  SubhaGenome& operator=(const GAGenome& g);
  virtual ~SubhaGenome();
  virtual GAGenome* clone(GAGenome::CloneMethod) const ;
  virtual void copy(const GAGenome & c);
  virtual int equal(const GAGenome& g) const;
  virtual int read(istream & is);
   virtual int write(ostream & os) const;
  GA1DArrayGenome<int> & factorstr() const {return *fac;}
  GAListGenome<int> & priorityy() const {return *pri;}
protected:
  GA1DArrayGenome <int>*fac;
  GAListGenome<int>*pri;
};

void ListInitializer(GAGenome &);
void ArrayInitializer(GAGenome &);
float Objective(GAGenome & );
//float level1objective(GAGenome &);
//float objective1(GAGenome &);


int 
SubhaGenome::write(ostream & os) const {
  int i,j;

  for(i=0; i<fac->length(); i++){
    os << (fac->gene(i) ) <<"\t";
    //os << "\n";
  }
 os << "\n" << *pri->head() << "\t";
 for(i=1;i<no_act;i++)
	{
         os <<*pri->next()<< "\t";
	}
os << "\n";
  return os.fail() ? 1 : 0;
}


SubhaGenome::
SubhaGenome(int length,GAGenome::Evaluator f, void* u) :	GAGenome(  SubhaInitializer,
			 SubhaMutator,
			 SubhaComparator) {
		  evaluator(f); userData(u); crossover(SubhaCrossover);
		  fac = new GA1DArrayGenome<int> (length, f, u);
		  pri = new  GAListGenome<int> ( f, u);
		pri->crossover(GAListGenome<int>::PartialMatchCrossover);
		} 

SubhaGenome::SubhaGenome(const SubhaGenome & orig) {
  fac = new GA1DArrayGenome<int>(orig.factorstr());
  pri= new  GAListGenome<int>(orig.priorityy());
  copy(orig);
}

SubhaGenome& 
SubhaGenome::operator=(const GAGenome& g) { copy(g); return *this; }

SubhaGenome::~SubhaGenome() { delete fac; delete pri; }

GAGenome* 
SubhaGenome::clone(GAGenome::CloneMethod) const {
  return new SubhaGenome(*this);
} 

void 
SubhaGenome::copy(const GAGenome & c){
  if(&c != this && sameClass(c)){
    GAGenome::copy(c);
   SubhaGenome & bc = (SubhaGenome &)c;
    fac->copy(*(bc.fac));
    pri->copy(*(bc.pri));
  }
}

int 
SubhaGenome::equal(const GAGenome& g) const {
  SubhaGenome& genome = (SubhaGenome&)g;
  return ((*fac == *genome.fac) && (*pri == *genome.pri));
}

int 
SubhaGenome::read(istream & is) {
  is >> *fac>> *pri; 
  return is.fail() ? 1 : 0; 
}

void 
SubhaGenome::SubhaInitializer(GAGenome & c) {
  SubhaGenome & child = (SubhaGenome &)c;
  child.factorstr().initializer(ArrayInitializer);
  child.priorityy().initializer(ListInitializer);
  child.factorstr().initialize();
  child.priorityy().initialize();
  //cout<<child;
  child._evaluated = gaFalse;
}

int 
SubhaGenome::SubhaMutator(GAGenome & c, float pmut) {
  SubhaGenome & child = (SubhaGenome &)c;
  int nmut = child.factorstr().mutate(pmut) + child.priorityy().mutate(pmut);

 
  if(nmut) child._evaluated = gaFalse;
  return nmut;
}

float 
SubhaGenome::SubhaComparator(const GAGenome& a, const GAGenome& b) {
  SubhaGenome& sis = (SubhaGenome &)a;
  SubhaGenome& bro = (SubhaGenome &)b;
 
  return 0.5 * (sis.factorstr().compare(bro) + sis.priorityy().compare(bro));
}

int
SubhaGenome::
SubhaCrossover(const GAGenome& a, const GAGenome& b,
		   GAGenome* c, GAGenome* d){ 
  SubhaGenome& mom = (SubhaGenome&)a;
  SubhaGenome& dad = (SubhaGenome&)b;
  int n=0;
 // GAGenome.Crossover=PartialMatchCrossover;
  GAGenome::SexualCrossover faccross = mom.fac->sexual();
  GAGenome:: SexualCrossover pricross = mom.pri->sexual();


  //GAGenome::SexualCrossover pricross  (GAGenome::SexualCrossover PartialMatchCrossover);
  if(c && d){
    SubhaGenome& sis = (SubhaGenome&)*c;
    SubhaGenome& bro = (SubhaGenome&)*d;
//	 sis.priority()::SexualCrossover Crossover (sis.priority::PartialMatchCrossover);
//	 bro.priority().Crossover(GAListGenome<int>::PartialMatchCrossover);
  
    (*faccross)(mom.factorstr(), dad.factorstr(), &sis.factorstr(), &bro.factorstr());
    (*pricross)(mom.priorityy(),dad.priorityy(), &sis.priorityy(), &bro.priorityy());
	
    sis._evaluated = gaFalse;
    bro._evaluated = gaFalse;
    n = 2;
  }
  else if(c){
   SubhaGenome& sis = (SubhaGenome&)*c;
    (*faccross)(mom.factorstr(), dad.factorstr(), &sis.factorstr(), 0);
    (*pricross)(mom.priorityy(), dad.priorityy(), &sis.priorityy(), 0);
	

    sis._evaluated = gaFalse;
    n = 1;
  }
  else if(d){
   SubhaGenome& bro = (SubhaGenome&)*d;
    (*faccross)(mom.factorstr(), dad.factorstr(), 0, &bro.factorstr());
    (*pricross)(mom.priorityy(), dad.priorityy(), 0, &bro.priorityy());

    bro._evaluated = gaFalse;
    n = 1;
  }
  return n;
}

/*typedef struct _SubhaData {
  short ** fac;
  float * pri;
} SubhaData;*/

/* ----------------------------------------------------------------------------
List Genome Operators
-------------------------------------------------------------------------------
The initializer creates a list with n elements in it and puts a unique digit
in each one.  After we make the list, we scramble everything up.
---------------------------------------------------------------------------- */

template<> int
GAListGenome<int>::write(ostream & os) const
{
    int *cur, *head;
    GAListIter<int> tmpiter(*this);
    if((head=tmpiter.head()) != 0) os << *head << " ";
    for(cur=tmpiter.next(); cur && cur != head; cur=tmpiter.next())
   os << *cur << " ";
    return os.fail() ? 1 : 0;
}
// force instantiations for compilers that do not do auto instantiation
// for some compilers (e.g. metrowerks) this must come after any
// specializations or you will get 'multiply-defined errors when you compile.
#if !defined(GALIB_USE_AUTO_INST)
#include <ga/GAList.C>
#include <ga/GAListGenome.C>
GALIB_INSTANTIATION_PREFIX GAList<int>;
GALIB_INSTANTIATION_PREFIX GAListGenome<int>;
#endif

void ListInitializer(GAGenome & c)
{
   GAListGenome<int> &child=(GAListGenome<int> &)c;
   while(child.head()) child.destroy(); // destroy any pre-existing list
   int n=11;
   child.insert(0,GAListBASE::HEAD); // the head node contains a '0'
   for(int i=1; i<n; i++)
   child.insert(i);        // each subsequent node contains a number
   for(int j=0; j<n; j++)
   child.swap(GARandomInt(0,n-1), GARandomInt(0,n-1));
}


void ArrayInitializer(GAGenome & c1)
{
GA1DArrayGenome<int> &child1=(GA1DArrayGenome<int> &) c1;
float low[1000];	
float  high[1000];
for(int i=0;i<1000;i++)
	{
		low[i] =0;		
	    high[i] =0;
	}
   for(int i=1;i<no_act;i++)
	{ 	  
		 low[i] =1;		
		 high[i] =act[i].maxr1/act[i].minr1;		
	}
	child1[0]=0;
	for(int j=1;j<no_act;j++)
	{
		child1[j]= GARandomFloat(low[j],high[j]) ;
		//cout<<child1[j]<<"\t";
	}
	//cout<<" "<<endl;
} 







int main(int argc, char *argv[])
{

	void setpriandfac(GAGenome & g);
	 //start of input section
	char line[1024];
    //file pointers
    FILE *input_ptr;    
    input_ptr=fopen("suba.txt","r"); 
	if(input_ptr==NULL)
	{
		cout<<"file is not opening"<<endl;
	}
	else
	  cout<<"file is opening";

	for (m=0;m<1000;m++)
    {
        act[m].duration=0;  
		 act[m].facduration=0;        
        act[m].startdate=0;
        act[m].minr1=0;
		act[m].facr1=0;
		act[m].maxr1=0;
		act[m].facr2=0;
		act[m].minr2=0;
        act[m].maxr2=0;
        act[m].pred1=0;
        act[m].pred2=0;       
        act[m].priority=0;
		act[m].priority1=0;
        act[m].delay=0;
        act[m].delay1=0;
        predone[m].duration=0;    
		predone[m].facduration=0;        
        predone[m].startdate=0;
        predone[m].maxr1=0;
		predone[m].minr1=0;
		predone[m].facr1=0;
		predone[m].facr2=0;
        predone[m].maxr2=0;
		predone[m].minr2=0;
        predone[m].pred1=0;
        predone[m].pred2=0;       
		predone[m].delay=0;
        predone[m].priority=0;
		predone[m].priority1=0;
		predone[m].delay1=0;
        predtwo[m].duration=0;
		predtwo[m].facduration=0;
		predtwo[m].delay=0;  
        predtwo[m].startdate=0;
        predtwo[m].minr1=0;
		predtwo[m].facr1=0;
		predtwo[m].facr2=0;
		predtwo[m].maxr1=0;
        predtwo[m].minr2=0;
		predtwo[m].maxr2=0;
        predtwo[m].pred1=0;
        predtwo[m].pred2=0;      
        predtwo[m].priority=0;
		predtwo[m].priority1=0;
		predtwo[m].delay1=0;
    } 
 for( i=0; i<1000; i++)
    {
        scheduledact[i]=0;
        eligibleact[i]=0;
    }


   m=1;    
    while (fgets(line,1024,input_ptr)!=NULL)                          //READING FROM THE INPUT FILE FOR ACTIVITY DATA
    {  
		char*tempduration11=strtok(line,"-");
		if(tempduration11==NULL)
		break;		
		act[m].duration=atoi(tempduration11);
		while(1)
		{
        
        char*tempminr1=strtok(NULL,"-");         
        if (tempminr1==NULL)
         {
             break;
         } 
		act[m].minr1=atoi(tempminr1);
		char*tempmaxr1=strtok(NULL,"-");        
        if (tempmaxr1==NULL)
         {
             break;
         } 
		act[m].maxr1=atoi(tempmaxr1);
		char*tempminr2=strtok(NULL,"-");   
        if (tempminr2==NULL)
         {
             break;
         }
		 act[m].minr2=atoi(tempminr2);
		char*tempmaxr2=strtok(NULL,"-");         
        if (tempmaxr2==NULL)
         {
             break;
         }
		act[m].maxr2=atoi(tempmaxr2);
       char*temppred1=strtok(NULL,"-");   
		 if (temppred1==NULL)
         {
             break;
         }
	  act[m].pred1=atoi(temppred1);
       char*temppred2=strtok(NULL,"-");    
       if (temppred2==NULL)
         {
             break;
         }
		  act[m].pred2=atoi(temppred2);
		  }
       m++;
    }
    no_act=m;    


    cout<<"Give availability of r1"<<endl;
    cin>>resource1;
    cout<<"Give availability of r2"<<endl;
    cin>>resource2;  

	for(m=0;m<1000;m++)
    {
        r1avail[m]=resource1;
        r2avail[m]=resource2;	
    }

/*for(int i=0;i<no_act;i++)
	{
		cout<<act[i].duration<<"\t"<<act[i].minr1<<"\t"<<act[i].maxr1<<"\t"<<act[i].minr2<<"\t"<<act[i].maxr2<<"\t"<<act[i].pred1<<"\t"<<act[i].pred2<<endl;
	}*/

//end of input section

//Setting priority ,factor getting objective
	for(int ii=1; ii<argc; ii++) {
    if(strcmp(argv[ii++],"seed") == 0) {
      GARandomSeed((unsigned int)atoi(argv[ii]));
		}
	}
	SubhaGenome genome(no_act, Objective);
	GASimpleGA ga(genome);
	ga.populationSize(2);
	ga.nGenerations(3);
	ga.pMutation(.01);
	ga.pCrossover(0.6);
	ga.minimize();  	
	ga.evolve();	
	genome=ga.statistics().bestIndividual();
	cout << "the ga generated the following list (objective score is ";
	cout << genome.score() << "):\n" << genome << "\n";   
	//void setpriandfac(GAGenome & g);
	return 0;
}

void setpriandfac(GAGenome & g)
{
		SubhaGenome & genome = (SubhaGenome &)g;
		GA1DArrayGenome<int>  & fac = genome.factorstr();
		GAListGenome <int>& pri = genome.priorityy();
	    int i;
	  /* short **pattern = ((SubhaData *)g.userData())->fac;
	   float *sequence = ((SubhaData *)g.userData())->pri;*/

		act[0].facr1=act[0].minr1* fac.gene(0) ;
		act[0].facr2=act[0].minr2* fac.gene(0) ;
		act[0].facduration=0;
		act[0].priority=*pri.head();
		
		for(i=1; i<fac.length(); i++)
		{			
				act[i].facr1=act[i].minr1* fac.gene(i) ;			
				act[i].facr2=act[i].minr2* fac.gene(i) ;
				act[i].facduration=act[i].duration/ fac.gene(i) ;
				act[i].priority=*pri.next() ;
		}

		/*cout<<"value of fac length"<<fac.length();

		for(i=1; i<fac.length(); i++)
		{			
				cout<<fac.gene(i) << "\t"<<act[i].priority<<endl;
		}*/
}

float Objective(GAGenome & g) 
{        		
		setpriandfac(g);
		temp=0;
		for(i=1; i<no_act; i++)
		{			
			temp=temp+act[i].facr1;
		}
		//cout<<"temp value"<<temp<<endl;
		return temp;
}