#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>
#include <random>

using namespace std;
ostream & operator <<(ostream &os,pair<double,double> &para)
{
    os<<para.first<<" "<<para.second;
    return os;
}
static int stopien_abstrakcji=0;
template<class T,class Z>
ostream & operator<< (ostream &os,pair<T,Z> para);
template<class T>
ostream & operator <<(ostream &os,vector<T> &vektor);
template<class T>
vector<T> & operator += (vector<T> &poczatkowy,vector<T> &dodawany);
template<class T>
vector<T> & operator += (vector<T> &poczatkowy,int &dodawany);
template<class T,class Z>
vector<T> & operator += (vector<T> &pocz,vector<Z> dod)
{
    int i=0;
    for(auto &kazdy:pocz)
    {
        for(auto &dodawany:dod)
        {
            kazdy+=dodawany;
        }




    }
    return pocz;
}


int main() {

    /*
     * pair<class T,class Z>
     */

    /*
     * W tej części zajmiemy się tablicami wielowymiarowymi oraz obiektami typu pair
     * Drugą część "Wykładu" poświęcimy na użytecznne aspekty programowania generycznego
     */
    // pari<typ1,typ2> nazwa_zmiennej;
    pair<int,int> zespolona;
    zespolona.first=10;
    zespolona.second=30;
    pair<double,double> zespolona_zmiennoprzecinkowa(13.5,11);
    cout<<"Pierwsza zespolona calkowita to : Re "<<zespolona.first<<" Im "<<zespolona.second<<endl;
    cout<<"Druga zespolona o rzeczywistych parametrach to : Re "
        <<zespolona_zmiennoprzecinkowa.first<<" Im "<<zespolona_zmiennoprzecinkowa.second<<endl;
    pair<pair<double,double>,pair<double,double>> odcinek_na_plaszczyznie_zespolonej;
    odcinek_na_plaszczyznie_zespolonej.first=zespolona_zmiennoprzecinkowa;
    odcinek_na_plaszczyznie_zespolonej.second=zespolona;
    pair<pair<double,double>,pair<double,double>> odcinek_na_plaszczyznie_zespolonej_zainicjalizowany({11,12},{77,66});
    /*
     * Aby inicjalizować składniki typu pair za pomocą listy inicjalizacyjnej trzeba używać nawiasów klamrowych{}
     * Mogą być one zainicjalizowane również za pomocą utworzonych wcześniej obiektów
     */
    cout<<zespolona_zmiennoprzecinkowa<<endl<<odcinek_na_plaszczyznie_zespolonej_zainicjalizowany.first
        <<" "<<odcinek_na_plaszczyznie_zespolonej_zainicjalizowany.second<<endl;

    /*
     * pair<typ1,typ2> nazwa;pair<typ1,typ2> nazwa(konstuktor_typu_1,konstruktor_typu_2);
     * gdzie typ1 oraz typ2 mogą być to dowolne typy ( np pair<string,string> pair<int,int*> itp....)
     *
     */
    swap(odcinek_na_plaszczyznie_zespolonej_zainicjalizowany.first,zespolona_zmiennoprzecinkowa);
    //Ta funkcja zamienia nam te 2 obiekty w danej parze , strukturze jedyny wymóg jest taki by oba miały te same typy
    //Np pair<double,double> musi być zamieniona z pair<double,double> etc ....
    /*
     * Możemy tak samo zamieniać obiekty metodą z pary
     */
    pair<int,string> id_stringa(1,"Testowy string");
    pair<int,string> id_stringa_drugiego(2,"Testowy string numer 2");
    cout<<id_stringa.first<<" "<<id_stringa.second<<endl;
    cout<<id_stringa_drugiego.first<<" "<<id_stringa_drugiego.second<<endl;

    id_stringa.swap(id_stringa_drugiego);
    cout<<id_stringa.first<<" "<<id_stringa.second<<endl;
    cout<<id_stringa_drugiego.first<<" "<<id_stringa_drugiego.second<<endl;


    /*
    * Drobna powtórka z wektorów
    */
    /*
   * Tutaj mamy pojedynczą tablicę zainicjalizowaną 10-tkami i ma długość 5
   */

vector<int> pojedyncza_tablica(5,10);
    //Można też zrobić
 //vector<vector<int>> tablica_dwuwymiarowa(5,pojedyncza_tablica);
   vector<vector<int>> tablica_dwuwymiarowa(5,{10,10});
   for(auto &kazdy:tablica_dwuwymiarowa)
   {
       for(int i =0;i<10;i++)
       {
           kazdy.push_back(i);

       }
   }
   cout<<tablica_dwuwymiarowa;
   for(int i=0;i<3;i++)
   {
       cout<<"Ide poziomo po indeksie [0]["<<i<<"] "<<tablica_dwuwymiarowa[0][i]<<endl;

   }
   for(int i=0;i<3;i++)
   {
       cout<<"Ide pionowo po indeksie ["<<i<<"][0] "<<tablica_dwuwymiarowa[i][0]<<endl;
   }

   vector<vector<vector<int>>> tablica_trzy_wymiarowa(3,{{10,11,12},{1,2,3},{4,5,6}});
   for(int i=0;i<3;i++)
   {
       cout<<"Ide poziomo (Wzdluz X) po indeksie [0][0]["<<i<<"] "<<tablica_trzy_wymiarowa[0][0][i]<<endl;

   }
   for(int i=0;i<3;i++)
   {
       cout<<"Ide pionowo (Wzdluz Y) po indeksie [0]["<<i<<"][0] "<<tablica_trzy_wymiarowa[0][i][0]<<endl;
   }
   for(int i=0;i<3;i++)
   {
       cout<<"Ide poziomo (Wzdluz Z) po indeksie ["<<i<<"][0][0] "<<tablica_trzy_wymiarowa[i][0][0]<<endl;
   }


   cout<<tablica_trzy_wymiarowa<<endl<<"Dodaje nowy element to 3 wymiarowej tablicy"<<endl;
   tablica_trzy_wymiarowa.push_back({{33,33,33},{44,44,44},{55,55,55}});

   cout<<tablica_trzy_wymiarowa;
   int licznik=0;
   for(auto &trzeci:tablica_trzy_wymiarowa)
   {
       for(auto &drugi:trzeci)
       {
           for(int i =0;i<20;i++)
           {
               drugi.push_back(licznik);
               licznik++;
           }

       }
   }

   cout<<tablica_trzy_wymiarowa;
   for( auto &trzeci:tablica_trzy_wymiarowa)
   {
       trzeci.erase(trzeci.end()-1);
   }
   cout<<tablica_trzy_wymiarowa;
   tablica_trzy_wymiarowa.pop_back();
   cout<<tablica_trzy_wymiarowa;




    /*
     * Wyrażenie lambda  [lista rzeczy którycch możemy używać] (ampersant pracujemy na referencji bez niego pracujemy na kopiach)]
     * (lista parametrów przekazywanych do funkcji) {ciało funkcji} (parametry z którymi chcemy by ona działała)
     *
     * inaczej można lambde zapisać []()->typ_zwracany{}; lub []()->typ_zwracany{}(); <- wywołanie tej funkcji
     *
     */



    auto funkcja= [](vector<vector<vector<int>>> &wymiarowy){
        for(auto &trzeci:wymiarowy)
        {

            for(auto &drugi:trzeci)
            {

                for(auto &pierwszy:drugi)
                {
                    cout<<pierwszy<<" ";
                }
                cout<<endl;
            }
            cout<<endl;
        }

    };

    cout<<" cos wypisuje "<<endl;
    funkcja(tablica_trzy_wymiarowa);
    auto wyrazenie_logiczne_lambda= [](int a,int b)->bool{return a>b;};

    sort(tablica_trzy_wymiarowa[0][0].begin(),tablica_trzy_wymiarowa[0][0].end(),[](int a,int b)->bool {
        return a<b? true:false;
    });
    // pierwszy> lub < 2alg

    cout<<"Sortuje pierwsza i druga tabele malejaco   "<<endl;

    sort(tablica_trzy_wymiarowa[0][1].begin(),tablica_trzy_wymiarowa[0][1].end(),wyrazenie_logiczne_lambda);
   // sort(tablica_trzy_wymiarowa[0][2].begin(),tablica_trzy_wymiarowa[0][2].end(),wyrazenie_logiczne_lambda);
    funkcja(tablica_trzy_wymiarowa);

    /*
     * Jak widzimy alokator dla wektorów działa dość dobrze jednak jeśli potrzebujemy zrobić bardziej specyficzne
     * zarządzanie pamięcią , przyjmować typy totalnie z kosmosu albo np dodatkowo monitorować używanie pamięci
     * (np zapis do pliku automatycznie w trakcie modyfikacji czegoś to możemy napisać własny alokator pamięci
     *
     */
    //vector<int()>wskazniki_na_funkcje;

    vector<string> tablica_napisow(3,"abc");
    vector<string> tablica_napisow_cba(4,"cba");

    tablica_napisow+=tablica_napisow_cba;
    //nasz nowozdefiniowany operator += dla typów generycznych działa
    cout<<tablica_napisow;
    vector<vector<int>> liczby(10,{1,2,3,4,5});
    for(int i=0;i<10;i++)
    {
        liczby[i]+=i;
    }
    cout<<liczby;
    tablica_napisow+=liczby[0];
    cout<<tablica_napisow;
//    // tablica_napisow+=liczby; nie możemy tego zrobić ponieważ typ vektora nr 1 i nr 2 są różne


//    vector<vector<int>> tablica_2_wym(10);
//for(auto &kazdy:tablica_2_wym)
//{
//    for(int i =0;i<100;i++)
//    {
//        kazdy.push_back(i%10);
//    }
//}
//for(auto &kazdy:tablica_2_wym)
//{
//    sort(kazdy.begin(),kazdy.end());
//}




    /*
     * Nie polecam wam aż tak komplikować jednak ten przykład ma na celu pokazać że przez programowanie generyczne możemy wybrnąć
     * w dość łatwy sposób z wypisywaniem i innego typu  operacjami na typach generycznych
     */

    vector<pair<vector<int>,vector<vector<int>>>> vektor_par_od_vektoraIntowego_i_vektora_od_wektora_intowego(1);
    for(auto &kazdy:vektor_par_od_vektoraIntowego_i_vektora_od_wektora_intowego)
    {
        for(int i =0;i<11;i++)
        {
            kazdy.first.push_back(i);
        }
        for(int i =0;i<5;i++)
        {
            vector<int> podrobka;
            podrobka.push_back(-300);
            for(int j=0;j<7;j++)
            {
                podrobka.push_back(j);
            }
            for(int j=0;j<6;j++)
            {
                kazdy.second.push_back(podrobka);
            }
        }


    }
    cout<<vektor_par_od_vektoraIntowego_i_vektora_od_wektora_intowego<<endl;
    return 0;

}
template<class T>
ostream & operator <<(ostream &os,vector<T> &vektor)
{
    stopien_abstrakcji++;
    if(stopien_abstrakcji!=2&&stopien_abstrakcji!=3)
        os<<" ";

    for(auto kazdy:vektor) {
        os << kazdy << " ";
    }
    os<<endl;
    stopien_abstrakcji--;
    return os;
}
template<class T,class Z>
ostream & operator<< (ostream &os,pair<T,Z> para){
    os<<para.first<<endl<<para.second<<endl;
    return os;
}
template<class T>
vector<T> & operator += (vector<T> &poczatkowy,vector<T> &dodawany)
{
    for(auto &kazdy_z_dodawanego:dodawany)
    {
        poczatkowy.push_back(kazdy_z_dodawanego);
    }
    return poczatkowy;
}
template<class T>
vector<T> & operator += (vector<T> &poczatkowy,int &dodawanyint)
{
    for(auto &kazdy:poczatkowy)
    {
        kazdy+=dodawanyint;
    }
    return poczatkowy;
}