#include <iostream>

using namespace std;

class Persona {
  public:
    enum Genere { Neutrale, Scettico, Pettegolo };

    Persona() ;

    //int stato() const ;
    Genere stato() const ;

    //void cambiaStato(const int& stato);
    void cambiaStato(const Genere& stato);

    void incontra(Persona& altro);

    void print() const ;
  private:
    //int stato_; // 0=neutrale, 1= scettico, 2=pettegolo

    Genere stato_;
    //const float piGreco;
};

//Persona::Persona() : stato_(0), piGreco(3.14) {
//Persona::Persona() : stato_(0) {
Persona::Persona() : stato_(Neutrale) {
  //stato_= 0;
  //piGreco = 3.14; NO!
}

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

void Persona::cambiaStato(const Genere& stato){
  stato_ = stato;
}

void Persona::incontra(Persona& altro){
  // controllo se sto incotrando me stesso
  if ( this == &altro) return;

  // controllo se incotro tra:
  // pettegolo - neutrale

  //if ( ( this )->stato() // mestesso.stato()

  /// pettegolo resta pettegolo
  /// neutrale -> pettegolo
  if ( stato() == Pettegolo && altro.stato() == Neutrale ) {
    altro.cambiaStato(Pettegolo);
  }
  else if ( stato() == Neutrale && altro.stato() == Pettegolo ) {
    cambiaStato(Pettegolo);
  }
  // pettegolo - scettico
  else if ( stato() == Pettegolo && altro.stato() == Scettico ) {
    cambiaStato(Scettico);
  }
  else if ( stato() == Scettico && altro.stato() == Pettegolo ) {
    altro.cambiaStato(Scettico);
  }
  // pettegolo - pettegolo
  else if ( stato() == Pettegolo && altro.stato() == Pettegolo ) {
    cambiaStato(Scettico);
    altro.cambiaStato(Scettico);
  }
}

void Persona::print() const {
  cout << "Io sono un " ;

  if (stato() == Pettegolo ) cout << " Pettegolo ";
  else if (stato() == Scettico ) cout << " Scettico ";
  else if (stato() == Neutrale ) cout << " Neutrale ";
  else cout << " non ne ho proprio idea ";

  cout << endl;

}


ostream& operator<<(ostream& out, const Persona& p) {
  out << "Io sono un " ;

  if (p.stato() == Persona::Pettegolo ) out << " Pettegolo ";
  else if (p.stato() == Persona::Scettico ) out << " Scettico ";
  else if (p.stato() == Persona::Neutrale ) out << " Neutrale ";
  else out << " non ne ho proprio idea ";

  //out << endl;

  return out;
}

class Popolazione {
  public:
    Popolazione(int num=1000); // construttore con numero di persone

    ~Popolazione();

    Persona& persona(int n) ; // <---
    const Persona& persona(int n) const; // <---

    int contaPettegoli() const;
    int contaScettici() const;
    int contaNeutrali() const;

    void evolvi() ;

    int dimensionePopolazione() const {
      return dimensionePopolazione_;
    }

  private:
    int conta(Persona::Genere tipo) const ;

    const int dimensionePopolazione_ ; // quante persone ci sono
    Persona* ilPopolo_; // array di "Persona"
};

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

  //crea pettegolo
  int pettegolo = (int)((1.*rand()/RAND_MAX)*dimensionePopolazione());
  persona(pettegolo).cambiaStato(Persona::Pettegolo);
}

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

Persona& Popolazione::persona(int n) {
  return ilPopolo_[n];
}

const Persona& Popolazione::persona(int n) const {
  return ilPopolo_[n];
}

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 ;
  //loop su popolo
  for (int i=0; i<dimensionePopolazione() ; ++i )                                    
    if (persona(i).stato()== tipo ) result++;
  return result;
}

ostream& operator<<(ostream& out, const Popolazione& p) {
  out << "Pettegoli " << p.contaPettegoli() << 
    " Scettici " << p.contaScettici() <<
    " Neutrali " << p.contaNeutrali();

  return out;
}

void Popolazione::evolvi() {
  // finche' ci sono pettegoli in giro
  while (contaPettegoli() >0 ) {

    // prendo due persone a caso
    int p1 = (int)((1.*rand()/RAND_MAX)*dimensionePopolazione());
    int p2 = (int)((1.*rand()/RAND_MAX)*dimensionePopolazione());

    // le faccio incontrare (e quindi cambieranno stato se e' il caso)
    persona(p1).incontra(persona(p2));

    // conto i pettegoli e evntualmente vado avanti con altre due persone
  }
}

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

  Popolazione ilPopolo(num);
  cout << ilPopolo << endl;
  ilPopolo.evolvi();

  cout << ilPopolo << endl;
  //cout.operator<<(cout, ilPopolo);

  // //stampare numero scettici e neutrali
  // cout << "Scettici " << ilPopolo.contaScettici() << endl;
  
}

  // int main() {
  // Popolazione popolo(99); // costruisco 99 persone
  // Popolazione altroPopolo; // costruisco con num=1000

  // Persona marco;
  // Persona stefano;

  // int a =100;
  // cout << "A = " << a << endl;


  // // cout << a << " pippo " << marco;
  // // //cout = operator<<(cout, marco) ;

  // cout << "Marco " << marco << endl;
  // cout << "Stefano " << stefano << endl;

  // marco.cambiaStato(Persona::Pettegolo);
  // stefano.cambiaStato(Persona::Scettico);

  // cout << "Marco " << marco << endl;
  // cout << "Stefano " << stefano << endl;

  // marco.incontra(stefano);

  // cout << "Marco " << marco << endl;
  // cout << "Stefano " << stefano << endl;
  // }
// esempio uso array

    // int pippo[100];

    // int primoElementoDiPippo = pippo[0];
    // int primoElementoDiPippo = *pippo;

    // int secondoElementoDiPippo = pippo[1];
    // int secondoElementoDiPippo = *(pippo+1);