#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
using namespace std;

class Punkt;
class Okrag;
class Prostokat;




class Punkt{
friend void wypisz (Punkt pkt);
public:
    void wypisz()
    {
        cout<<"("<<x<<","<<y<<")";
    }
    Punkt(int x, int y) : x(x), y(y) {}

    friend ostream &operator<<(ostream &os, const Punkt &punkt) {
        os << "(" << punkt.x << " , " << punkt.y<<")";
        return os;
    }

    int getX() const {
        return x;
    }

    int getY() const {
        return y;
    }

private:
    friend Prostokat;
    friend Okrag;
    int x,y;

};
class Prostokat
{
friend void wypisz (Prostokat prostokat);
public:
    void wypisz()
    {
        cout<<"Jest to prostokat o punkcie "<<lewy_dolny<<" a dlugosci "<<szerokosc<<" i wysokosci "<<wysokosc<<endl;
    }
    Prostokat(const Punkt &lewyDolny, int szerokosc, int wysokosc) : lewy_dolny(lewyDolny), wysokosc(wysokosc),
                                                                     szerokosc(szerokosc) {}
    void czy_wspolne(Punkt * tablica_punktow,int ilosc)
    {

        bool czy_jest=true;
        int delta_X= lewy_dolny.x   +szerokosc;
        int delta_Y=lewy_dolny.y +wysokosc;
        for(int i = 0;i<ilosc;i++)
        {


            if((delta_X-tablica_punktow[i].x>=0)&&tablica_punktow[i].x>=lewy_dolny.x)
            {
                czy_jest=true;
            }else
            {
                cout<<"warunek pierwszy X "<<endl;
                czy_jest=false;
            }
            if(czy_jest)
            {
                if(delta_Y-tablica_punktow[i].y>=0&&tablica_punktow[i].y>=lewy_dolny.y)
                {
                    czy_jest=true;
                } else
                {
                    cout<<"warunek Y "<<endl;
                    czy_jest=false;
                }
            }



            if(czy_jest)
            {
                cout<<"Punkt "<<tablica_punktow[i]<<" nalezy do tego prostakota"<<endl;
            }

        }
    }
private:
    Punkt lewy_dolny;
    int wysokosc,szerokosc;
public:

};
class Okrag{
public:
   friend  void wypisz (Okrag o);
    void wypisz()
    {
        cout<<"Okrag o srodku ";srodek.wypisz();cout<<" o promieniu "<<promien;
    }
    Okrag(const Punkt &srodek, int promien) : srodek(srodek), promien(promien) {}

    Okrag() {
        int x = rand()%16-5;
        int y = rand() %16 -10;
        int dlugosc_promienia = rand()%15+1;
        Punkt punkt(x,y);
        srodek=punkt;
        promien=dlugosc_promienia;
    }

    friend ostream &operator<<(ostream &os, const Okrag &okrag) {
        os << "srodek: " << okrag.srodek << " promien: " << okrag.promien;
        return os;
    }

    void setSrodek( Punkt srodek) {
        Okrag::srodek = srodek;
    }

    void setPromien(int promien) {
        Okrag::promien = promien;
    }

    const Punkt &getSrodek() const {
        return srodek;
    }

    int getPromien() const {
        return promien;
    }

private:
    Punkt srodek=Punkt(0,0);
    int promien;
};

int ile_sie_przecina(Okrag* pierwsza_tablica,int licznik1,Okrag *druga_tablica,int licznik2)
{
    long long ile_przejsc=0;
    int przeciecia=0;
    for(int i=0;i<licznik1;i++ )
    {
        for(int j=0;j<licznik2;j++) {
            ile_przejsc++;

            long double wart_bezwzgledna=  abs(pierwsza_tablica[i].getPromien()-druga_tablica[j].getPromien());
            long double odlegloscX = pow(druga_tablica[j].getSrodek().getX()- pierwsza_tablica[i].getSrodek().getX(),2) ;//x^2
            long double odlegloscY = pow(druga_tablica[j].getSrodek().getY()- pierwsza_tablica[i].getSrodek().getY() ,2) ;//y^2
            long double odleglosc_miedzy_srodkami = sqrt(odlegloscX+odlegloscY);// sqrt(x^2 + y^2)
            long double suma_promieni= pierwsza_tablica[i].getPromien() + druga_tablica[j].getPromien();
            if(wart_bezwzgledna<=odleglosc_miedzy_srodkami&&odleglosc_miedzy_srodkami<=suma_promieni)// zewnętrznie styczne
            {
                przeciecia++;
                continue;
            }
        }

    }
    cout<<"Wypisze ilosc porownan  "<<ile_przejsc<<endl;
    return przeciecia;
}

void wypisz (Okrag o)
{
    o.wypisz();
}
void wypisz (Punkt pkt)
{
    pkt.wypisz();
}
void wypisz (Prostokat prostokat)
{
    prostokat.wypisz();
}
int main() {
    srand(time(0));
    Punkt tablica[3]= {Punkt (5,2),Punkt (-9,-9),Punkt (2,3)};

    Prostokat prostokat({-8,-6},13,10);
    prostokat.czy_wspolne(tablica,3);
    Okrag tablica_statyczna[100];// konstruktor domyślny
    for(int i =0;i<100;i++)
    {
        int x = rand()%6;
        int y = rand() %6 -5;
        int dlugosc_promienia = rand()%10+1;
        tablica_statyczna[i]=Okrag({x,y},dlugosc_promienia);// konstruktor domyślny -> konstruktor z parametrami
    }

    Okrag * tablica_dynamiczna=new Okrag [50];
    for(int i =0;i<100;i++)
    {
//        int x = rand()%16-5;
//        int y = rand() %16 -10;
//        int dlugosc_promienia = rand()%15+1;
//        tablica_dynamiczna[i].setPromien(dlugosc_promienia);
//        tablica_dynamiczna[i].setSrodek({x,y});// to nie działa

    }
//    for(auto kazdy:tablica_statyczna)
//    {
//        cout<<kazdy<<endl;// testowe wypisanie
//    }
//    cout<<endl;
//    for(int i =0;i<50;i++)
//    {
//        cout<<tablica_dynamiczna[i]<<endl;
//    }
    cout<<ile_sie_przecina(tablica_statyczna,100,tablica_dynamiczna,50);
    cout<<endl;

    wypisz(prostokat);
    cout<<endl;
    wypisz(tablica[0]);
    cout<<endl;
    wypisz(tablica_statyczna[0]);
    cout<<endl;
    return 0;
}