#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdlib>
using namespace std;

std::fstream plik;


class statyczna{
    static statyczna *ptr_cos;
};

class produkty{
friend class plyta_glowna;
public:
produkty(void);

class plyta_glowna{
friend class klient;
friend klient *dodaj_klienta(klient *, int &);
friend klient *destroy_klient(klient *, int &, int &);
friend void pokaz(plyta_glowna *,int );
friend int pokaz(klient *, int );
private:
    string producent;
    string gniazdo_procesora;
    int max_ilosc_pamieci;
    int zlacze_PCI;
    int usb_3;
    int cena;
public:
    plyta_glowna(void){};
    ~plyta_glowna(void){cout<<"Destruktor zostal uzyty";};

     plyta_glowna *create_plyta_glowna ()
 {
     plyta_glowna *temp;
     int rozmiar;
     int i;

        plik.open( "plyty_glowne.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new plyta_glowna[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].gniazdo_procesora;
                    plik >> temp[i].max_ilosc_pamieci;
                    plik >> temp[i].zlacze_PCI;
                    plik >> temp[i].usb_3;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else cout << "Dostep do pliku zostal zabroniony!" << endl;


            return temp;
 }

    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    string getgniazdo_procesora(){return gniazdo_procesora;}
    void setgniazdo_procesora(string gniazdo_procesora_set){gniazdo_procesora = gniazdo_procesora_set;}
    int getmax_ilosc_pamieci(){return max_ilosc_pamieci;}
    void setmax_ilosc_pamieci(int max_ilosc_pamieci_set){max_ilosc_pamieci = max_ilosc_pamieci_set;}
    int getzlacze_PCI(){return zlacze_PCI;}
    void setzlacze_PCI(int zlacze_PCI_set){zlacze_PCI = zlacze_PCI_set;}
    int getusb_3(){return usb_3;}
    void setusb_3(int usb_3_set){cena = usb_3_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}


    void pokaz()
    {
        cout << "Nazwa: " << producent << endl;
        cout << "Gniazdo procesora: " << gniazdo_procesora << endl;
        cout << "Max pamieci ram: " << max_ilosc_pamieci << "GB" <<endl;

        if(zlacze_PCI == 1)
            cout << "Zlacze PCI-E: Tak" << endl;
        else
            cout << "Zlacze PCI-E: Nie" << endl;

        if(usb_3 == 1)
            cout << "USB 3.0: Tak" << endl;
        else
            cout << "USB 3.0: Nie" << endl;

        cout << "Cena: " <<cena << "zl\n" << endl;
    }

};

};
produkty::produkty(void){};

class procesor{
friend procesor *create_procesor();
friend class klient;
friend klient *dodaj_klienta(klient *, int &);
friend klient *destroy_klient(klient *, int &, int &);
friend void pokaz(procesor *,int );
friend int pokaz(klient *, int );

    int cena;
    float zegar;
    string rdzen;
    string producent;

    public:
    procesor(void);

    procesor(const procesor &kopia)
    {

        cena=kopia.cena;
        zegar=kopia.zegar;
        rdzen=kopia.rdzen;
        producent=kopia.producent;
    }


    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    string getrdzen(){return rdzen;}
    void setrdzen(string rdzen_set){rdzen = rdzen_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}
    float getzegar(){return zegar;}
    void setzegar(float zegar_set){zegar = zegar_set;}


    void pokaz()
    {
        cout << "Producent: " << producent << endl;
        cout << "Rdzen: " << rdzen << endl;
        cout << "Zegar: " << zegar << "GHz" <<endl;
        cout << "Cena: " << cena << "zl\n" <<endl;
    }
};
procesor::procesor(void){};

 class kgraficzna{
friend kgraficzna *create_kgraficzna();
friend class klient;
friend klient *destroy_klient(klient *, int &, int &);
friend klient *dodaj_klienta(klient *, int &);
friend void pokaz(kgraficzna *,int );
friend int pokaz(klient *, int );

 private:
    int cena;
    int ilosc_pamieci;
    int typ_pamieci;
    int crossfire;
    string producent;

 public:
        kgraficzna(void);

    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}
    int getilosc_pamieci(){return ilosc_pamieci;}
    void setilosc_pamieci(int ilosc_pamieci_set){ilosc_pamieci = ilosc_pamieci_set;}
    int gettyp_pamieci(){return typ_pamieci;}
    void settyp_pamieci(int typ_pamieci_set){typ_pamieci = typ_pamieci_set;}
    int getcrossfire(){return crossfire;}
    void setcrossfire(int crossfire_set){crossfire = crossfire_set;}

    void pokaz()
    {
        cout << "Nazwa: " << producent << endl;
        cout << "Ilosc pamieci: " << ilosc_pamieci << "MB" <<endl;
        cout << "Typ pamieci: GDDR " << typ_pamieci <<endl;
        if(crossfire == 1)
            cout << "Crossfire: Tak" << endl;
        else
            cout << "Crossfire: Nie" << endl;
        cout << "Cena: " << cena << "zl\n" <<endl;
    }

};
kgraficzna::kgraficzna(void){};

class pamiec_ram{
    friend pamiec_ram *create_pamiec_ram();
    friend class klient;
    friend klient *destroy_klient(klient *, int &, int &);
    friend klient *dodaj_klienta(klient *, int &);
    friend void pokaz(pamiec_ram *,int );
    friend int pokaz(klient *, int );
private:
    string producent;
    int ddr;
    int ilosc_pamieci;
    int ilosc_kosci;
    int taktowanie;
    int cena;
public:
    pamiec_ram(void);

    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}
    int getilosc_pamieci(){return ilosc_pamieci;}
    void setilosc_pamieci(int ilosc_pamieci_set){ilosc_pamieci = ilosc_pamieci_set;}
    int getilosc_kosci(){return ilosc_kosci;}
    void setilosc_kosci(int ilosc_kosci_set){ilosc_kosci = ilosc_kosci_set;}
    int getddr(){return ddr;}
    void setddr(int ddr_set){ddr = ddr_set;}
    int gettaktowanie(){return taktowanie;}
    void settaktowanie(int taktowanie_set){taktowanie = taktowanie_set;}

    void pokaz()
    {
        cout << "Nazwa: " << producent << endl;
        cout << "Typ pamieci: DDR " << ddr << endl;
        cout << "Ilosc pamieci: " << ilosc_pamieci << "GB" <<endl;
        cout << "Ilosc kosci: " << ilosc_kosci << endl;
        cout << "Taktowanie: " << taktowanie << "MHz" << endl;
        cout << "Cena: " <<cena << "zl\n" << endl;
    }
};
pamiec_ram::pamiec_ram(void){};

class dysk_twardy{
    friend class klient;
    friend dysk_twardy *create_dysk_twardy();
    friend klient *destroy_klient(klient *, int &, int &);
    friend klient *dodaj_klienta(klient *, int &);
    friend void pokaz(dysk_twardy *,int );
    friend int pokaz(klient *, int );
private:
    string producent;
    int pojemnosc;
    int pamiec_cache;
    int transfer_zewnetrzny;
    int cena;

public:

    dysk_twardy(void);

    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}
    int getpojemnosc(){return pojemnosc;}
    void setpojemnosc(int pojemnosc_set){pojemnosc = pojemnosc_set;}
    int getpamiec_cache(){return pamiec_cache;}
    void setpamiec_cache(int pamiec_cache_set){pamiec_cache = pamiec_cache_set;}
    int gettransfer_zewnetrzny(){return transfer_zewnetrzny;}
    void settransfer_zewnetrzny(int transfer_zewnetrzny_set){transfer_zewnetrzny = transfer_zewnetrzny_set;}

    void pokaz()
    {
        cout << "Nazwa: " << producent << endl;
        cout << "Pojemnosc: " << pojemnosc << "GB" << endl;
        cout << "Pamiec Cache: " << pamiec_cache << "MB" <<endl;
        cout << "Szybkosc transferu: " << transfer_zewnetrzny << "MB" << endl;
        cout << "Cena: " << cena << "zl\n" << endl;
    }
};

dysk_twardy::dysk_twardy(void){};

 class kmuzyczna {
     friend kmuzyczna *create_kmuzyczna ();
     friend klient *destroy_klient(klient *, int &, int &);
     friend class klient;
     friend klient *dodaj_klienta(klient *, int &);
     friend void pokaz(kmuzyczna *,int );
     friend int pokaz(klient *, int );

 private:
     string producent;
     int czestotliwosc_probkowania;
     int ilosc_obslugiwanych_glowsnikow;
     int cena;
 public:
         kmuzyczna(void);

    string getproducent(){return producent;}
    void setproducent(string producent_set){producent = producent_set;}
    int getcena(){return cena;}
    void setcena(int cena_set){cena = cena_set;}
    int getczestotliwosc_probkowania(){return czestotliwosc_probkowania;}
    void setczestotliwosc_probkowania(int czestotliwosc_probkowania_set){czestotliwosc_probkowania = czestotliwosc_probkowania_set;}
    int getilosc_obslugiwanych_glowsnikow(){return ilosc_obslugiwanych_glowsnikow;}
    void setilosc_obslugiwanych_glowsnikow(int ilosc_obslugiwanych_glowsnikow_set){ilosc_obslugiwanych_glowsnikow = ilosc_obslugiwanych_glowsnikow_set;}

     void pokaz()
     {
        cout << "Nazwa: " << producent << endl;
        cout << "Czestotliwosc propkowania: " << czestotliwosc_probkowania << "KHz" << endl;
        cout << "Ilosc obslugowanych_glosnikow: " << ilosc_obslugiwanych_glowsnikow <<endl;
        cout << "Cena: " << cena << "zl\n" << endl;
    }
 };

  kmuzyczna::kmuzyczna(void){};

 class klient{
     friend klient *dodaj_klienta(klient *, int &);
     friend klient *destroy_klient(klient *, int &, int &);
     friend void create_klient(klient *);
     friend int pokaz(klient *, int );

    string imie;
    string nazwisko;
    string ulica;
    string nr_domu;
    string nr_mieszkania;
    string miasto;

public:

    klient(void);
    string getimie(){return imie;}
    void setimie(string imie_set){imie = imie_set;}
    string getnazwisko(){return nazwisko;}
    void setnazwisko(string nazwisko_set){nazwisko = nazwisko_set;}
    string getulica(){return ulica;}
    void setulica(string ulica_set){ulica = ulica_set;}
    string getnr_domu(){return nr_domu;}
    void setnr_domu(string nr_domu_set){nr_domu = nr_domu_set;}
    string getnr_mieszkania(){return nr_mieszkania;}
    void setnr_mieszkania(string nr_mieszkania_set){nr_mieszkania = nr_mieszkania_set;}
    string getmiasto(){return miasto;}
    void setmiasto(string miasto_set){miasto = miasto_set;}

    int zamowienie[6];

    produkty::plyta_glowna a;
    procesor b;
    kgraficzna c;
    pamiec_ram d;
    dysk_twardy e;
    kmuzyczna f;

    void pokaz()
    {
        cout << "Imie: " << imie << endl;
        cout << "Nazwisko: " << nazwisko << endl;
        cout << "Ulica: " << ulica << endl;
        cout << "Numer domu: " << nr_domu << endl;
        cout << "Numer mieszkania: " << nr_mieszkania << endl;
        cout << "Miasto: " << miasto << endl;

    }
};

 klient::klient(void){};

//////////////////////////////////////////// funkcje create(tworzy tablice prosuktow z pliku) //////////////////////////


procesor *create_procesor ()
 {
     procesor *temp;
     int rozmiar ,i;

        plik.open( "procesory.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new procesor[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].rdzen;
                    plik >> temp[i].zegar;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else std::cout << "Dostep do pliku zostal zabroniony!" << std::endl;
            return temp;
 }

 kgraficzna *create_kgraficzna ()
 {
     kgraficzna *temp;
     int rozmiar ,i;

        plik.open( "karty_graficzne.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new kgraficzna[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].ilosc_pamieci;
                    plik >> temp[i].typ_pamieci;
                    plik >> temp[i].crossfire;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else std::cout << "Dostep do pliku zostal zabroniony!" << std::endl;
            return temp;
 }

 pamiec_ram *create_pamiec_ram ()
  {
     pamiec_ram *temp;
     int rozmiar ,i;

        plik.open( "ram.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new pamiec_ram[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].ddr;
                    plik >> temp[i].ilosc_kosci;
                    plik >> temp[i].ilosc_pamieci;
                    plik >> temp[i].taktowanie;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else std::cout << "Dostep do pliku zostal zabroniony!" << std::endl;
            return temp;
  }

 dysk_twardy *create_dysk_twardy ()
  {
     dysk_twardy *temp;
     int rozmiar ,i;

        plik.open( "dyski_twarde.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new dysk_twardy[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].pojemnosc;
                    plik >> temp[i].pamiec_cache;
                    plik >> temp[i].transfer_zewnetrzny;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else std::cout << "Dostep do pliku zostal zabroniony!" << std::endl;
            return temp;
  }

 kmuzyczna *create_kmuzyczna ()
 {
     kmuzyczna *temp;
     int rozmiar ,i;

        plik.open( "karty_muzyczne.txt", std::ios::in);
            if( plik.good() == true )
            {
                plik >> rozmiar;
                temp = new kmuzyczna[rozmiar];

                for(i=0;i<rozmiar;i++)
                {
                    plik >> temp[i].producent;
                    plik >> temp[i].czestotliwosc_probkowania;
                    plik >> temp[i].ilosc_obslugiwanych_glowsnikow;
                    plik >> temp[i].cena;
                }
                plik.close();
            }
            else std::cout << "Dostep do pliku zostal zabroniony!" << std::endl;
            return temp;
 }

 klient *dodaj_klienta(klient *aha, int &rozmiar)
{
        klient *temp = new klient[rozmiar+1];

    int i, j;

    for(i = 0; i < rozmiar;i++)
    {

        temp[i].imie = aha[i].imie;
        temp[i].nazwisko = aha[i].nazwisko;
        temp[i].miasto = aha[i].miasto;
        temp[i].ulica = aha[i].ulica;
        temp[i].nr_domu = aha[i].nr_domu;
        temp[i].nr_mieszkania = aha[i].nr_mieszkania;

        temp[i].a.gniazdo_procesora = aha[i].a.gniazdo_procesora;
        temp[i].a.max_ilosc_pamieci = aha[i].a.max_ilosc_pamieci;
        temp[i].a.zlacze_PCI = aha[i].a.zlacze_PCI;
        temp[i].a.usb_3 = aha[i].a.usb_3;
        temp[i].a.cena = aha[i].a.cena;

        temp[i].b.cena = aha[i].b.cena;
        temp[i].b.zegar = aha[i].b.zegar;
        temp[i].b.rdzen = aha[i].b.rdzen;
        temp[i].b.producent = aha[i].b.producent;

        temp[i].c.cena = aha[i].c.cena;
        temp[i].c.ilosc_pamieci = aha[i].c.ilosc_pamieci;
        temp[i].c.typ_pamieci = aha[i].c.typ_pamieci;
        temp[i].c.crossfire = aha[i].c.crossfire;
        temp[i].c.producent = aha[i].c.producent;

        temp[i].d.producent = aha[i].d.producent;
        temp[i].d.ddr = aha[i].d.ddr;
        temp[i].d.ilosc_pamieci = aha[i].d.ilosc_pamieci;
        temp[i].d.ilosc_kosci = aha[i].d.ilosc_kosci;
        temp[i].d.taktowanie = aha[i].d.taktowanie;
        temp[i].d.cena = aha[i].d.cena;

        temp[i].e.producent = aha[i].e.producent;
        temp[i].e.pojemnosc = aha[i].e.pojemnosc;
        temp[i].e.pamiec_cache = aha[i].e.pamiec_cache;
        temp[i].e.transfer_zewnetrzny = aha[i].e.transfer_zewnetrzny;
        temp[i].e.cena = aha[i].e.cena;

        temp[i].f.producent = aha[i].f.producent;
        temp[i].f.czestotliwosc_probkowania = aha[i].f.czestotliwosc_probkowania;
        temp[i].f.ilosc_obslugiwanych_glowsnikow = aha[i].f.ilosc_obslugiwanych_glowsnikow;
        temp[i].f.cena = aha[i].f.cena;

        for(j = 0; j< 6; j++)
        {
            temp[i].zamowienie[j] = aha[i].zamowienie[j];
        }
    }
    rozmiar++;
    return temp;
}

///////////////////////////////////////// koniec funkcji tworzenia /////////////////////////////////

klient *destroy_klient(klient *aha, int &rozmiar, int &usuwanie)
{
    if(rozmiar == 1)
    {
        aha[0].~klient();
        aha = NULL;
        return aha;
    }
    else
    {
    klient *temp = new klient[rozmiar-1];
    int i, j;

    usuwanie--;

    for(i = 0; i < usuwanie; i++)
    {
        temp[i].imie = aha[i].imie ;
        temp[i].nazwisko = aha[i].nazwisko;
        temp[i].miasto = aha[i].miasto;
        temp[i].ulica = aha[i].ulica;
        temp[i].nr_domu = aha[i].nr_domu;
        temp[i].nr_mieszkania = temp[i].nr_mieszkania;

        temp[i].imie = aha[i].imie;
        temp[i].nazwisko = aha[i].nazwisko;
        temp[i].miasto = aha[i].miasto;
        temp[i].ulica = aha[i].ulica;
        temp[i].nr_domu = aha[i].nr_domu;
        temp[i].nr_mieszkania = aha[i].nr_mieszkania;

        temp[i].a.gniazdo_procesora = aha[i].a.gniazdo_procesora;
        temp[i].a.max_ilosc_pamieci = aha[i].a.max_ilosc_pamieci;
        temp[i].a.zlacze_PCI = aha[i].a.zlacze_PCI;
        temp[i].a.usb_3 = aha[i].a.usb_3;
        temp[i].a.cena = aha[i].a.cena;

        temp[i].b.cena = aha[i].b.cena;
        temp[i].b.zegar = aha[i].b.zegar;
        temp[i].b.rdzen = aha[i].b.rdzen;
        temp[i].b.producent = aha[i].b.producent;

        temp[i].c.cena = aha[i].c.cena;
        temp[i].c.ilosc_pamieci = aha[i].c.ilosc_pamieci;
        temp[i].c.typ_pamieci = aha[i].c.typ_pamieci;
        temp[i].c.crossfire = aha[i].c.crossfire;
        temp[i].c.producent = aha[i].c.producent;

        temp[i].d.producent = aha[i].d.producent;
        temp[i].d.ddr = aha[i].d.ddr;
        temp[i].d.ilosc_pamieci = aha[i].d.ilosc_pamieci;
        temp[i].d.ilosc_kosci = aha[i].d.ilosc_kosci;
        temp[i].d.taktowanie = aha[i].d.taktowanie;
        temp[i].d.cena = aha[i].d.cena;

        temp[i].e.producent = aha[i].e.producent;
        temp[i].e.pojemnosc = aha[i].e.pojemnosc;
        temp[i].e.pamiec_cache = aha[i].e.pamiec_cache;
        temp[i].e.transfer_zewnetrzny = aha[i].e.transfer_zewnetrzny;
        temp[i].e.cena = aha[i].e.cena;

        temp[i].f.producent = aha[i].f.producent;
        temp[i].f.czestotliwosc_probkowania = aha[i].f.czestotliwosc_probkowania;
        temp[i].f.ilosc_obslugiwanych_glowsnikow = aha[i].f.ilosc_obslugiwanych_glowsnikow;
        temp[i].f.cena = aha[i].f.cena;

        for(j = 0; j< 6; j++)
        {
            temp[i].zamowienie[j] = aha[i].zamowienie[j];
        }
    }
    rozmiar--;

    for(i = usuwanie; i < rozmiar; i++)
    {
        temp[i].imie = aha[i].imie ;
        temp[i].nazwisko = aha[i].nazwisko;
        temp[i].miasto = aha[i].miasto;
        temp[i].ulica = aha[i].ulica;
        temp[i].nr_domu = aha[i].nr_domu;
        temp[i].nr_mieszkania = temp[i].nr_mieszkania;

        temp[i].imie = aha[i].imie;
        temp[i].nazwisko = aha[i].nazwisko;
        temp[i].miasto = aha[i].miasto;
        temp[i].ulica = aha[i].ulica;
        temp[i].nr_domu = aha[i].nr_domu;
        temp[i].nr_mieszkania = aha[i].nr_mieszkania;

        temp[i].a.gniazdo_procesora = aha[i].a.gniazdo_procesora;
        temp[i].a.max_ilosc_pamieci = aha[i].a.max_ilosc_pamieci;
        temp[i].a.zlacze_PCI = aha[i].a.zlacze_PCI;
        temp[i].a.usb_3 = aha[i].a.usb_3;
        temp[i].a.cena = aha[i].a.cena;

        temp[i].b.cena = aha[i].b.cena;
        temp[i].b.zegar = aha[i].b.zegar;
        temp[i].b.rdzen = aha[i].b.rdzen;
        temp[i].b.producent = aha[i].b.producent;

        temp[i].c.cena = aha[i].c.cena;
        temp[i].c.ilosc_pamieci = aha[i].c.ilosc_pamieci;
        temp[i].c.typ_pamieci = aha[i].c.typ_pamieci;
        temp[i].c.crossfire = aha[i].c.crossfire;
        temp[i].c.producent = aha[i].c.producent;

        temp[i].d.producent = aha[i].d.producent;
        temp[i].d.ddr = aha[i].d.ddr;
        temp[i].d.ilosc_pamieci = aha[i].d.ilosc_pamieci;
        temp[i].d.ilosc_kosci = aha[i].d.ilosc_kosci;
        temp[i].d.taktowanie = aha[i].d.taktowanie;
        temp[i].d.cena = aha[i].d.cena;

        temp[i].e.producent = aha[i].e.producent;
        temp[i].e.pojemnosc = aha[i].e.pojemnosc;
        temp[i].e.pamiec_cache = aha[i].e.pamiec_cache;
        temp[i].e.transfer_zewnetrzny = aha[i].e.transfer_zewnetrzny;
        temp[i].e.cena = aha[i].e.cena;

        temp[i].f.producent = aha[i].f.producent;
        temp[i].f.czestotliwosc_probkowania = aha[i].f.czestotliwosc_probkowania;
        temp[i].f.ilosc_obslugiwanych_glowsnikow = aha[i].f.ilosc_obslugiwanych_glowsnikow;
        temp[i].f.cena = aha[i].f.cena;

    }
    return temp;
    }
}


////////////////////////////////////// Funkcje destroy /////////////////////////////////////
void destroy(klient *destroyed){
delete destroyed;

}

void destroy(procesor *destroyed){

delete destroyed;

}

void destroy(kgraficzna *destroyed){

delete destroyed;

}

void destroy(pamiec_ram *destroyed){

delete destroyed;

}

void destroy(kmuzyczna *destroyed){

delete destroyed;
}

void destroy(dysk_twardy *destroyed){

delete destroyed;
}


//////////////////////////////////////// end of destroy /////////////////////////////

////////////////////////////////////// Funkcje programowe //////////////////////////

void pokaz(produkty::plyta_glowna *temp,int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}

    void pokaz(procesor *temp, int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}



void pokaz(kgraficzna *temp, int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}

void pokaz(pamiec_ram *temp, int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}

void pokaz(dysk_twardy *temp, int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}

void pokaz(kmuzyczna *temp, int rozmiar)
{
    int i;

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();
    }
}

int pokaz(klient *temp, int rozmiar)
{
    int i;

        if(temp == NULL)
    {
        std::cout << "Lista jest pusta!\n ";
        return 0;
    }

    for(i = 0; i< rozmiar; i++)
    {
        cout << i+1 << ".++++++++++++++++++++++++++++" << endl;
        temp[i].pokaz();

        if(temp[i].zamowienie[0] == 1)
            temp[i].a.pokaz();
        if(temp[i].zamowienie[1] == 1)
            temp[i].b.pokaz();
        if(temp[i].zamowienie[2] == 1)
            temp[i].c.pokaz();
        if(temp[i].zamowienie[3] == 1)
            temp[i].d.pokaz();
        if(temp[i].zamowienie[4] == 1)
            temp[i].e.pokaz();
        if(temp[i].zamowienie[5] == 1)
            temp[i].f.pokaz();
    }
}

 void create_klient(klient *temp)
 {
     cout << "Podaj Imie: ";
     cin >> temp->imie;
     cout << "Podaj nazwisko: ";
     cin >> temp->nazwisko;
     cout << "Podaj Miasto: ";
     cin >> temp->miasto;
     cout << "Podaj ulice: ";
     cin >> temp->ulica;
     cout << "Podaj nr domu: ";
     cin >> temp->nr_domu;
     cout << "Podaj nr mieszkania: ";
     cin >> temp->nr_mieszkania;
 }

int main()
{
    int i, zmienna_while, zmienna_while1;
    int plyta_r, proc_r, kgraf_r, ram_r, dysk_r, kmu_r, klient_r = 0;
    produkty::plyta_glowna kupa;

    //////////////////////////////tworzenie tablic  produktami/////////////////////////////
    produkty::plyta_glowna *plyta_tab = kupa.create_plyta_glowna();
    procesor *proc_tab = create_procesor();
    kgraficzna *kgraf_tab = create_kgraficzna();
    pamiec_ram *ram_tab = create_pamiec_ram();
    dysk_twardy *dysk_tab = create_dysk_twardy();
    kmuzyczna *kmu_tab = create_kmuzyczna();
    klient *klient_tab;
    //////////////////////////////koniec tworzenia tablic  produktami/////////////////////

    /////////////////////////////pobieranie rozmiarow tablic na produkty//////////////

plik.open( "plyty_glowne.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> plyta_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.open( "procesory.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> proc_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.open( "karty_graficzne.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> kgraf_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.open( "ram.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> ram_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.open( "dyski_twarde.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> dysk_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.open( "karty_muzyczne.txt", std::ios::in);
        if( plik.good() == true )
        {
            plik >> kmu_r;
            plik.close();
        }
        else cout << "Dostep do pliku zostal zabroniony!" << endl;
///////////////////////////////////////koniec pobierania rozmiarow tablic///////////////////////

//////////////////////////////////////Poczatek menu uzytkownika//////////////////////////////
    do
    {
        cout << "Witaj w systemie!" << endl << endl;
        cout << "1.Przegladaj towar.\n2.Zloz zamowienie.\n3.Wyswietl zamowienia.\n4.Usun zamowienie.\n0.Zamknij" << endl << endl;
        cout << "Co chcesz zrobic: ";
        cin >> zmienna_while;

/////////////////////////////////////LEVEL 1////////////////////////////////////////////
        switch(zmienna_while)
        {
            case 1:
            {
                system("cls");
                do
                {

                    cout << "1.Plyty glowne\n2.Procesory\n3.Karty graficzne\n4.Pamiec RAM\n5.Dyski twarde\n6.Karty muzyczne\n" << endl;
                    cout << "Co chcialbys przejrzec: ";
                    cin >> zmienna_while1;

//////////////////////////////////////////// 1. LEVEL 2 ///////////////////////////////////////
                    switch(zmienna_while1)
                    {
                        case 1:
                        {
                            system("cls");
                            pokaz(plyta_tab, plyta_r);
                            break;
                        }

                        case 2:
                        {
                            system("cls");
                            pokaz(proc_tab, proc_r);
                            break;
                        }

                        case 3:
                        {
                            system("cls");
                            pokaz(kgraf_tab, kgraf_r);
                            break;
                        }

                        case 4:
                        {
                            system("cls");
                            pokaz(ram_tab, ram_r);
                            break;
                        }

                        case 5:
                        {
                            system("cls");
                            pokaz(dysk_tab, dysk_r);
                            break;
                        }

                        case 6:
                        {
                            system("cls");
                            pokaz(kmu_tab, kmu_r);
                            break;
                        }
                        case 0:
                        {
                            system("cls");
                            break;
                        }

                    }

                }
                while(zmienna_while1 != 0);
                break;
            }
//////////////////////////////////////////// 1. END of LEVEL2 ///////////////////////////////////////////

            case 2:
            {
                system("cls");
                do
                {
                    cout << "1.Zamow caly zestaw czesci.\n2.Zamow wybrane czesci.\n0.Wroc\n" << endl;
                    cout << "Wybierz swoja opcje: \n";
                    cin >> zmienna_while1;
////////////////////////////////////////// 2. LEVEL 2 /////////////////////////////////////////////
switch(zmienna_while1)
                    {
                        case 1:
                        {
                            i = 0;
                            if(klient_r == 0)  ///////// kiedy zakladany jest pierwszy klient
                            {
                                klient_tab = new klient;
                                klient_r++;
                            }
                            else
                                klient_tab = dodaj_klienta(klient_tab, klient_r);     // gdy mamy juz klientow

                            for(i = 0; i<6;i++)
                            {
                                klient_tab[klient_r-1].zamowienie[i] = 1;
                            }

                            system("cls");
                            pokaz(plyta_tab, plyta_r);                        // wszedzie trzeba orobic zabezpieczenie
                            cout << "Podaj numer wybranej plyty glownej: ";   // ze i nie moze byc wieksze niz rozmiar
                            cin >> i;                                         // tabeli z danymi produktami


                            klient_tab[klient_r-1].a.setgniazdo_procesora(plyta_tab[i-1].getgniazdo_procesora());
                            klient_tab[klient_r-1].a.setmax_ilosc_pamieci(plyta_tab[i-1].getmax_ilosc_pamieci());
                            klient_tab[klient_r-1].a.setproducent(plyta_tab[i-1].getproducent());
                            klient_tab[klient_r-1].a.setusb_3(plyta_tab[i-1].getusb_3());
                            klient_tab[klient_r-1].a.setzlacze_PCI(plyta_tab[i-1].getzlacze_PCI());
                            klient_tab[klient_r-1].a.setcena(plyta_tab[i-1].getcena());

                            system("cls");
                            pokaz(proc_tab, proc_r);
                            cout << "Podaj numer wybranego procesora: ";
                            cin >> i;
                            klient_tab[klient_r-1].b.setcena(proc_tab[i-1].getcena());
                            klient_tab[klient_r-1].b.setproducent(proc_tab[i-1].getproducent());
                            klient_tab[klient_r-1].b.setrdzen(proc_tab[i-1].getrdzen());
                            klient_tab[klient_r-1].b.setzegar(proc_tab[i-1].getzegar());


                            system("cls");
                            pokaz(kgraf_tab, kgraf_r);
                            cout << "Podaj numer wybranej karty graficznej: ";
                            cin >> i;
                            klient_tab[klient_r-1].c.setcena(kgraf_tab[i-1].getcena());
                            klient_tab[klient_r-1].c.setcrossfire(kgraf_tab[i-1].getcrossfire());
                            klient_tab[klient_r-1].c.setilosc_pamieci(kgraf_tab[i-1].getilosc_pamieci());
                            klient_tab[klient_r-1].c.settyp_pamieci(kgraf_tab[i-1].gettyp_pamieci());
                            klient_tab[klient_r-1].c.setproducent(kgraf_tab[i-1].getproducent());

                            system("cls");
                            pokaz(ram_tab, ram_r);
                            cout << "Podaj numer wybranej pamieci ram: ";
                            cin >> i;
                            klient_tab[klient_r-1].d.setcena(ram_tab[i-1].getcena());
                            klient_tab[klient_r-1].d.setddr(ram_tab[i-1].getddr());
                            klient_tab[klient_r-1].d.setilosc_kosci(ram_tab[i-1].getilosc_kosci());
                            klient_tab[klient_r-1].d.setilosc_pamieci(ram_tab[i-1].getilosc_pamieci());
                            klient_tab[klient_r-1].d.setproducent(ram_tab[i-1].getproducent());
                            klient_tab[klient_r-1].d.settaktowanie(ram_tab[i-1].gettaktowanie());

                            system("cls");
                            pokaz(dysk_tab, dysk_r);
                            cout << "Podaj numer wybranego dysku twardego: ";
                            cin >> i;
                            klient_tab[klient_r-1].e.setcena(dysk_tab[i-1].getcena());
                            klient_tab[klient_r-1].e.setpamiec_cache(dysk_tab[i-1].getpamiec_cache());
                            klient_tab[klient_r-1].e.setpojemnosc(dysk_tab[i-1].getpojemnosc());
                            klient_tab[klient_r-1].e.setproducent(dysk_tab[i-1].getproducent());
                            klient_tab[klient_r-1].e.settransfer_zewnetrzny(dysk_tab[i-1].gettransfer_zewnetrzny());

                            system("cls");
                            pokaz(kmu_tab, kmu_r);
                            cout << "Podaj numer wybranej Karty muzycznej: ";
                            cin >> i;
                            klient_tab[klient_r-1].f.setcena(kmu_tab[i-1].getcena());
                            klient_tab[klient_r-1].f.setczestotliwosc_probkowania(kmu_tab[i-1].getczestotliwosc_probkowania());
                            klient_tab[klient_r-1].f.setilosc_obslugiwanych_glowsnikow(kmu_tab[i-1].getilosc_obslugiwanych_glowsnikow());
                            klient_tab[klient_r-1].f.setproducent(kmu_tab[i-1].getproducent());
                            cout << klient_r << endl;

                            create_klient(klient_tab+(klient_r-1));

                            break;

                        }

                        case 2:
                        {
                            i = 0;
                            if(klient_r == 0)  ///////// kiedy zakladany jest pierwszy klient
                            {
                                klient_tab = new klient;
                                klient_r++;
                            }
                            else
                                klient_tab = dodaj_klienta(klient_tab, klient_r);

                            cout << "Czy chcesz zamowic Plyte glowna? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[0];

                            if(klient_tab[klient_r-1].zamowienie[0] == 1)
                            {
                                system("cls");
                                pokaz(plyta_tab, plyta_r);
                                cout << "Podaj numer wybranej plyty glownej: ";
                                cin >> i;
                                klient_tab[klient_r-1].a.setgniazdo_procesora(plyta_tab[i-1].getgniazdo_procesora());
                                klient_tab[klient_r-1].a.setmax_ilosc_pamieci(plyta_tab[i-1].getmax_ilosc_pamieci());
                                klient_tab[klient_r-1].a.setproducent(plyta_tab[i-1].getproducent());
                                klient_tab[klient_r-1].a.setusb_3(plyta_tab[i-1].getusb_3());
                                klient_tab[klient_r-1].a.setzlacze_PCI(plyta_tab[i-1].getzlacze_PCI());
                                klient_tab[klient_r-1].a.setcena(plyta_tab[i-1].getcena());
                            }

                            cout << "Czy chcesz zamowic Procesor? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[1];

                            if(klient_tab[klient_r-1].zamowienie[1] == 1)
                            {
                                system("cls");
                                pokaz(proc_tab, proc_r);
                                cout << "Podaj numer wybranego procesora: ";
                                cin >> i;
                                klient_tab[klient_r-1].b.setcena(proc_tab[i-1].getcena());
                                klient_tab[klient_r-1].b.setproducent(proc_tab[i-1].getproducent());
                                klient_tab[klient_r-1].b.setrdzen(proc_tab[i-1].getrdzen());
                                klient_tab[klient_r-1].b.setzegar(proc_tab[i-1].getzegar());
                            }

                            cout << "Czy chcesz zamowic Karte graficzna? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[2];

                            if(klient_tab[klient_r-1].zamowienie[2] == 1)
                            {
                                system("cls");
                                pokaz(kgraf_tab, kgraf_r);
                                cout << "Podaj numer wybranej karty graficznej: ";
                                cin >> i;
                                klient_tab[klient_r-1].c.setcena(kgraf_tab[i-1].getcena());
                                klient_tab[klient_r-1].c.setcrossfire(kgraf_tab[i-1].getcrossfire());
                                klient_tab[klient_r-1].c.setilosc_pamieci(kgraf_tab[i-1].getilosc_pamieci());
                                klient_tab[klient_r-1].c.settyp_pamieci(kgraf_tab[i-1].gettyp_pamieci());
                                klient_tab[klient_r-1].c.setproducent(kgraf_tab[i-1].getproducent());
                            }

                            cout << "Czy chcesz zamowic Pamiec RAM? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[3];

                            if(klient_tab[klient_r-1].zamowienie[3] == 1)
                            {
                                system("cls");
                                pokaz(ram_tab, ram_r);
                                cout << "Podaj numer wybranej pamieci ram: ";
                                cin >> i;
                                klient_tab[klient_r-1].d.setcena(ram_tab[i-1].getcena());
                                klient_tab[klient_r-1].d.setddr(ram_tab[i-1].getddr());
                                klient_tab[klient_r-1].d.setilosc_kosci(ram_tab[i-1].getilosc_kosci());
                                klient_tab[klient_r-1].d.setilosc_pamieci(ram_tab[i-1].getilosc_pamieci());
                                klient_tab[klient_r-1].d.setproducent(ram_tab[i-1].getproducent());
                                klient_tab[klient_r-1].d.settaktowanie(ram_tab[i-1].gettaktowanie());

                            }

                            cout << "Czy chcesz zamowic Dysk twardy? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[4];

                            if(klient_tab[klient_r-1].zamowienie[4] == 1)
                            {
                                system("cls");
                                pokaz(dysk_tab, dysk_r);
                                cout << "Podaj numer wybranego dysku twardego: ";
                                cin >> i;
                            klient_tab[klient_r-1].e.setcena(dysk_tab[i-1].getcena());
                            klient_tab[klient_r-1].e.setpamiec_cache(dysk_tab[i-1].getpamiec_cache());
                            klient_tab[klient_r-1].e.setpojemnosc(dysk_tab[i-1].getpojemnosc());
                            klient_tab[klient_r-1].e.setproducent(dysk_tab[i-1].getproducent());
                            klient_tab[klient_r-1].e.settransfer_zewnetrzny(dysk_tab[i-1].gettransfer_zewnetrzny());

                            }

                            cout << "Czy chcesz zamowic Karty muzycznej? 1-Tak, 2-Nie: ";
                            cin >> klient_tab[klient_r-1].zamowienie[5];

                            if(klient_tab[klient_r-1].zamowienie[5] == 1)
                            {
                                system("cls");
                                pokaz(kmu_tab, kmu_r);
                                cout << "Podaj numer wybranej Karty muzycznej: ";
                                cin >> i;
                                klient_tab[klient_r-1].f.setcena(kmu_tab[i-1].getcena());
                                klient_tab[klient_r-1].f.setczestotliwosc_probkowania(kmu_tab[i-1].getczestotliwosc_probkowania());
                                klient_tab[klient_r-1].f.setilosc_obslugiwanych_glowsnikow(kmu_tab[i-1].getilosc_obslugiwanych_glowsnikow());
                                klient_tab[klient_r-1].f.setproducent(kmu_tab[i-1].getproducent());
                            }

                            create_klient(klient_tab+(klient_r-1));
                        }
                    }
                }
                while(zmienna_while1 != 0);
            }

            case 3:
            {
                pokaz(klient_tab, klient_r);
                break;
            }

            case 4:
            {
                cout << "Podaj numer klienta, ktorego chcesz usunac; ";
                cin >> i;
                klient_tab = destroy_klient(klient_tab, klient_r, i);
                break;
            }
        }
    }
    while(zmienna_while != 0);


}