#include <iostream>

using namespace std;


class element {
protected:
    double prad;
    double napiecie;
    double moc;
    double czestotliwosc;
    string nazwa;
public:
    element() {nazwa = "element"; czestotliwosc = 1.0; napiecie = prad = moc = 0.0;}
    element(const string arg) {nazwa = arg; napiecie = czestotliwosc = 1.0; prad = moc = 0.0;}

    virtual void wymuszenieU(double) = 0;
    virtual void wymuszenieI(double) = 0;
    virtual void wymuszenieU_f(double, double) = 0;

    friend int obwod(element*, element*);

    void setName(string naz) {
        nazwa = naz;
    }

    string getName() {
        return nazwa;
    }
};

int obwod(element *e1, element *e2) {
    bool pradMatch = false;
    bool napiecieMatch = false;
    if (e1->prad == e2->prad) {
        pradMatch = true;
    }
    if (e1->napiecie == e2->napiecie) {
        napiecieMatch = true;
    }
    if ((pradMatch && !napiecieMatch) || (!pradMatch && napiecieMatch)) {
        //std::string matchType = (pradMatch)?"prad":"napiecie";
        std::string matchType;
        if (pradMatch) {
            matchType = "prad";
            return 1;
        } else {
            matchType = "napiecie";
            return 2;
        }

        cout << "elementy: " << e1->nazwa.c_str() << " oraz: " << e2->nazwa.c_str() << " maja taki sam: " << matchType.c_str() << endl;
    } else {
        if (pradMatch && napiecieMatch) {
            cout << "elementy: " << e1->nazwa.c_str() << " oraz: " << e2->nazwa.c_str() << " sa nieokreslone." << endl;
            return 3;
        } else {
            cout << "elementy: " << e1->nazwa.c_str() << " oraz: " << e2->nazwa.c_str() << " sa nie polaczone." << endl;
            return 0;
        }
    }
}

class cewka : public element {
protected:
    double L;
public:
    cewka() {nazwa = "cewka"; L = 1.0;}
    cewka(const string arg) {nazwa = arg; L = 1.0;}
    cewka(const string arg, double argL) {nazwa = arg; L = argL;}
    void wymuszenieU(double);
    void wymuszenieI(double);
    void wymuszenieU_f(double, double);

};

void cewka::wymuszenieU(double u) {
    napiecie = u;
    if (czestotliwosc > 0.0) {
        prad = napiecie*6.28*czestotliwosc*L;
        napiecie = prad * 6.28 * L * czestotliwosc;
        moc = napiecie * prad;
    }
}

void cewka::wymuszenieI(double i) {
    prad = i;
    if (czestotliwosc > 0.0) {
        napiecie = prad * 6.28 * L * czestotliwosc;
        moc = napiecie * prad;
        prad = napiecie*6.28*czestotliwosc*L;
    }
}


void cewka::wymuszenieU_f(double U, double f) {
    czestotliwosc = f;
    napiecie = U;

    if(czestotliwosc>0.0) {
        napiecie = prad * 6.28 * L * czestotliwosc;
        moc = napiecie * prad;
        prad = napiecie*6.28*czestotliwosc*L;
    }
}

class rezystor: public element {
protected:
    double R;
public:
    rezystor() {nazwa = "rezystor"; R = 1.0;}
    rezystor(const string arg) {nazwa = arg; R=1.0;}
    rezystor(const string arg, double argR) {nazwa= arg; R = argR;}
    void wymuszenieU(double);
    void wymuszenieI(double);
    void wymuszenieU_f(double,double);

};

void rezystor::wymuszenieU(double u) {
    napiecie = u;
    if (R > 0.0) {
        prad = napiecie/R;
        moc = prad*prad*R;
        napiecie = prad*R;
    }
}

void rezystor::wymuszenieI(double i) {
    prad = i;
    if (R > 0.0) {
        prad = napiecie/R;
        moc = prad*prad*R;
        napiecie = prad*R;
    }
}

void rezystor::wymuszenieU_f(double U, double f) {
    czestotliwosc = f;
    napiecie = U;

    if(R>0.0) {
        prad = napiecie/R;
        moc = prad*prad*R;
        napiecie = prad*R;
    }
}

class kondensator: public element {
protected:
    double C;
public:
    kondensator() {nazwa = "kondensator"; C = 1.0;}
    kondensator(const string arg) {nazwa = arg; C=1.0;}
    kondensator(const string arg, double argC) {nazwa= arg; C = argC;}
    void wymuszenieU(double);
    void wymuszenieI(double);
    void wymuszenieU_f(double, double);

};

void kondensator::wymuszenieU(double u) {
    napiecie = u;
    if (czestotliwosc > 0.0) {
        napiecie = prad/(6.28*czestotliwosc*C);
        moc = (prad*prad)/(6.28*czestotliwosc*C);
        prad = napiecie/(6.28*czestotliwosc*C);
    }
}

void kondensator::wymuszenieI(double i) {
    prad = i;
    if (czestotliwosc > 0.0) {
        napiecie = prad/(6.28*czestotliwosc*C);
        moc = (prad*prad)/(6.28*czestotliwosc*C);
        prad = napiecie/(6.28*czestotliwosc*C);
    }
}


void kondensator::wymuszenieU_f(double U, double f) {
    czestotliwosc = f;
    napiecie = U;
    if (czestotliwosc > 0.0) {
        napiecie = prad/(6.28*czestotliwosc*C);
        moc = (prad*prad)/(6.28*czestotliwosc*C);
        prad = napiecie/(6.28*czestotliwosc*C);

    }
}


int main() {

    element *tab[10];
    tab[0] = new cewka("cewka1", 4.0);
    tab[1] = new kondensator("kondensator1", 3.0);
    tab[2] = new rezystor("rezystor1", 20.0);
    tab[3] = new cewka("cewka2", 3.0);
    tab[4] = new kondensator("kondensator2", 200.0);
    tab[5] = new kondensator("kondensator3", 3.0);
    tab[6] = new cewka("cewka3", 200);
    tab[7] = new rezystor("rezystor2", 3.0);
    tab[8] = new kondensator("kondensator4", 100);
    tab[9] = new rezystor("rezystor3", 120);

    for (int i = 0; i < 10; i++) {
        int wybor;
        double U;
        double I;
        double f;

        cout << "Wybierz wymuszenie dla elementu: " << tab[i]->getName() << endl;
        cin >> wybor;
        if (wybor == 0) {
            cout << "Podaj napięcie";
            cin >> U;
            tab[i]->wymuszenieU(U);
        }

        if (wybor == 1) {
            cout << "Podaj natezenie" << endl;
            cin >> I;
            tab[i]->wymuszenieI(I);
        }

        if (wybor == 2) {
            cout << "Podaj natezenie" << endl;

            cin >> I;
            cout << "Podaj czestotliwosc" << endl;
            cin >> f;
            tab[i]->wymuszenieU_f(I, f);
        }
    }

        int counter = 0;
    for (int i = 0; i < 10; i++) {
        for (int a = i + 1; a < 10; a++) {
            obwod(tab[i], tab[a]);
            counter += 1;
        }
    }


        cout << counter;