#include <iostream>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <stdio.h>
#include <fstream>
//#include <interface.h>

using namespace std;

ofstream out;
ifstream in;

class Electrical_facility
{
protected:
    string type;
    double r;
public:
    Electrical_facility(string newtype, double newr)
    {
        type = newtype;
        r = newr;
    }

    string get_type()
    {
        return type;
    }

    double get_r()
    {
        return r;
    }

    void set_r(double newr)
    {
        this->r = newr;
    }

    virtual void print()
    {
        cout << this->get_type() << " " << this->get_r() << " Ом " << endl;
    }

    virtual void save_in_file()
    {
        out << this->get_type() << " " << this->get_r() << endl;
    }
};

class Lamp : public Electrical_facility
{
protected:
    bool light;
public:
    Lamp(double newr) : Electrical_facility("LMP", newr)
    {
        light = false;
    }

    bool get_light()
    {
        return light;
    }

    void set_light(bool newlight)
    {
        this->light = newlight;
    }

    void print()
    {
        cout << this->get_type() << " " << this->get_r() << " Ом; ";
        if(this->get_light())
            cout << "светится \n";
        else
            cout << "не светится \n";
    }

    void save_in_file()
    {
        out << this->get_type() << " " << this->get_r() << this->get_light() << endl;
    }
};

class Resistor : public Electrical_facility
{
public:
    Resistor(double newr) : Electrical_facility("RES", newr) {}

    void print()
    {
        cout << this->get_type() << " " << this->get_r() << " Oм " << endl;
    }

    void save_in_file()
    {
        out << this->get_type() << " " << this->get_r() << endl;
    }
};

class Appliance : public Electrical_facility
{
protected:
    double req_u, req_i, du, di;
    bool is_working;

public:
    Appliance(double newr, double newrequ, double newreqi,
         double newdu, double newdi) : Electrical_facility("APP", newr)
    {
        req_u = newrequ;
        du = newdu;
        req_i = newreqi;
        di = newdi;
        is_working = false;
    }

    double get_req_u()
    {
        return req_u;
    }

    void set_req_u(double newreq_u)
    {
        this->req_u = newreq_u;
    }

    double get_req_i()
    {
        return req_i;
    }

    void set_req_i(double newreq_i)
    {
        this->req_i = newreq_i;
    }

    double get_du()
    {
        return du;
    }

    void set_du(double newdu)
    {
        this->du = newdu;
    }

    double get_di()
    {
        return di;
    }

    void set_di(double newdi)
    {
        this->di = newdi;
    }

    void set_is_working(bool state)
    {
        this->is_working = state;
    }

    bool get_is_working()
    {
        return is_working;
    }

    void print()
    {
        cout << this->get_type() << " " << this->get_r() << " Ом; ";
        if(this->get_is_working())
            cout << "работает \n";
        else
            cout << "не работает \n";
        cout << "    требуется  " << this->get_req_u() << " В; " << this->get_req_i() << " A \n";
        cout << "    возможная разница " << this->get_du() << " В; " << this->get_di() << " A \n";
    }

    void save_in_file()
    {
        out << this->get_type() << " " << this->get_r() << " " << this->get_req_u() << " " << this->get_req_i() << " " << this->get_du() << " " << this->get_di() << endl;
    }
};

class CCS : public Electrical_facility
{
protected:
    double e;

public:
    CCS(double newr, double newe) : Electrical_facility("CCS", newr)
    {
        e = newe;
    }

    double get_e()
    {
        return e;
    }

    void set_e(double newe)
    {
        this->e = newe;
    }

    void print()
    {
        cout << this->get_type() << " " << this->get_r() << " Oм; " << this->get_e() << " В " << endl;
    }

    void save_in_file()
    {
        out << this->get_type() << " " << this->get_r() << " " << this->get_e() << endl;
    }

};

class Key : public Electrical_facility
{
protected:
    bool state;

public:
    Key(bool newstate) : Electrical_facility("KEY", 0)
    {
        state = newstate;
    }

    bool get_state()
    {
        return state;
    }

    void set_state(bool newstate)
    {
        this->state = newstate;
    }

    void print()
    {
        cout << this->get_type() << " ";
        if(this->get_state())
            cout << "закрыт \n";
        else
            cout << "открыт \n";
    }

    void save_in_file()
    {
        out << this->get_type() << " " << this->get_state() << endl;
    }
};

class Branch
{
protected:
    vector<Electrical_facility*> branch;
public:
    Branch() {}
    void set_el_f(int chain_number, bool flag, int type, int place, vector<double> param)
    {
        if(flag)
        {
            cout << "Для установки новой лампы,                              нажмите 1" << endl;
            cout << "Для установки нового резистора,                         нажмите 2" << endl;
            cout << "Для установки нового электронагревательного устройства, нажмите 3" << endl;
            cout << "Для установки нового источника тока,                    нажмите 4" << endl;
            cout << "Для установки нового ключа,                             нажмите 5" << endl;
            cout << "Будьте внимательный: цепь замыкается на источники тока, поэтому \n";
            cout << "они могут располагаться только в 1 подцепи в 1 ветке" << endl;
        }
        if(type == -1 && place == -1)
        {
            cin >> type;
            if(flag)
                cout << "Введите позицию, на которой будет расположен этот элемент: ";
            cin >> place;
        }

        Electrical_facility* new_obj = new Electrical_facility("Ошибка", -100500);
        double r, ru, ri, du, di, e;
        bool f = true;
        switch (type)
        {
        case 1:
            if(flag)
                cout << "Введите величину сопротивления лампы: ";
            if(param.empty())
                cin >> r;
            else
                r = param[0];
            if(chain_number)
                new_obj = new Lamp(r);
            else
            {
                f = false;
                cout << "Нельзя поставить этот элемент сюда!\n";
            }
            break;
        case 2:
            if(flag)
                cout << "Введите величину сопротивления резистора: ";
            if(param.empty())
                cin >> r;
            else
                r = param[0];
            if(chain_number)
                new_obj = new Resistor(r);
            else
            {
                f = false;
                cout << "Нельзя поставить этот элемент сюда!\n";
            }
            break;
        case 3:
            if(flag)
            {
                cout << "Введите величину сопротивления электронагревательного устройства и необходимые напряжение и силу тока, ";
                cout << "затем возможную разницу в напряжении и силе тока: ";
            }
            if(param.size() < 5)
                cin >> r >> ru >> ri >> du >> di;
            else
            {
                r = param[0];
                ru = param[1];
                ri = param[2];
                du = param[3];
                di = param[4];
            }
            if(chain_number)
                new_obj = new Appliance(r, ru, ri, du, di);
            else
            {
                f = false;
                cout << "Нельзя поставить этот элемент сюда!\n";
            }
            break;
        case 4:
            if(flag)
                cout << "Ведите величину внутреннего сопротивления источника тока и ЭДС: ";
            if(param.size() < 2)
                cin >> r >> e;
            else
            {
                r = param[0];
                e = param[1];
            }
            if(chain_number != 0)
            {
                if(flag)
                    cout << "К сожалению, вы не можете разместить источник тока здесь\n";
                f = false;
            }
            else
                new_obj = new CCS(r, e);
            break;
        case 5:
            if(flag)
                cout << "В каком положении ключ? (1 - закрыт, 0 - открыт): ";
            bool st;
            if(param.empty())
                cin >> st;
            else
            {
                if(abs(param[0]) < 1e-9)
                    st = false;
                else
                    st = true;
            }
            if(chain_number)
                new_obj = new Key(st);
            else
            {
                f = false;
                cout << "Нельзя поставить этот элемент сюда!\n";
            }
            break;
        default:
            f = false;
            if(flag)
                cout << "Что-то пошло не так, попробуйте снова\n";
            break;
        }

        place--;
        if(f)
            if(place < 0 || place > branch.size())
            {
                if(flag)
                    cout << "Что-то пошло не так, попробуйте снова\n";
            }
            else
            {
                branch.insert(branch.begin() + place, new_obj);
            }
    }

    void remove_el_f()
    {
        cout << "Введите номер по счету на ветке электрической установки, которую вы хотите удалить: ";
        int n; cin >> n; n--;
        if(n >= branch.size() || n < 0)
            cout << "Что-то пошло не так, попробуйте снова\n";
        else
            branch.erase(branch.begin() + n);
    }

    bool is_locked()
    {
        bool res = true;
        for(int i = 0; i < branch.size(); i++)
        {
            if(branch[i]->get_type() == "KEY")
            {
                Key key = *(dynamic_cast<Key*>(branch[i]));
                if(!key.get_state())
                {
                    res = false;
                    break;
                }
            }
        }
        return res;
    }

    double get_r_from_to(int from, int to)
    {
        double res = 0;
        from--, to--;
        if(to >= 0 && to < branch.size() && from >=0 && from < branch.size()
            && to >= from && this->is_locked())
            for(int i = from; i <= to; i++)
                res += branch[i]->get_r();
        return res;
    }

    void change_parameters(bool flag)
    {
        if(flag)
        {
            cout << "На этой ветке " << branch.size() << " элементов\n";
            cout << "Введите номер на ветке устройства, чьи параметры будете изменять: ";
        }
        int i; cin >> i; i--;
        if(i >= branch.size() || i < 0)
        {
            if(flag)
                cout << "Некорректный номер, попробуйте ещё раз\n";
        }
        else
        {
            string type = branch[i]->get_type();
            if(flag)
                cout << "Доступные изменения: \n";
            if(type == "LMP")
            {
                Lamp* lmp = (dynamic_cast<Lamp*>(branch[i]));
                if(flag)
                {
                    cout << "Внутреннее сопротивление: сейчас" << lmp->get_r() << " Oм\n";
                    cout << "Нажмите 1 для изменения внутреннего сопротивления, \n";
                    cout << "        0 для выхода: ";
                }
                int answer; cin >> answer;
                switch (answer)
                {
                case 1:
                    if(flag)
                        cout << "Введите новое значение внутреннего сопротивления: ";
                    double r; cin >> r;
                    lmp->set_r(r);
                    break;
                case 0:
                    break;
                default:
                    if(flag)
                        cout << "Некорректная команда\n";
                    break;
                }
            }
            else if(type == "RES")
            {
                Resistor* res = (dynamic_cast<Resistor*>(branch[i]));
                if(flag)
                {
                    cout << "Сопротивление: сейчас" << res->get_r() << " Oм\n";
                    cout << "Нажмите 1 для изменения сопротивления, \n";
                    cout << "        0 для выхода: ";
                }
                int answer; cin >> answer;
                switch (answer)
                {
                case 1:
                    if(flag)
                        cout << "Введите новое значение сопротивления: ";
                    double r; cin >> r;
                    res->set_r(r);
                    break;
                case 0:
                    break;
                default:
                    if(flag)
                        cout << "Некорректная команда\n";
                    break;
                }
            }
            else if(type == "APP")
            {
                Appliance* app = (dynamic_cast<Appliance*>(branch[i]));
                if(flag)
                {
                    cout << "Внутреннее сопротивление: сейчас" << app->get_r() << " Oм\n";
                    cout << "Необходимое напряжение: сейчас " << app->get_req_u() << " В\n";
                    cout << "Необходимая сила тока: сейчас " << app->get_req_i() << " A\n";
                    cout << "Возможная разница в напряжении: сейчас " << app->get_du() << " В\n";
                    cout << "Возможная разница в силе тока: сейчас " << app->get_di() << " A\n";
                    cout << "Нажмите 1 для изменения внутреннего сопротивления, \n";
                    cout << "        2 для изменения необходимого напряжения, \n";
                    cout << "        3 для изменения необходимой силы тока, \n";
                    cout << "        4 для изменения возможной разницы напряжения, \n";
                    cout << "        5 для изменения возможной разницы силы тока, \n";
                    cout << "        0 для выхода: ";
                }
                int answer; cin >> answer;
                double u, i, r;
                switch (answer)
                {
                case 1:
                    if(flag)
                        cout << "Введите новое значение внутреннего сопротивления: ";
                    cin >> r;
                    app->set_r(r);
                    break;
                case 2:
                    if(flag)
                        cout << "Введите новое значение необходимого напряжения: ";
                    cin >> u;
                    app->set_req_u(u);
                    break;
                case 3:
                    if(flag)
                        cout << "Введите новое значение необходимой силы тока: ";
                    cin >> i;
                    app->set_req_i(i);
                    break;
                case 4:
                    if(flag)
                        cout << "Введите новое значение возможной разницы напряжения: ";
                    cin >> u;
                    app->set_du(u);
                    break;
                case 5:
                    if(flag)
                        cout << "Введите новое значение возможной разницы силы тока: ";
                    cin >> i;
                    app->set_di(i);
                    break;
                case 0:
                    break;
                default:
                    if(flag)
                        cout << "Некорректная команда\n";
                    break;
                }

            }
            else if(type == "CCS")
            {
                CCS* ccs = (dynamic_cast<CCS*>(branch[i]));
                if(flag)
                {
                    cout << "Внутреннее сопротивление: сейчас" << ccs->get_r() << " Oм\n";
                    cout << "ЭДС: сейчас " << ccs->get_e() << " В\n";
                    cout << "Нажмите 1 для изменения внутреннего сопротивления, \n";
                    cout << "        2 для изменения ЭДС, \n";
                    cout << "        0 для выхода: ";
                }
                int answer; cin >> answer;
                switch (answer)
                {
                case 1:
                    if(flag)
                        cout << "Введите новое значение внутреннего сопротивления: ";
                    double r; cin >> r;
                    ccs->set_r(r);
                    break;
                case 2:
                    if(flag)
                        cout << "Ввeдите новое значение ЭДС: ";
                    double e; cin >> e;
                    ccs->set_e(e);
                    break;
                case 0:
                    break;
                default:
                    if(flag)
                        cout << "Некорректная команда\n";
                    break;
                }
            }
            else if(type == "KEY")
            {
                Key* key = (dynamic_cast<Key*>(branch[i]));
                if(flag)
                    cout << "Положение ключа: сейчас ";
                if(key->get_state())
                {
                    if(flag)
                        cout << "закрыт\n";
                }
                else
                {
                    if(flag)
                        cout << "открыт\n";
                }
                if(flag)
                {
                    cout << "Нажмите 1 для изменения положения ключа,\n";
                    cout << "        0 для выхода: ";
                }
                int answer; cin >> answer;

                switch (answer)
                {
                case 1:
                    if(flag)
                        cout << "Введите новое положение ключа (1 - закрыт, 0 - открыт): ";
                    bool newstate; cin >> newstate;
                    key->set_state(newstate);
                case 0:
                    break;
                default:
                    if(flag)
                        cout << "Некоррректная команда\n";
                    break;
                }
            }
            else
            {
                if(flag)
                    cout << "Программист, если ты видишь это, то все очень плохо!" << endl;
            }
        }
    }

    int size()
    {
        return branch.size();
    }

    bool is_shorted_path()
    {
        if(branch.size() == 0)
            return true;
        if(!this->is_locked())
            return false;
        for(int i = 0; i < branch.size(); i++)
        {
            if(branch[i]->get_type() != "KEY")
                return false;

        }
        return true;
    }

    void print(){
        for(int i = 0; i < branch.size(); i++)
            branch[i]->print();
    }

    void save_in_file()
    {
        for(int i = 0; i < branch.size(); i++)
            branch[i]->save_in_file();
    }

    double get_emf()
    {
        double res = 0;
        for(int i = 0; i < branch.size(); i++)
        {
            if(branch[i]->get_type() == "CCS")
            {
                CCS* ccs = (dynamic_cast<CCS*>(branch[i]));
                res += ccs->get_e();
            }
        }
        return res;
    }

    void check_state(double i_power)
    {
        for(int i = 0; i < branch.size(); i++)
        {
            if(branch[i]->get_type() == "LMP")
            {
                Lamp* lamp = (dynamic_cast<Lamp*>(branch[i]));
                if(i_power > 0)
                    lamp->set_light(true);
                else
                    lamp->set_light(false);
            }
            else if(branch[i]->get_type() == "APP")
            {
                Appliance* app = (dynamic_cast<Appliance*>(branch[i]));
                double u = i_power * app->get_r();
                if(i <= app->get_di() + app->get_req_i() &&
                   u <= app->get_du() + app->get_req_u())
                    app->set_is_working(true);
                else
                    app->set_is_working(false);
            }
        }
    }
};

class Subchain
{
protected:
    vector<Branch*> subchain;
public:

    void set_branch(int subchain_number, bool flag)
    {
        if(subchain_number == 0 && subchain.size() > 0)
        {
            if(flag)
                cout << "В главной цепи нельзя создавать дополнительные ветки!\n";
        }
        else
            subchain.push_back(new Branch());
    }

    void set_el(int subchain_number, bool flag, int j, int type, int place, vector<double> param)
    {
        if(flag)
        {
            cout << "В этой подцепи " << subchain.size() << " веток\n";
            cout << "Введите номер ветки, куда вы хотите поместить элемент: ";
        }
        if(j == -1)
            cin >> j;
        j--;
        if(j >= 0 && j < subchain.size())
            subchain[j]->set_el_f(subchain_number, flag, type, place, param);
        else
        {
            if(flag)
                cout << "Некорректный номер ветки\n";
        }
    }

    void change_parameters(bool flag)
    {
        if(flag)
        {
            cout << "В этой подцепи " << subchain.size() << " веток\n";
            cout << "Введите номер ветке, в которой вы хотите\n";
            cout << "изменить параметры элемента: ";
        }
        int j; cin >> j; j--;
        if(j >= 0 && j < subchain.size())
            subchain[j]->change_parameters(flag);
        else
            if(flag)
                cout << "Некорректный номер ветки\n";
    }

    void remove_el()
    {
        cout << "В этой подцепи " << subchain.size() << " веток\n";
        cout << "Введите номер ветки, в которой вы хотите удалить элемент: ";
        int j; cin >> j; j--;
        if(j >= 0 && j < subchain.size())
            subchain[j]->remove_el_f();
        else
            cout << "Некорректный номер ветки\n";
    }

    bool has_shorted_paths()
    {
        for(int i = 0; i < subchain.size(); i++)
        {
            if(subchain[i]->is_shorted_path())
                return true;
        }
        return false;
    }

    double get_r_from_to(int j, int from, int to)
    {
        if(j == -1)
        {
            cout << "Введите номер ветки, где располагаются нужные для расчета элементы: ";
            cin >> j; j--;
        }
        double res = 0;
        if(j >= 0 && j < subchain.size())
        {
            if(from == -1 || to == -1)
            {
                cout << "Введите номера элементов: от которого надо начинать расчет и\n";
                cout << "на котором расчет должен заканчиваться(включительно):";
                cin >> from >> to;
            }
            res = subchain[j]->get_r_from_to(from, to);
        }
        else
            cout << "Некорректный номер ветки\n";
        return res;
    }

    double get_r_branch(int j)
    {
        if(j == -1)
        {
            cout << "Введите номер ветки, чье напряжение вы хотите найти: ";
            cin >> j; j--;
        }
        double res = 0;
        if(j >= 0 && j < subchain.size())
            res = subchain[j]->get_r_from_to(1, subchain[j]->size());
        else
            cout << "Некорректный номер ветки\n";
        return res;
    }

    double get_r_subchain()
    {
        double sum = 0.0;
        double sum_of_branch = 0.0;
        int cnt = 0;
        if(this->has_shorted_paths())
            return 0;
        for(int i = 0; i < subchain.size(); i++)
        {
            if(subchain[i]->is_locked())
            {
                double r = subchain[i]->get_r_from_to(1, subchain[i]->size());
                sum_of_branch = r;
                sum += 1 / r;
                cnt++;
            }
        }
        if(cnt == 0)
            return 0;
        else if(cnt == 1)
            return sum_of_branch;
        else
            return 1 / sum;
    }

    bool is_locked()
    {
        bool res = true;
        if(!subchain.empty())
        {
            res = subchain[0]->is_locked();
            for(int i = 1; i < subchain.size(); i++)
            {
                res = res || subchain[i]->is_locked();
            }
        }
        return res;
    }

    void remove_branch()
    {
        cout << "В этой подцепи " << subchain.size() << " веток\n";
        cout << "Введите номер удаляемой ветки: ";
        int j; cin >> j; j--;
        if(j >= 0 && j < subchain.size())
            subchain.erase(subchain.begin() + j);
        else
            cout << "Некорректный номер ветки\n";
    }

    int size()
    {
        return subchain.size();
    }

    void print()
    {
        for(int i = 0; i < subchain.size(); i++)
        {
            cout << "Ветка " << i + 1 << endl;
            subchain[i]->print();
            cout << endl;
        }
    }

    void save_in_file()
    {
        for(int i = 0; i < subchain.size(); i++)
        {
            out << "Ветка " << i + 1 << endl;
            subchain[i]->save_in_file();
            out << endl;
        }
    }

    double get_emf()
    {
        return subchain[0]->get_emf();
    }

    vector<Branch*> get_subchain()
    {
        return subchain;
    }

};

class Chain
{
protected:
    vector<Subchain*> chain;

public:

    void set(bool flag, int n, int i, int j, int type, int place, vector<double> param)
    {
        if(flag)
        {
            cout << "Нажмите 1, чтобы создать новую подцепь\n";
            cout << "        2, чтобы создать новую ветку\n";
            cout << "        3, чтобы создать новый элемент\n";
            cout << "        0, чтобы выйти\n";
        }
        if(n == -1)
            cin >> n;
        if(n == 1) chain.push_back(new Subchain());
        else
            if(n == 2 || n == 3)
            {
                if(flag)
                {
                    cout << "Введите номер подцепи, где вы хотите создать ";
                    if(n == 2) cout << "новую ветку: ";
                    if(n == 3) cout << "новый элемент: ";
                }
                if(i == -1)
                    cin >> i;
                i--;
                if(i >= 0 && i < chain.size())
                {
                    if(n == 2) chain[i]->set_branch(i, flag); //
                    if(n == 3) chain[i]->set_el(i, flag, j, type, place, param);
                }
                else
                {
                    if(flag)
                        cout << "Некорректный номер подцепи\n";
                }
            }
    }

    void remove()
    {
        map<int, pair<string, string>> m;
        m[0] = make_pair("exit", "error");
        m[3] = make_pair("element",
            "Введите номер подцепи, где вы хотите удалить элемент: ");
        m[2] = make_pair("branch",
            "Введите номер подцепи, где вы хотите удалить ветку: ");
        m[1] = make_pair("subchain",
            "Введите номер удаляемой подцепи: ");

        cout << "Нажмите 1, чтобы удалить подцепь\n";
        cout << "        2, чтобы удалить ветку\n";
        cout << "        3, чтобы удалить элемент\n";
        cout << "        0, чтобы выйти\n";
        int n; cin >> n;
        if(n > 0 && n < 4)
        {
            cout << m[n].second;
            int i; cin >> i; i--;
            if(i >= 0 && i < chain.size())
            {
                if(n == 3) chain[i]->remove_el();
                else if(n == 2) chain[i]->remove_branch();
                else if(n == 1) chain.erase(chain.begin() + i);
            }
            else
                cout << "Incorrect number of subchain\n";
        }
    }

    void change_parameters(bool flag)
    {
        if(flag)
        {
            cout << "Введите номер подцепи, где вы хотите \n";
            cout << "изменить параметры элемента: ";
        }
        int i; cin >> i; i--;
        if(i >= 0 && i < chain.size())
            chain[i]->change_parameters(flag);
        else
        {
            if(flag)
                cout << "Некорректный номер подцепи\n";
        }
    }

    bool is_locked()
    {
        bool res = true;
        for(int i = 0; i < chain.size(); i++)
        {
            res = res && chain[i]->is_locked();
        }
        return res;
    }

    double get_r_chain()
    {
        double r = 0.0;
        for(int i = 0; i < chain.size(); i++)
            r += chain[i]->get_r_subchain();

        return r;
    }

    double get_r_subchain(int i)
    {
        if(i == -1)
        {
            cout << "Введите номер подцепи, чье сопротивление вы хотите узнать: ";
            cin >> i; i--;
        }
        double r = 0;
        if(i >= 0 && i < chain.size())
            r = chain[i]->get_r_subchain();
        else
            cout << "Некорректный номер подцепи\n";
        return r;
    }

    double get_r_branch(int i, int j)
    {
        if(i == -1)
        {
            cout << "Введите номер подцепи, где располагается нужная ветка: ";
            cin >> i; i--;
        }
        double r = 0;
        if(i >= 0 && i < chain.size())
            r = chain[i]->get_r_branch(j);
        else
            cout << "Некорректный номер подцепи\n";
        return r;
    }

    double get_r_from_to(int i, int j, int from, int to)
    {
        if(i == -1)
        {
            cout << "Введите номер подцепи, где располагаются нужные элементы: ";
            cin >> i; i--;
        }
        double r = 0;
        if(i >= 0 && i < chain.size())
            r = chain[i]->get_r_from_to(j, from, to);
        else
            cout << "Некорректный номер подцепиn";
        return r;
    }

    void print()
    {
        check_state();
        for(int i = 0; i < chain.size(); i++)
        {
            cout << "\nПодцепь " << i + 1 << endl;
            chain[i]->print();
        }
    }

    double get_i(int subch, int br, bool flag)
    {
        if(subch == -1 && br == -1)
        {
            cout << "Введите координаты - номер подцепи и ветки, в которой вы хотите найти силу тока: ";
            cin >> subch >> br;
            subch--; br--;
        }
        double res = 0;
        string s = "";
        if(subch >= 0 && subch < chain.size())
        {
            if(br >= 0 && br < chain[subch]->size())
            {
                if(this->is_locked())
                {
                    double i_all = this->get_i_all(flag);
                    double r_subch = this->get_r_subchain(subch);
                    double r_branch = this->get_r_branch(subch, br);
                    if(r_subch == 0)
                        s = "Подцепь закорочена\n";
                    else if(r_branch == 0)
                        s = "Ветка закорочена\n";
                    else
                        res = i_all * r_subch / r_branch;
                }
                else
                    s = "Цепь не замкнута\n";
            }
            else
                s = "Некорректный номер ветки\n";
        }
        else
            s = "Некорректный номер подцепи\n";
        if(flag)
            cout << s;

        return res;
    }

    double get_i_all(bool flag)
    {
        double i_all = 0;
        string s;
        if(this->is_locked())
        {
            if(chain.size())
            {
                double r_all = this->get_r_chain();
                double u_all = chain[0]->get_emf();

                if(r_all == 0)
                {
                    s = "Цепь закорочена\n";
                }
                else
                {
                    i_all = u_all / r_all;
                }
            }
            else
                s = "В цепи отсутствуют источники тока\n";
        }
        else
            s = "Цепь не замкнута\n";
        if(flag)
            cout << s;
        return i_all;
    }

    double get_u_chain(bool flag)
    {
        double res = 0;
        if(this->is_locked())
        {
            if(chain.size())
                res = chain[0]->get_emf();
            else
            {
                if(flag)
                    cout << "В цепи отсутствуют источники ток\n";
            }
        }
        else
        {
            if(flag)
                cout << "Цепь не замкнута\n";
        }
        return res;
    }

    double get_u_subchain(bool flag)
    {
        double res = 0;
        if(flag)
            cout << "Введите номер подцепи, напряжение на которой вы хотите найти: ";
        int subch; cin >> subch; subch--;
        if(subch >=0 && subch < chain.size())
        {
            if(this->is_locked())
            {
                double r = this->get_r_subchain(subch);
                if(r == 0)
                {
                    if(flag)
                        cout << "Цепь закорочена\n";
                }
                else
                {
                    double i_all = this->get_i_all(flag);
                    res = r * i_all;
                }
            }
            else
            {
                if(flag)
                    cout << "Цепь не замкнута\n";
            }
        }
        else
        {
            if(flag)
                cout << "Некорректный номер подцепи\n";
        }
        return res;
    }

    double get_u_branch(bool flag)
    {
        if(flag)
            cout << "Введите координаты - номер подцепи и номер ветки, напряжение на которой вы хотите найти: ";
        int subch, br;
        cin >> subch >> br;
        subch--; br--;
        double i = this->get_i(subch, br, flag);
        double r = this->get_r_branch(subch, br);
        return i * r;
    }

    double get_u_from_to(bool flag, int subch, int br, int from, int to)
    {
        if(flag)
        {
            cout << "Введите координаты - номер подцепи, номер ветки,\т ";
            cout << "номера стартого и конечного элементов для расчетов: ";
        }
        if(subch == -1 && br == -1 && from == -1 && to == -1)
        {
            cin >> subch >> br >> from >> to;
            subch--; br--;
        }
        double i = this->get_i(subch, br, flag);
        double r = this->get_r_from_to(subch, br, from, to);
        return i * r;
    }

    void check_state()
    {
        for(int i = 0; i < chain.size(); i++)
        {
            vector<Branch*> v = chain[i]->get_subchain(); //i - номер подцепи
            for(int j = 0; j < v.size(); j++)
            {
                double i_power = get_i(i, j, false);
                v[j]->check_state(i_power);
            }
        }
    }

    void load_from_file()
    {
        ifstream in;
        in.open("in.txt");
        string s;
        int cur_subchain = -1, cur_branch = -1;
        while(in >> s)
        {
            if(s == "Подцепь")
            {
                in >> cur_subchain;
                set(false, 1, -1, -1, -1, -1, vector<double>());
            }
            else if(s == "Ветка")
            {
                in >> cur_branch;
                set(false, 2, cur_subchain, -1, -1, -1, vector<double>());
            }
            else if(s == "LMP")
            {
                vector<double> param(1);
                in >> param[0];
                set(false, 3, cur_subchain, cur_branch, 1, 1, param);
            }
            else if(s == "RES")
            {
                vector<double> param(1);
                in >> param[0];
                set(false, 3, cur_subchain, cur_branch, 2, 1, param);
            }
            else if(s == "APP")
            {
                vector<double> param(5);
                in >> param[0] >> param[1] >> param[2] >> param[3] >> param[4];
                set(false, 3, cur_subchain, cur_branch, 3, 1, param);
            }
            else if(s == "CCS")
            {
                vector<double> param(2);
                in >> param[0] >> param[1];
                set(false, 3, cur_subchain, cur_branch, 4, 1, param);
            }
            else if(s == "KEY")
            {
                vector<double> param(1);
                in >> param[0];
                set(false, 3, cur_subchain, cur_branch, 5, 1, param);
            }
            else if(s.find("Цепь_номер") == string::npos)
                break;

        }
    }

    void save_in_file()
    {
        check_state();
        for(int i = 0; i < chain.size(); i++)
        {
            out << "Подцепь " << i + 1 << endl;
            chain[i]->save_in_file();
        }
    }
};

int main()
{

    out.open("out.txt");
    in.open("in.txt");
    setlocale(LC_ALL, "Russian");
    Chain* chain = new Chain();

    int n = 1, cnt = 0;
    while(n != 0)
    {
        cout << "\nНажмите \n";
        cout << "1  - создание (подцепи, ветки, элемента)\n";
        cout << "2  - проверка цепи на замкнутость\n";
        cout << "3  - удаление (подцепи, ветки, элемента)\n";
        cout << "4  - изменение параметров\n";
        cout << "5  - вывод на экран\n";
        cout << "6  - получить сопротивление всей цепи\n";
        cout << "7  - получить сопротивление подцепи\n";
        cout << "8  - получить сопротивление ветки\n";
        cout << "9  - получить сопротивление на отрезке ветки\n";
        cout << "10 - получить общую силу тока в цепи\n";
        cout << "11 - получить силу тока на произвольной ветке\n";
        cout << "12 - получить напряжение на цепи\n";
        cout << "13 - получить напряжение на подцепи\n";
        cout << "14 - получить напряжение на ветке\n";
        cout << "15 - получить напряжение на отрезке ветки\n";
        cout << "16 - загрузить из файла\n";
        cout << "17 - сохранить в файл\n";
        cout << "0  - выход\n";
        cin >> n;

        switch (n)
        {
        case 0:
            break;
        case 1:
            chain->set(true, -1, -1, -1, -1, -1, vector<double>());
            break;
        case 2:
            if(chain->is_locked())
                cout << "Цепь замкнута" << endl;
            else
                cout << "Цепь разомкнута" << endl;
            break;
        case 3:
            chain->remove();
            break;
        case 4:
            chain->change_parameters(true);
            break;
        case 5:
            chain->print();
            break;
        case 6:
            cout << chain->get_r_chain() << " Ом" << endl;
            break;
        case 7:
            cout << chain->get_r_subchain(-1) << " Ом" << endl;
            break;
        case 8:
            cout << chain->get_r_branch(-1, -1) << " Ом" << endl;
            break;
        case 9:
            cout << chain->get_r_from_to(-1, -1, -1, -1) << " Ом" << endl;
            break;
        case 10:
            cout << chain->get_i_all(true) << " А" << endl;
            break;
        case 11:
            cout << chain->get_i(-1, -1, true) << " А" << endl;
            break;
        case 12:
            cout << chain->get_u_chain(true) << " В" << endl;
            break;
        case 13:
            cout << chain->get_u_subchain(true) << " В" << endl;
            break;
        case 14:
            cout << chain->get_u_branch(true) << " В" << endl;
            break;
        case 15:
            cout << chain->get_u_from_to(true, -1, -1, -1, -1) << " В" << endl;
            break;
        case 16:
            chain->load_from_file();
            cout << "Цепь загружена из файла" << endl;
            break;
        case 17:
            cnt++;
            out << "Цепь_номер_" << cnt << "\n";
            chain->save_in_file();
            cout << "Цепь сохранена в файле" << endl;
            break;

        default:
            cout << "Некорректный номер команды, попробуй ещё раз\n";
            break;
        }
    }
    cout << "Программа завершена успешно\n";
    system("pause");
    return 0;
}