#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <map>
#include <sstream>
#include <list>
#include <math.h>

using namespace std;


struct cso
{
    public:
    string nev_cso;
    double d_cso;
    bool nyitvae = false ;
    string tar1;
    string tar2;
    bool switch_=false;
};

struct cel
{
    string cel_nev;
    string cel_nedv;
    int cel_V;
};

struct tartaly
{
    string nev_tart;
    double V;
    map<tartaly*,cso>szomsz;
    bool tisztae = true;
    string nedv;
    double V_nedv =0;
    double delta;

};

struct szabad_cso
{
    tartaly* t1;
    tartaly* t2;
    cso ertek;
};

struct halozat
{
    vector<tartaly*>tartalyok;
    vector<cso>csovek;
};

bool beolvas(string fnev, string knev, string cnev, halozat &graf, cel C)
{
    tartaly T;
    string sor;
    ifstream bf;
    ifstream bk;
    ifstream bc;

    bc.open(cnev.c_str(), ifstream::in);
    bf.open(fnev.c_str(), ifstream::in);
    bk.open(knev.c_str(), ifstream::in);
    if(!bf.good()) return false;
    stringstream ss;

    while( getline(bf, sor) && sor != "-")

    {

        int temp;
        ss.clear();
        ss << sor;
        sor = "";

        ss >> T.nev_tart;
        ss >> T.V;

        graf.tartalyok.push_back(new tartaly(T));

    }

    cso CS;
    szabad_cso SZ;
    while( getline(bf,sor))
    {
        ss.clear();
        ss << sor;
        sor = "";


        ss >> CS.nev_cso;
        ss >> CS.d_cso;
        ss >> CS.tar1;
        ss >> CS.tar2;

        CS.nyitvae=false;

        graf.csovek.push_back(CS);
        SZ.ertek.nev_cso = CS.nev_cso;
        SZ.ertek.d_cso = CS.d_cso;

        for (int i=0; i<graf.tartalyok.size(); i++)
        {

            if (graf.tartalyok[i]->nev_tart == CS.tar1 )
            {
                SZ.t1 = graf.tartalyok[i];
                for (int j=0; j<graf.tartalyok.size(); j++)
                {
                    if (graf.tartalyok[j]->nev_tart == CS.tar2)
                    {
                        graf.tartalyok[i]->szomsz.insert(pair<tartaly*,cso>(graf.tartalyok[j],CS));
                        SZ.t2 = graf.tartalyok[j];



                    }
                }
            }

            if (graf.tartalyok[i]->nev_tart == CS.tar2 )
            {
                for (int j=0; j<graf.tartalyok.size(); j++)
                {
                    if (graf.tartalyok[j]->nev_tart == CS.tar1)
                    {
                        graf.tartalyok[i]->szomsz.insert(pair<tartaly*,cso>(graf.tartalyok[j],CS));


                    }
                }
            }

            ///       graf.csovek.push_back(SZ);

        }
        /*        for (int i=0; i<graf.csovek.size();i++)
                {
                    for (int j=i+1; j<graf.csovek.size();j++)
                    {
                        if (graf.csovek[i].ertek.nev_cso == graf.csovek[j].ertek.nev_cso)
                         graf.csovek.erase(graf.csovek.begin()+j);
                    }

                }*/
    }

    if(!bk.good()) return false;


    while(getline(bk,sor))
    {
        string temp_nedv;
        int temp_V = 0;
        ss.clear();
        ss << sor;
        sor = "";


        ss >> temp_nedv;
        ss >> sor;
        ss >> temp_V;

        //cout << temp_nedv << endl;

        for (int i=0; i<graf.tartalyok.size(); i++)
        {
            if (graf.tartalyok[i]->nev_tart == sor)
            {
                graf.tartalyok[i]->nedv = temp_nedv;
                graf.tartalyok[i]->V_nedv = temp_V;
                //cout<<" "<<graf.tartalyok[i]->nev_tart<<" ";
                graf.tartalyok[i]->tisztae = false;
            }
        }


    }

    sor= "";

    while (getline(bc,sor))
    {
        sor= "";
        ss.clear();
        ss << sor;

        ss >> C.cel_nedv;
        ss >> C.cel_nev;
        ss >> C.cel_V;

    }


    return true;


}

void kiir(halozat &graf)
{
    for (int i=0; i<graf.tartalyok.size(); i++)
    {
        cout << graf.tartalyok[i]->nev_tart   << endl;
    }

    for (int i=0; i<graf.csovek.size(); i++)
    {
        cout << graf.csovek[i].nev_cso << " | nyitvae: "<< graf.csovek[i].nyitvae << " | switch: " << graf.csovek[i].switch_ << endl;
    }
}


vector<vector<double>> createflowmatrix(halozat& graf)
{
     vector<vector<double>> flowmatrix ;

     int k= 0;
     vector<double> flows;
     for(int i=0; i<graf.tartalyok.size();i++)
    {

        for (int j=0; j<graf.csovek.size();j++)
        {
            if (graf.tartalyok[i]->nev_tart == graf.csovek[j].tar1)
            {
                if (graf.csovek[j].nyitvae == true )
                {
                    if (graf.csovek[j].switch_ == false) flows.push_back(-graf.csovek[j].d_cso);
                    if (graf.csovek[j].switch_ == true)  flows.push_back(graf.csovek[j].d_cso);
                }
                if (graf.csovek[j].nyitvae == false ) flows.push_back(0);
            }
             if (graf.tartalyok[i]->nev_tart == graf.csovek[j].tar2)
            {
                if (graf.csovek[j].nyitvae == true )
                {
                    if (graf.csovek[j].switch_ == true) flows.push_back(-graf.csovek[j].d_cso);
                    if (graf.csovek[j].switch_ == false)  flows.push_back(graf.csovek[j].d_cso);
                }
                if (graf.csovek[j].nyitvae == false ) flows.push_back(0);
            }

            if(graf.tartalyok[i]->nev_tart != graf.csovek[j].tar1 && graf.tartalyok[i]->nev_tart != graf.csovek[j].tar2)
            {
                flows.push_back(0);
            }

        }
            flowmatrix.push_back(flows);
            flows.clear();
    }


    for (int i=0; i<flowmatrix.size();i++)
    {
        for (int j=0; j<flowmatrix[i].size(); j++)
        {
            cout << flowmatrix[i][j] << "|";
        }
        cout << endl;
    }

    return flowmatrix;
}

void step ( halozat& graf, vector<vector<double>> flowmatrix, int time)
{

    vector<double> sum(graf.tartalyok.size(),0);



    double t = time;
    double t_temp = 1-time;
    int keresett = 0;

    for(int i=0; i<graf.tartalyok.size(); i++)
    {
        for(int j=0; j<graf.csovek.size(); j++)
        {
            sum[i]=flowmatrix[i][j] + sum[i];
        }
    }
    for(int i=0; graf.tartalyok.size(); i++)
    {
        if(sum[i] != 0)
        {
            if(sum[i]>0 && t_temp > (graf.tartalyok[i]->V - graf.tartalyok[i]->V_nedv)/sum[i]) {t_temp = (graf.tartalyok[i]->V - graf.tartalyok[i]->V_nedv)/sum[i]; keresett = i;}
            if(sum[i]<0 && t_temp > (0 - graf.tartalyok[i]->V_nedv)/sum[i]) {t_temp = (0 - graf.tartalyok[i]->V_nedv)/sum[i]; keresett = i;}
        }
    }
    if(t+t_temp == 1)
    {
        for(int i=0 ;i <graf.tartalyok.size();i++)
        {
            graf.tartalyok[i]->V_nedv += sum[i]*t_temp;
        }
        return;
    }

    else
    {
        for(int i = 0; i<graf.tartalyok.size();i++)
        {
            graf.tartalyok[i]->V_nedv += sum[i]*t_temp;
        }
    }
    double poz[graf.csovek.size()];
    int alfa = 1;
    double sumt = sum[keresett];

    if(sum[keresett]<0)
    {
        alfa = -1;
    }
    for(int i=0; i<graf.csovek.size();i++)
    {
        if(flowmatrix[keresett][i]*alfa > 0)
        {
            poz[i]=flowmatrix[keresett][i];
            sumt = sumt-poz[i];
        }
    }
    if(sumt = 0)
    {
        for (int i=0; i<graf.csovek.size();i++)

    {
        if(flowmatrix[keresett][i] != 0)
        {
           if( graf.csovek[i].tar1 == graf.tartalyok[keresett]->nev_tart)
            {

            for(int j=0; j<graf.tartalyok.size();j++)
           {
               if(graf.tartalyok[j]->nev_tart == graf.csovek[i].tar2)
               {
                          flowmatrix[keresett][i]=0;
                          flowmatrix[j][i]=0;
               }
           }
        }
        else
        {
             for(int j=0; j<graf.tartalyok.size();j++)
           {
               if(graf.tartalyok[j]->nev_tart == graf.csovek[i].tar1)
               {
                          flowmatrix[keresett][i]=0;
                          flowmatrix[j][i]=0;
               }
           }
        }
        }
    }
    step(graf, flowmatrix, t+t_temp);
    }
    else
    {  alfa = 1;
       double sumt2;
       vector<int>index;

       if (sumt < 0)    alfa=-1;

       for(int i= 0; i< graf.csovek.size(); i++)
       {
          if ( flowmatrix[keresett][i]*alfa > 0 )
          {
              sumt2=+flowmatrix[keresett][i];
              index.push_back(i);

          }
       }

        for(int i=0; i<index.size();i++)
        {
              if (graf.csovek[index[i]].tar1 == graf.tartalyok[keresett]->nev_tart)
        {
            for (int j=0; j<graf.tartalyok.size();j++)
            {
                if(graf.csovek[index[i]].tar2 == graf.tartalyok[j]->nev_tart)
                {
                  flowmatrix[keresett][index[i]] =  ((sumt2-sum[keresett])/sumt2)*flowmatrix[keresett][index[i]];
                    flowmatrix[j][index[i]] = ((sumt2-sum[keresett])/sumt2)*flowmatrix[j][index[i]];
                }
            }
        }
    }
        step(graf,flowmatrix,t+t_temp);
    }

}


int main()
{

halozat graf;
cel C;
vector<vector<double>>flowmatrix;
beolvas("rendszer2.txt","kezdeti2.txt","celallapot",graf,C);




string command;
string name;
string dest;
ifstream initcommand("Command1.txt");
while(initcommand.good())
{   int i=0;
    initcommand >> command;

    if(command == "step")
        {
            int time = 0;
            vector<vector<double>> flowmatrix = createflowmatrix(graf);
            step(graf,flowmatrix,time);
        }
    if(command == "off")
    {
        initcommand >> name;
        while(graf.csovek[i].nev_cso != name)
        {
            i++;
        }
        graf.csovek[i].nyitvae = false;
    }
    if(command == "on")
    {
        initcommand >> name;

        for (int i=0; i<graf.csovek.size(); i++)
        {
            if(graf.csovek[i].nev_cso == name)
            {

                graf.csovek[i].nyitvae = true;

                initcommand >> dest;

                if(graf.csovek[i].switch_ == true && dest == graf.csovek[i].tar1) graf.csovek[i].nyitvae = true;
                else if(graf.csovek[i].switch_ == true && dest == graf.csovek[i].tar2){ graf.csovek[i].nyitvae = true; graf.csovek[i].switch_ = false;}
                else if(graf.csovek[i].switch_ == false && dest == graf.csovek[i].tar2) graf.csovek[i].nyitvae = true;
                else if(graf.csovek[i].switch_ == false && dest == graf.csovek[i].tar1) {graf.csovek[i].nyitvae = true; graf.csovek[i].switch_ = true;}
                else cout << "hibas parancs";
            }
        }
    }
    if(command == "clean")
    {
        initcommand >> name;

         while(graf.tartalyok[i]->nev_tart != name)
        {
            i++;
        }
        if (graf.tartalyok[i]->V_nedv == 0)
        {
            for(int i=0; i<graf.csovek.size(); i++)
            {
                if(graf.csovek[i].tar1 == name or graf.csovek[i].tar2 == name)
                    graf.csovek[i].nyitvae = false;
            }
            graf.tartalyok[i]->tisztae = true;
        }
    }
}



kiir(graf);
    return 0;

}