#include <iostream>

using namespace std;

////////////////////////////////////////////////////////////////
// Class che rappresenta una persona
class Persona {
  public:
    enum Genere { Pettegolo, Scettico, Neutrale };

    Persona();

    ~Persona();

    //void cambiaStato(int tipo);
    void cambiaStato(Genere tipo);
    
    // 0=pettegolo, 1=scettico, 2=altro
    //int stato() ;
    Genere stato() const;

    // // ritorna quanti pettegoli in piu' o in meno dopo l'interazione
    // int interagisci(Persona altro);

    // interagisce due persone
    void interagisci(Persona& altro);

  private:
    //int stato_; // 0=pettegolo, 1=scettico, 2=altro
    Genere stato_;
};

Persona::Persona() {
  //stato_=2;
  stato_= Neutrale;
}

Persona::~Persona() {
  //cout << "Aiuto muoio!" << endl;
}

//void Persona::cambiaStato(int tipo) {
void Persona::cambiaStato(Genere tipo) {
  stato_= tipo;
}

//int Persona::stato() {
Persona::Genere Persona::stato() const {
  return stato_;
}

void Persona::interagisci(Persona& altro) {

  // controllo di non interagire con me stesso
  if (&altro  == this ) return;
  // this e' un puntatore const a me stesso
  // stato();
  // this->stato();
  // (*this).stato();
 
  // se pettegolo con altro
  if (stato() == Pettegolo && altro.stato() == Neutrale) {
    altro.cambiaStato(Pettegolo);
  }

  // se neutrale con pettogolo
  else if (stato() == Neutrale && altro.stato() == Pettegolo) {
    cambiaStato(Pettegolo);
  }

  // se pettegolo con scettico
  else if (stato() == Pettegolo && altro.stato() == Scettico) {
    cambiaStato(Scettico);
  }

  // se scettico con pettegolo
  else if (stato() == Scettico && altro.stato() == Pettegolo) {
    altro.cambiaStato(Scettico);
  }

  // se pettegolo con pettogolo
  else if (stato() == Pettegolo && altro.stato() == Pettegolo) {
    cambiaStato(Scettico);
    altro.cambiaStato(Scettico);
  }
}

////////////////////////////////////////////////////////////////
class Popolazione {
  public:
    //Popolazione(); // default 1000 elementi
    Popolazione(int num = 1000); // num elementi

    ~Popolazione();

    const int dimensione() const ;

    void vivi();

    int contaPettegoli() const ;
    int contaScettici() const ;
    int contaNeutrali() const ;
    int conta(Persona::Genere tipo) const ;

    void print() const ;

    Persona& elemento(int num) ;
    const Persona& elemento(int num) const ;

  private:
    Persona* ilPopolo_; // array di persone
    const int numPersone_; // numero elementi

};

Popolazione::Popolazione(int num) : numPersone_(num) {
  //numPersone_ = num ; // errore
  ilPopolo_ = new Persona[numPersone_];

  // creiamo un pettegolo
  int primoPettegolo = (int)((1.*rand()/RAND_MAX)*dimensione());
  elemento(primoPettegolo).cambiaStato(Persona::Pettegolo);
}

Popolazione::~Popolazione() {
  delete [] ilPopolo_;
}

const int Popolazione::dimensione() const {
  return numPersone_;
}

void Popolazione::vivi(){
  while( contaPettegoli() > 0 ) {

    int p1 = (int)((1.*rand()/RAND_MAX)*dimensione());
    int p2 = (int)((1.*rand()/RAND_MAX)*dimensione());

    elemento(p1).interagisci(elemento(p2));

  }
}

int Popolazione::contaPettegoli() const {
  return conta(Persona::Pettegolo);
}

int Popolazione::contaScettici() const {
  return conta(Persona::Scettico);
}

int Popolazione::contaNeutrali() const {
  return conta(Persona::Neutrale);
}

int Popolazione::conta(Persona::Genere tipo) const {
  int result = 0;
  for ( int i = 0 ; i < dimensione() ; ++i) {
    if ( elemento(i).stato() == tipo ) result++;
  }
  return result;

}

void Popolazione::print() const {
  cout << "Pettegoli " << contaPettegoli() <<
    " Scettici " << contaScettici() <<
    " Neutrali " << contaNeutrali() << endl;
}

Persona& Popolazione::elemento(int num) {
  return ilPopolo_[num];
}

const Persona& Popolazione::elemento(int num) const {
  return ilPopolo_[num];
}

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

  int num = 1000;
  if (argn==2) {
    num = atoi(argc[1]);
  }

  Popolazione ilPopolo(num);
  ilPopolo.vivi();

  ilPopolo.print();
}

// int main(){
//   Popolazione primo;
//   Popolazione secondo(1321);

//   // Persona stefano;
//   // Persona Andrea;

//   // stefano.interagisci(stefano);
//   // stefano.interagisci(Andrea);
//   // //Andrea.interagisci(stefano);

//   // creo N persone
//   Persona popolazione[1000];
//   
//   // definisco il primo pettegolo
//   /// numero a caso
//   int primoPettegolo = (int)((1.*rand()/RAND_MAX)*1000);
//   /// setto lo stato a pettegolo
//   popolazione[primoPettegolo].cambiaStato(Persona::Pettegolo);


//   int numPettegoli = 1;
//   while (numPettegoli > 0 ) {
//   // faccio incotrare a caso due persone 
//     int p1 = (int)((1.*rand()/RAND_MAX)*1000);
//     int p2 = (int)((1.*rand()/RAND_MAX)*1000);

//     //cout << "p1 " << popolazione[p1].stato() << " p2 "<< popolazione[p2].stato() << endl;
//     int variazionePettegoli = popolazione[p1].interagisci(popolazione[p2]);
//     //cout << "variazionePettegoli " << variazionePettegoli << endl;

//     // conto i pettegoli dopo l'interazione
//     numPettegoli+=variazionePettegoli;

//   // vado avanti finche' non ci sono piu' pettegoli
//   }

//   // stampare num scettici e numero di neutrali
//   int numNeutrali=0;
//   int numScettici=0;
//   numPettegoli=0;
//   for (int i =0 ; i<1000; ++i){
//     if (popolazione[i].stato() == Persona::Scettico  ) numScettici++;
//     else if (popolazione[i].stato() == Persona::Neutrale ) numNeutrali++;
//     else if (popolazione[i].stato() == Persona::Pettegolo ) numPettegoli++;
//   }

//   cout << "Numero Scettici " << numScettici << endl;
//   cout << "Numero Neutrali " << numNeutrali << endl;
//   cout << "Numero Pettegoli " << numPettegoli << endl;

//   return 0;
// }


// // esempio array
//     // int a[100];

//       
//     // int primo = a[0];
//     // int primt = (*a);

//     // int secondo = a[1];
//     // int secondo = *(a+1);