#include <iostream>
#include <algorithm>
#include <functional>
#include <numeric>

using namespace std;

class Pritisci {
  double *pritisak;
  double min_pritisak, max_pritisak;
  int max_br, br_upisanih;
  public:

  Pritisci (int max, double min_pr, double max_pr);
  ~Pritisci () {delete [] pritisak;}
  Pritisci (const Pritisci &p);
  Pritisci &Pritisci::operator =(const Pritisci &p);
  int DajBrojUpisanih () {return br_upisanih;}
  void UpisiNovi (double novi);
  void Izbrisi () { fill_n (pritisak, br_upisanih, 0); br_upisanih=0;}
  double DajProsjecni ();
  double DajNajmanji ();
  double DajNajveci ();
  int VeciOd (double broj);
  int ManjiOd (double broj);
  void Ispisi();
  friend Pritisci operator + (const Pritisci &p, double y);
  friend Pritisci operator + (double x, const Pritisci &p) {return p+x;}
  friend Pritisci operator + (const Pritisci &p1, const Pritisci &p2);
  friend Pritisci operator - (const Pritisci &p, double y);
  friend Pritisci operator - (double y, const Pritisci &p) {return p-y;}
  friend Pritisci operator - (const Pritisci &p1, const Pritisci &p2);
  friend Pritisci operator -= (Pritisci &p, double x) {p= p-x; return p;}
  friend Pritisci operator -= (Pritisci &p1,const Pritisci &p2) {return p1= p1-p2;}
  friend Pritisci operator += (Pritisci &p, double x) {return p= p+x;}
  friend Pritisci operator += (Pritisci &p1,const Pritisci &p2) {return p1= p1+p2;}
  friend Pritisci &operator ++ (Pritisci &p) {return p=p+1;}
  friend Pritisci &operator ++ (Pritisci &p, int);
  friend Pritisci &operator -- (Pritisci &p) {return p=p-1;}
  friend Pritisci &operator -- (Pritisci &p, int);
  double operator [] (int) const;
  double &operator [] (int);
  friend bool operator == (const Pritisci &p1, const Pritisci &p2);
  friend bool operator != (const Pritisci &p1, const Pritisci &p2) {return !(p1==p2);}

};


  Pritisci::Pritisci (int max, double min_pr, double max_pr){
      pritisak= new double [max];
      max_br=max;
      for (int i=0; i<max; i++)
      pritisak[i]=0;
      max_pritisak=max_pr; min_pritisak=min_pr; br_upisanih=0;
  }


  Pritisci::Pritisci (const Pritisci &p) {
      min_pritisak =p.min_pritisak; max_pritisak=p.max_pritisak;
      max_br=p.max_br; br_upisanih=p.br_upisanih;
      pritisak =new double [p.max_br];
      copy(p.pritisak, p.pritisak + max_br, pritisak);
  }

  Pritisci::Pritisci &Pritisci::operator =(const Pritisci &p) {
      if (max_br<p.max_br)
      {
          delete[] pritisak;
          pritisak =new double [p.max_br];
      }
      max_br= p.max_br; br_upisanih=p.br_upisanih;
      copy (p.pritisak, p.pritisak + max_br, pritisak);
      return *this;
  }


  void Pritisci::UpisiNovi (double novi) {
      if (novi < min_pritisak) throw "Nedozvoljeno mala vrijednost pritiska";
      if (novi > max_pritisak) throw "Nedozvoljeno velika vrijednost pritiska";
      if (br_upisanih==max_br) throw "Vec je upisan maksimalan broj pritisaka";
      pritisak [br_upisanih]=novi;
  }

  double Pritisci::DajProsjecni () {
      if(br_upisanih==0) throw "nema unesneih pritisaka";
      return (accumulate (pritisak, &pritisak[br_upisanih], 0)/double(br_upisanih));
  }

  double Pritisci::DajNajmanji (){
      if(br_upisanih==0) throw "nema unesneih pritisaka";
      return *min_element (pritisak, pritisak + br_upisanih);
  }

  double Pritisci::DajNajveci () {
      if(br_upisanih==0) throw "nema unesneih pritisaka";
      return *max_element (pritisak, pritisak + br_upisanih);
  }

int Pritisci::VeciOd (double broj) {
    if ((br_upisanih)==0) throw "nema unesenih pritisaka";
    return count_if(pritisak, pritisak + max_br, bind2nd(greater <double>(),broj));
}

int Pritisci::ManjiOd (double broj) {
    if(br_upisanih==0) throw "nema unesneih pritisaka";
    return count_if (pritisak, pritisak + max_br, bind2nd(less <double>(),broj));
}

void Pritisci::Ispisi() {
    double *p(new double [br_upisanih]);
    partial_sort_copy (pritisak, pritisak + br_upisanih, p, p+br_upisanih);
    for (int i=br_upisanih-1; i>=0; i--)
    cout <<p[i] <<endl;
    delete [] p;
}

Pritisci operator + (const Pritisci &p, double y) {
    Pritisci p1(p.max_br, p.min_pritisak +y, p.max_pritisak + y);
    transform (p.pritisak, p.pritisak + p.br_upisanih, p1.pritisak, bind2nd(plus<double>(), y));
    return p1;
}

Pritisci operator - (const Pritisci &p, double y) {
    Pritisci p1(p.max_br, p.min_pritisak -y, p.max_pritisak - y);
    transform (p.pritisak, p.pritisak + p.br_upisanih, p1.pritisak, bind2nd(minus<double>(), y));
    return p1;
}

Pritisci operator + (const Pritisci &p1, const Pritisci &p2) {
    if (p1.br_upisanih != p2.br_upisanih) throw "zadani pritisci se ne mogu sabrati";
    Pritisci p3(p1.max_br, p1.min_pritisak - p2.max_pritisak, p1.max_pritisak - p2.min_pritisak);
    transform (p1.pritisak, p1.pritisak + p1.br_upisanih, p2.pritisak, p3.pritisak, plus<double>());
    return p3;
}

Pritisci operator - (const Pritisci &p1, const Pritisci &p2) {
    if (p1.br_upisanih != p2.br_upisanih) throw "zadani pritisci se ne mogu oduzeti";
    Pritisci p3(p1.max_br, p1.min_pritisak - p2.max_pritisak, p1.max_pritisak - p2.min_pritisak);
    transform (p1.pritisak, p1.pritisak + p1.br_upisanih, p2.pritisak, p3.pritisak, minus<double>());
    return p3;
}

Pritisci &operator ++ (Pritisci &p, int){
    Pritisci p1(p);
    ++p;
    return p1;
}

Pritisci &operator -- (Pritisci &p, int){
    Pritisci p1(p);
    --p;
    return p1;
}

double Pritisci::operator [] (int n) const {
    if (n<1 || n>max_br) throw "Pogresan indeks!";
    return pritisak[n-1];
}

double &Pritisci::operator [] (int n){
    if (n<1 || n>max_br) throw "Pogresan indeks!";
    return pritisak[n-1];
}

bool operator == (const Pritisci &p1, const Pritisci &p2){
    return ((p1.br_upisanih == p2.br_upisanih)&& equal (p1.pritisak, p1.pritisak + p1.br_upisanih, p2.pritisak));
}





int main()
{
    Pritisci p(3, 1, 10);       //pravim primjerak pomocu konstruktora
    Pritisci p1(p);             //kopiram pritisak pomocu konstruktora kopije

    p.Ispisi();
    p1.Ispisi();


    double a, b;

    cout <<"koliko pritisaka zelite unijeti?" <<endl;
    cin>>a;
    cout <<"Unesite pritiske: " <<endl;
    for (int i=0; i<a; i++)
    {
        cin>> b;                                //isprobavanje metoda
        p.UpisiNovi(b);                         //
    }
    cout <<"Unijeli ste " <<p.DajBrojUpisanih() <<" vrijednosti pritiska." <<endl;
    cout <<"Od unesenih pritisaka najmanji je " <<p.DajNajmanji() <<", a najveci " <<p.DajNajveci() <<endl;
    cout <<"Prosjecna vrijednost pritiska iznosi " <<p.DajProsjecni() <<endl;

    cout <<"Pritisci sortirani po opadajucem poretku: " <<endl;
    p.Ispisi();

    cout <<endl <<"Unesite novu vrijednost prvog pritiska" <<endl;
    cin>>a;
    p.UpisiNovi(a);
    cout <<"Unesite novu vrijednost drugog pritiska" <<endl;
    cin>>a;

    cout<<"Pritisci sad sadrze vrijednosti: " <<endl;
    p1.UpisiNovi(a);
    cout <<"p1= "; p.Ispisi();
    cout <<"i:" <<endl <<"p2= ";
    p1.Ispisi();                                //provjera za operatore

    cout <<"a nakon kopiranja izgleda ovako: " <<endl;
    p1=p;
    cout <<"p1= "; p.Ispisi();
    cout <<"p2= "; p1.Ispisi();
    Pritisci p2(4, 2, 10);
    p+=3;
    p2=p+p1;
    cout <<endl;
    p2.Ispisi();
    cout <<endl;
    p2-=p1;
    p2.Ispisi();
    cout <<endl;
    p2++;
    p2.Ispisi();


    cout << "Hello world!" << endl;
    return 0;
}