source: observatorio/simulacion/SimEscenariosEconomicos/simulator.C

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

# include <dbProperties.H>

# include <ioManager.H>

# include "internal/c.h"

typedef Arcs_Index <Graph> ArcsIndex;

typedef List <ProductInfo> SuggestionList;

typedef Map <std::string, SuggestionList> SuggestionBuffer;

/* Aquí mapeo los nodos que subieron por orden directa (es decir los que
   aumentaron por ser nodos iniciales de estudio) con la cantidad aumentada.
*/
typedef Map <Graph::Node *, real> MapNodesQuantity;

typedef Map <size_t, Graph::Node *> MapImports;

// Mapea el id de un producto con el nodo en el grafo correspondiente
typedef Map <long, Graph::Node *> MapProductNode;

void computeOutputQuantityAndPutInQueue(Graph & g, Graph::Node * src,
                                        DynListQueue <Graph::Node *> & q) {

    real sum = 0;

    for (Graph::Node_Arc_Iterator it(src); it.has_current(); it.next()) {

        Graph::Arc * arc = it.get_current();

        if (g.get_src_node(arc) != src)
            continue;

        sum += arc->get_info().newValue2;
    }

    for (Graph::Node_Arc_Iterator it(src); it.has_current(); it.next()) {

        Graph::Arc * arc = it.get_current();

        if (g.get_src_node(arc) != src)
            continue;

        const real proportion = sum == 0 ? 0 : arc->get_info().newValue2 / sum;

        arc->get_info().newValue2 = src->newValue2 * proportion;

        q.put(g.get_tgt_node(arc));
    }
}

void prepareGraphForProduction(Graph & g) {

    for(Graph::Node_Iterator it(g); it.has_curr() ; it.next()) {

        Graph::Node * node = it.get_curr();

        node->newValue1 = node->get_info()->getTotalQuantity();

        node->newValue2 = node->get_info()->getQuantity();

        node->newValue3 = node->get_info()->getUsedCapacity();
    }

    for(Graph::Arc_Iterator it(g); it.has_curr() ; it.next()) {

        Graph::Arc * arc = it.get_curr();

        arc->get_info().newValue1 = arc->get_info().totalQuantity;

        arc->get_info().newValue2 = arc->get_info().quantity;

        arc->get_info().newValue3 = arc->get_info().usedQuantity;
    }
}

void computeNodeQuantity(Graph & g, Graph::Node * tgt) {

    Map <long, Aleph::pair<real, real>> inputsMap;

    for (Graph::Node_Arc_Iterator it(tgt); it.has_current(); it.next()) {

        Graph::Arc * arc = it.get_current();

        if (g.get_tgt_node(arc) != tgt)
            continue;

        Aleph::pair<real, real> * ptrPair =
            inputsMap.search(arc->get_info().inputId);

        if (ptrPair == NULL) {
            const real & unit = arc->get_info().reqQuantity;

            ptrPair =
                inputsMap.insert(arc->get_info().inputId,
                                 Aleph::pair<real, real>(0, unit));
        }

        ptrPair->first += arc->get_info().newValue2;
    }

    List<Aleph::pair<real, real>> list;

    inputsMap.for_each(IOManager::InsertFromMapInList(list));

    List <Aleph::pair<real, real>>::Iterator it(list);

    Aleph::pair<real, real> & p = it.get_current();

    tgt->newValue2 = p.first / p.second;

    it.next();

    for ( ; it.has_current(); it.next()) {
        Aleph::pair<real, real> & _p = it.get_current();

        real q = _p.first / _p.second;

        if (q < tgt->newValue2)
            tgt->newValue2 = q;
    }
}

struct SetUsedQuantity {

    Graph & g;

    SetUsedQuantity(Graph & _g)
        : g(_g) {

        // Empty
    }

    void operator () (const long &, List <Graph::Arc *> & arcs) {

        real sum = 0;

        for (List<Graph::Arc *>::Iterator it(arcs); it.has_current(); it.next())
            sum += it.get_current()->get_info().newValue2;

        for (List<Graph::Arc *>::Iterator it(arcs); it.has_current();
             it.next()) {

            Graph::Arc * a = it.get_current();

            Graph::Node * t = g.get_tgt_node(a);

            real unit = a->get_info().reqQuantity;

            real needed = t->newValue2 * unit;

            real proportion = a->get_info().newValue2 / sum;

            a->get_info().newValue3 = needed * proportion;

            Graph::Node * tgt = g.get_tgt_node(a);

            if ((tgt->get_info()->getTotalQuantity() >
                tgt->get_info()->getQuantity()) and
                (a->get_info().quantity == a->get_info().usedQuantity))
                a->get_info().isMin = true;
            else
                a->get_info().isMin = false;
        }
    }
};

void computeUsageInputQuantities(Graph & g, Graph::Node * tgt) {

    Map <long, List <Graph::Arc *>> inputsMap;

    for (Graph::Node_Arc_Iterator it(tgt); it.has_current(); it.next()) {

        Graph::Arc * arc = it.get_current();

        if (g.get_tgt_node(arc) != tgt)
            continue;

        const long & inputId = arc->get_info().inputId;

        List <Graph::Arc *> * ptrList = inputsMap.search(inputId);

        if (ptrList == NULL)
            ptrList = inputsMap.insert(inputId, List<Graph::Arc *>());

        ptrList->append(arc);
    }

    inputsMap.for_each(SetUsedQuantity(g));
}

void decreaseProduction(Graph & g, Graph::Node * start, const real & value) {

    start->newValue1 *= (1 - value / 100);

    if (start->newValue1 >= start->newValue2)
        return;

    start->newValue2 *= (1 - value / 100);

    DynListQueue <Graph::Node *> queue;

    computeOutputQuantityAndPutInQueue(g, start, queue);

    while (not queue.is_empty()) {

        Graph::Node * p = queue.get();

        computeNodeQuantity(g, p);
        computeUsageInputQuantities(g, p);

        real diff = std::fabs(p->newValue2 - p->get_info()->getQuantity());

        p->newValue1 -= diff;

        computeOutputQuantityAndPutInQueue(g, p, queue);
    }
}

struct ArcsGroup {

    std::string tariffCode;

    real neededQuantity;

    real price;

    List <Graph::Arc *> arcs;
};

typedef Map <long, ArcsGroup> MapGroupArcs;

void groupInputs(Graph & g, Graph::Node * tgt, MapGroupArcs & map) {

    for (Graph::Node_Arc_Iterator it(tgt); it.has_current(); it.next()) {

        Graph::Arc * arc = it.get_current();

        if (g.get_tgt_node(arc) != tgt)
            continue;

        long inputId = arc->get_info().inputId;

        ArcsGroup * ptrArcsGroup = map.search(inputId);

        if (ptrArcsGroup == NULL) {

            ptrArcsGroup = map.insert(inputId, ArcsGroup());

            ptrArcsGroup->tariffCode =
                g.get_src_node(arc)->get_info()->getTariffCode();

            ptrArcsGroup->neededQuantity =
                tgt->newValue2 * arc->get_info().reqQuantity;

            ptrArcsGroup->price = arc->get_info().price;
        }

//        // TODO: Pendiente: Posiblemente se reste también lo que me proveen los
//        //       proveedores no visibles en la red

        ptrArcsGroup->neededQuantity -= arc->get_info().usedQuantity;

        if (ptrArcsGroup->neededQuantity < 0.0)
            ptrArcsGroup->neededQuantity = 0.0;

        ptrArcsGroup->arcs.append(arc);
    }
}

struct IncreaseUsageInArcs {

    void operator () (const long &, ArcsGroup & group) {

        if (group.neededQuantity <= 0)
            return;

        real sum = 0;

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            ArcInfo & info = arc->get_info();

            sum += info.newValue2 - info.newValue3;
        }

        real howManyIncrease = std::min(group.neededQuantity, sum);

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            ArcInfo & info = arc->get_info();

            real availableQuantity = info.newValue2 - info.newValue3;

            real proportion = sum == 0 ? 0 : availableQuantity / sum;

            real howManyIncreaseInArc = howManyIncrease * proportion;

            info.newValue3 += howManyIncreaseInArc;

            group.neededQuantity -= howManyIncreaseInArc;
        }
    }
};

struct IncreaseProductionInSuppliers {

    Graph & g;

    IncreaseProductionInSuppliers(Graph & _g)
        : g(_g) {

        // Empty
    }

    void operator () (const long &, ArcsGroup & group) {

        if (group.neededQuantity <= 0)
            return;

        real sum = 0;

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            Graph::Node * src = g.get_src_node(arc);

            if (src->type == IMPORT or src->type == SUGGESTED or
                src->get_info()->getType() == INPUT_GOOD)
                continue;

            ArcInfo & arcInfo = arc->get_info();

            sum += arcInfo.newValue1 - arcInfo.newValue2;
        }

        real howManyIncrease = std::min(group.neededQuantity, sum);

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            ArcInfo & arcInfo = arc->get_info();

            Graph::Node * src = g.get_src_node(arc);

            if (src->type == IMPORT or src->type == SUGGESTED or
                src->get_info()->getType() == INPUT_GOOD)
                continue;

            Good * good = src->get_info().get();

            real availableQuantity = arcInfo.newValue1 - arcInfo.newValue2;

            real proportion = sum == 0 ? 0 : availableQuantity / sum;

            real howManyIncreaseInArc = howManyIncrease * proportion;

            arcInfo.newValue2 += howManyIncreaseInArc;
            arcInfo.newValue3 += howManyIncreaseInArc;
            group.neededQuantity -= howManyIncreaseInArc;

            /* El monto de compra de la cantidad que quiero incrementar dividido
               entre el precio unitario de venta declarado me da la cantidad
               que debo aumentar en el nodo.
            */
            real nodeQuantity = howManyIncrease * arcInfo.price /
                                good->getUnitarianPrice();

            src->newValue2 += nodeQuantity;
        }
    }
};

struct UseNewProductionInSuppliers {

    Graph & g;

    MapNodesQuantity & increasedNodes;

    UseNewProductionInSuppliers(Graph & _g, MapNodesQuantity & _increasedNodes)
        : g(_g), increasedNodes(_increasedNodes) {

        // Empty
    }

    void operator () (const long &, ArcsGroup & group) {

        if (group.neededQuantity <= 0)
            return;

        real sum = 0;

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            Graph::Node * src = g.get_src_node(arc);

            real * ptrQ = increasedNodes.search(src);

            if (ptrQ == NULL)
                continue;

            /*
               Incremento cantidad disponible en nodo en función a la unidad
               en el arco.
            */
            sum += *ptrQ * src->get_info()->getUnitarianPrice() /
                   arc->get_info().price;
        }

        real howManyIncrease = std::min(group.neededQuantity, sum);

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            ArcInfo & arcInfo = arc->get_info();

            Graph::Node * src = g.get_src_node(arc);

            real * ptrQ = increasedNodes.search(src);

            if (ptrQ == NULL)
                continue;

            real q = *ptrQ * src->get_info()->getUnitarianPrice() /
                       arc->get_info().price;

            real proportion = sum == 0 ? 0 : q / sum;

            real howManyIncreaseInArc = howManyIncrease * proportion;

            arcInfo.newValue2 += howManyIncreaseInArc;
            arcInfo.newValue3 += howManyIncreaseInArc;
            group.neededQuantity -= howManyIncreaseInArc;

            /*
               Quito cantidad disponible en nodo lo que se incrementó en el
               arco en función de la unidad en el nodo.
            */
            *ptrQ -= howManyIncreaseInArc * arc->get_info().price /
                     src->get_info()->getUnitarianPrice();
        }
    }
};

struct IncreaseInactiveCapacity {

    Graph & g;

    IncreaseInactiveCapacity(Graph & _g)
        : g(_g) {

        // Empty
    }

    void operator () (const long &, ArcsGroup & group) {

        if (group.neededQuantity <= 0.0)
            return;

        real sum = 0.0;

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            Graph::Node * src = g.get_src_node(arc);

            if (src->get_info()->getType() != PRODUCT_GOOD)
                continue;

            if (src->get_info()->getUsedCapacity() >= 100.0)
                continue;

            real totalCapacity = 100.0 * src->newValue1 / src->newValue3;

            assert(arc->get_info().price > 0.0);

            sum += (totalCapacity - src->newValue1) *
                    src->get_info()->getUnitarianPrice() /
                    arc->get_info().price;
        }

        real howManyIncrease = std::min(group.neededQuantity, sum);

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            ArcInfo & arcInfo = arc->get_info();

            Graph::Node * src = g.get_src_node(arc);

            if (src->get_info()->getType() != PRODUCT_GOOD)
                continue;

            if (src->get_info()->getUsedCapacity() >= 100.0)
                continue;

            Good * good = src->get_info().get();

            real totalCapacity = 100.0 * src->newValue1 / src->newValue3;

            real q = (totalCapacity - src->newValue1) *
                       src->get_info()->getUnitarianPrice() /
                       arc->get_info().price;

            real proportion = sum == 0.0 ? 0.0 : q / sum;

            real howManyIncreaseInArc = howManyIncrease * proportion;

            arcInfo.newValue1 += howManyIncreaseInArc;
            arcInfo.newValue2 += howManyIncreaseInArc;
            arcInfo.newValue3 += howManyIncreaseInArc;
            group.neededQuantity -= howManyIncreaseInArc;

            if (group.neededQuantity < 0.0)
                group.neededQuantity = 0.0;

            real nodeQuantity = howManyIncreaseInArc * arcInfo.price /
                                  good->getUnitarianPrice();

            src->newValue1 += nodeQuantity;
            src->newValue2 += nodeQuantity;

            src->newValue3 = 100.0 * src->newValue1 / totalCapacity;
        }
    }
};

struct PutSuppliersInQueue {

    Graph & g;

    DynListQueue <Graph::Node *> & q;

    PutSuppliersInQueue(Graph & _g, DynListQueue <Graph::Node *> & _q)
        : g(_g), q(_q) {

        // Empty
    }

    void operator () (const long &, ArcsGroup & group) {

        for (List<Graph::Arc *>::Iterator it(group.arcs); it.has_current();
             it.next()) {

            Graph::Arc * arc = it.get_current();

            Graph::Node * src = g.get_src_node(arc);

            if (src->type == IMPORT or src->type == SUGGESTED or
                src->get_info()->getType() == INPUT_GOOD)
                continue;

            q.put(src);
        }
    }
};

bool eval(const long & id, List<long> & ids) {
    for (List<long>::Iterator it(ids); it.has_current(); it.next())
        if (id == it.get_current())
            return false;
    return true;
}

struct MakeSuggestions {

    AutoConnection & conn;

    Graph & g;

    Graph::Node * tgt;

    SuggestionBuffer & buffer;

    const std::string & year;

    MapProductNode & mapProductNode;

    ArcsIndex & arcsIndex;

    MakeSuggestions(AutoConnection & _conn,
                    Graph & _g, Graph::Node * _tgt, SuggestionBuffer & _buffer,
                    const std::string & _year, MapProductNode & _mapProductNode,
                    ArcsIndex & _arcsIndex)
        : conn(_conn), g(_g), tgt(_tgt), buffer(_buffer), year(_year),
          mapProductNode(_mapProductNode), arcsIndex(_arcsIndex) {

        // Empty
    }

    void operator () (const long & id, ArcsGroup & group) {

        if (group.neededQuantity <= 0)
            return;

        SuggestionList * ptrSuggestions = buffer.search(group.tariffCode);

        if (ptrSuggestions == NULL) {

            ptrSuggestions = buffer.insert(group.tariffCode, SuggestionList());

            listSuggestedSuppliers(conn, group.tariffCode, year,
                                   *ptrSuggestions);
        }

        if (ptrSuggestions->is_empty())
            return;

        List <long> ids;

        listRealProductId(conn, id, year, ids);

        for (SuggestionList::Iterator it(*ptrSuggestions); it.has_current(); ){

            ProductInfo & productInfo = it.get_current();

            it.next();

            if (not eval(productInfo.productId, ids))
                continue;

            real totalCapacity =
                100 * productInfo.totalQuantity / productInfo.usedCapacity;

            real available = totalCapacity - productInfo.totalQuantity;

            if (available <= 0.0)
                continue;

            real mayIncrease =
                available * productInfo.unitarianPrice / group.price;

            real howManyIncrease = std::min(mayIncrease, group.neededQuantity);

            Graph::Node * src = NULL;

            Graph::Node ** ptrSrc =
                mapProductNode.search(productInfo.productId);

            if (ptrSrc == NULL) {

                std::unique_ptr <Product> product(new Product);

                product->setId(productInfo.productId);
                product->setName(productInfo.name);
                product->setTechnicalSpecifications(
                    productInfo.technicalSpecifications);
                product->setTariffCode(productInfo.tariffCode);
                product->setTrademark(productInfo.trademark);
                product->setMeasurementUnit(productInfo.measurementUnit);
                product->setUnitarianPrice(productInfo.unitarianPrice);
                product->setUsedCapacity(productInfo.usedCapacity);
                product->setQuantity(productInfo.quantity);
                product->setTotalQuantity(productInfo.totalQuantity);

                Company company;
                company.setRif(productInfo.companyRif);
                company.setName(productInfo.companyName);
                company.setNationality(productInfo.nationality);
                company.setOrigCountry(productInfo.origCountry);
                company.setProcCountry(productInfo.procCountry);

                Plant plant;
                plant.setId(productInfo.plantId);
                plant.setName(productInfo.plantName);
                plant.setOwnerCompany(g.searchOrInsert(company));

                product->setProducerPlant(g.searchOrInsert(plant));

                std::shared_ptr <Good> good(product.release());

                src = g.insertNode(good);

                assert(tgt->levels.size() > 0);

                src->type = SUGGESTED;
                src->id = g.get_num_nodes() - 1;

                mapProductNode.insert(productInfo.productId, src);

            } else
                src = *ptrSrc;

            assert(src != NULL);

            real nodeQuantity = howManyIncrease * group.price /
                                  productInfo.unitarianPrice;

            productInfo.totalQuantity += nodeQuantity;
            productInfo.quantity += nodeQuantity;

            group.neededQuantity -= howManyIncrease;

            productInfo.usedCapacity =
                100 * productInfo.totalQuantity / totalCapacity;


            src->newValue1 = productInfo.totalQuantity;
            src->newValue2 = productInfo.quantity;
            src->newValue3 = productInfo.usedCapacity;

            tgt->levels.for_each(IOManager::SetLevelsUpstream(src));

            Graph::Arc * arc = arcsIndex.search(src, tgt);

            if (arc == NULL) {

                ArcInfo arcInfo;

                arcInfo.inputId = id;
                arcInfo.totalQuantity = howManyIncrease;
                arcInfo.quantity = howManyIncrease;
                arcInfo.usedQuantity = howManyIncrease;

                arc = arcsIndex.insert_in_graph(src, tgt, arcInfo);


                arc->get_info().newValue1 = arcInfo.totalQuantity;
                arc->get_info().newValue2 = arcInfo.quantity;
                arc->get_info().newValue3 = arcInfo.usedQuantity;

            } else {

                arc->get_info().newValue1 += howManyIncrease;
                arc->get_info().newValue2 += howManyIncrease;
                arc->get_info().newValue3 += howManyIncrease;

            }


            if (productInfo.usedCapacity >= 100.0)
                ptrSuggestions->remove(productInfo);

            if (group.neededQuantity <= 0.0)
                return;
        }
    }
};

struct SuggestImport {

    AutoConnection & conn;

    Graph & g;

    Graph::Node * tgt;

    MapImports & map;

    SuggestImport(AutoConnection & _conn,
                  Graph & _g, Graph::Node * _tgt, MapImports & _map)
        : conn(_conn), g(_g), tgt(_tgt), map(_map) {

        // Empty
    }

    void operator () (const long & id, ArcsGroup & group) {

        if (group.neededQuantity <= 0)
            return;

        Graph::Node ** ptrSrc = map.search(id);

        if (ptrSrc == NULL) {

            std::unique_ptr <Input> input(new Input);

            input->setQuantity(group.neededQuantity);
            input->setName(getInputName(conn, id));

            Company company;

            company.setNationality("E");

            input->setProviderCompany(g.searchOrInsert(company));

            std::shared_ptr <Good> good(input.release());

            Graph::Node * src = g.insertNode(good);

            src->type = IMPORT;

            src->newValue2 = good->getQuantity();

            assert(tgt->levels.size() > 0);

            tgt->levels.for_each(IOManager::SetLevelsUpstream(src));
            src->get_info()->setMeasurementUnit(
                tgt->get_info()->getMeasurementUnit());

            ArcInfo arcInfo;
            arcInfo.inputId = id;
            arcInfo.totalQuantity = group.neededQuantity;
            arcInfo.quantity = group.neededQuantity;
            arcInfo.usedQuantity = group.neededQuantity;

            g.insert_arc(src, tgt, arcInfo);
            map.insert(id, src);

       } else {

            Graph::Node * src = *ptrSrc;

            Graph::Node_Arc_Iterator it(src);

            assert(it.has_current());

            Graph::Arc * a = it.get_current();

            src->get_info()->setQuantity(
                src->get_info()->getQuantity() + group.neededQuantity);

            src->newValue2 = src->get_info()->getQuantity();

            ArcInfo & arcInfo = a->get_info();

            arcInfo.totalQuantity += group.neededQuantity;
            arcInfo.quantity += group.neededQuantity;
            arcInfo.usedQuantity += group.neededQuantity;

        }
    }
};

void increaseProduction(Graph & g, Graph::Node * start, const real & value,
                        const std::string & year, SuggestionBuffer & buffer,
                        MapNodesQuantity & increasedNodes,
                        MapProductNode & mapProductNode,
                        MapImports & mapImports, ArcsIndex & arcsIndex) {

    real totalCapacity = 100.0 * start->newValue1 / start->newValue3;

    real toIncrease = start->newValue2 * value / 100.0;

    increasedNodes.insert(start, toIncrease);

    start->newValue1 += toIncrease;
    start->newValue2 += toIncrease;

    if (start->newValue1 > totalCapacity)
        start->newValue3 = 100.0;
    else
        start->newValue3 = 100.0 * start->newValue1 / totalCapacity;

    DynListQueue <Graph::Node *> queue;

    queue.put(start);

    AutoConnection conn;

    while (not queue.is_empty()) {

        Graph::Node * p = queue.get();

        MapGroupArcs mapGroupArcs;

        groupInputs(g, p, mapGroupArcs);

        mapGroupArcs.for_each<IncreaseUsageInArcs>();

        mapGroupArcs.for_each(IncreaseProductionInSuppliers(g));

        mapGroupArcs.for_each(UseNewProductionInSuppliers(g, increasedNodes));

        mapGroupArcs.for_each(IncreaseInactiveCapacity(g));

        mapGroupArcs.for_each(PutSuppliersInQueue(g, queue));

        mapGroupArcs.for_each(MakeSuggestions(conn, g, p, buffer, year,
                                              mapProductNode, arcsIndex));

        mapGroupArcs.for_each(SuggestImport(conn, g, p, mapImports));

    }
}


/** Agrega un campo nuevo a cada nodo y arco del grafo tipo real para
 * almacenar información adicional en el cálculo de variación de precios
 *
 * @param[in-out] g Grafo a estudiar
 */
void prepareGraphForCosts(Graph & g) {

    for(Graph::Node_Iterator it(g); it.has_curr() ; it.next()) {

        Graph::Node * node = it.get_curr();

        node->newValue1 = node->get_info()->getUnitarianPrice();

        node->newValue2 = 0;  //para calcular el Indice de precios

    }

    for(Graph::Arc_Iterator it(g); it.has_curr() ; it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * tgt = g.get_tgt_node(arc);

        arc->get_info().newValue1 = arc->get_info().price;

        // Para calcular la Proporcion del gastos en insumo
        arc->get_info().newValue2 =
         (arc->get_info().price / tgt->get_info()->getUnitarianPrice()) * 100;

        arc->get_info().newValue3 = 0;  //Acumula el indicador de dependencia

    }
}


/** Calcula el indicador Indices de precios Laspeyres
 *
 * @param[in-out] g Grafo a estudiar, Nodo de la cadena
 */

void Laspeyres(Graph & g, Graph::Node * node){

    double numerator   = 0;

    double denominator = 0;

    for(Graph::Node_Arc_Iterator it(node); it.has_curr(); it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * src = g.get_src_node(arc);

        if (src == node)
            continue;

        numerator += arc->get_info().newValue1 * arc->get_info().reqQuantity;

        denominator += arc->get_info().price * arc->get_info().reqQuantity;
    }

    node->newValue2 = (numerator / denominator) * 100;

    node->newValue2 = node->newValue2 == 0 ? 0 : node->newValue2 - 100;

}



/** Calcula el indicador Indices de dependencia
 *
 * @param[in-out] g Grafo a estudiar, Nodo de la cadena
 */


void dependency_indicator(Graph & g, Graph::Node * node){

    double acumulator = 0;

    for(Graph::Node_Arc_Iterator it(node); it.has_curr(); it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * src = g.get_src_node(arc);

        if (src == node)
            continue;

        acumulator += arc->get_info().newValue1* arc->get_info().quantity;

    }

    for(Graph::Node_Arc_Iterator it(node); it.has_curr(); it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * src = g.get_src_node(arc);

        if (src == node)
            continue;

        real prop =  (arc->get_info().newValue1 * arc->get_info().quantity /
                      acumulator) * 100;

        dependency_indicator(g, src);

        if (COMPANY(src->get_info().get())->getNationality() != "E")
            node->newValue3 += (src->newValue3 / 100) * prop;
        else 
            node->newValue3 += prop;
    }
}

void alterPriceInArcs(Graph & g, Graph::Node * node,
                      DynListQueue<Graph::Node *> & nodeQueue, 
                      const real & factor) {

    for(Graph::Node_Arc_Iterator it(node); it.has_curr(); it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * tgt = g.get_tgt_node(arc);

        if(tgt == node)
            continue;

        arc->get_info().newValue1 *= factor;

        if (not tgt->isInQueue) {

            tgt->isInQueue = true;

            nodeQueue.put(tgt);
        }
    }
}

struct GroupPrice {

    real reqQuantity;

    real sumQuantity;

    real sumQuantityOldPrice;

    real sumQuantityNewPrice;

    List <Graph::Arc *> arcs;

    GroupPrice()
        : reqQuantity(0.0), sumQuantity(0.0), sumQuantityOldPrice(0.0),
          sumQuantityNewPrice(0.0) {
        // Empty
    }
};

typedef Map <long, GroupPrice> MapGroupPrice;

struct ProportionPrice {

    const real & newUnitarianCost;

    ProportionPrice(const real & _newUnitarianCost)
        : newUnitarianCost(_newUnitarianCost) {

        // Empty
    }

    void operator () (const long &, const GroupPrice & group) {

        real proportion = (((group.sumQuantityNewPrice / group.sumQuantity) *
                             group.reqQuantity) / newUnitarianCost) * 100;

        for (List <Graph::Arc *>::Iterator it(group.arcs); it.has_curr();
             it.next()) {

            Graph::Arc * a = it.get_curr();

            real prop = (a->get_info().quantity / group.sumQuantity) *
                         proportion;

            it.get_current()->get_info().newValue2 = prop;
        }
    }

};

struct UnitarianCostSetter {

    real & oldUnitarianCost;

    real & newUnitarianCost;

    UnitarianCostSetter(real & _oldUnitarianCost, real & _newUnitarianCost)
        : oldUnitarianCost(_oldUnitarianCost),
          newUnitarianCost(_newUnitarianCost) {

        // Empty
    }

    void operator () (const long &, const GroupPrice & group) {

         oldUnitarianCost += (group.sumQuantityOldPrice / group.sumQuantity) *
                             group.reqQuantity;

         newUnitarianCost += (group.sumQuantityNewPrice / group.sumQuantity) *
                             group.reqQuantity;

    }

};

void alterPriceInNode(Graph & g, Graph::Node * node) {

    MapGroupPrice map;

    for(Graph::Node_Arc_Iterator it(node); it.has_curr(); it.next()) {

        Graph::Arc * arc = it.get_curr();

        Graph::Node * src = g.get_src_node(arc);

        if(src == node)
            continue;

        const long & inputId = arc->get_info().inputId;

        GroupPrice * ptrGroupPrice = map.search(inputId);

        if (ptrGroupPrice == NULL) {

            ptrGroupPrice = map.insert(inputId, GroupPrice());

            ptrGroupPrice->reqQuantity = arc->get_info().reqQuantity;
        }

        assert(ptrGroupPrice != NULL);

        const real & quantity = arc->get_info().quantity;

        ptrGroupPrice->sumQuantity += quantity;

        ptrGroupPrice->sumQuantityOldPrice += quantity *
                                              arc->get_info().price;

        ptrGroupPrice->sumQuantityNewPrice += quantity *
                                              arc->get_info().newValue1;

        ptrGroupPrice->arcs.append(arc);

    }

    real oldUnitarianCost = 0;

    real newUnitarianCost = 0;

    map.for_each(UnitarianCostSetter(oldUnitarianCost, newUnitarianCost));

    map.for_each(ProportionPrice(newUnitarianCost));

    real otherCosts = node->get_info()->getUnitarianPrice() - oldUnitarianCost;

    node->newValue1 = newUnitarianCost + otherCosts;
}

struct AlterPriceInfo {

    Graph::Node * node;

    real value;

    AlterPriceInfo()
        : node(NULL), value(0.0) {
        // Empty
    }

    AlterPriceInfo(Graph::Node * _node, const real & _value)
        : node(_node), value(_value) {

        // Empty
    }
};

typedef List <AlterPriceInfo> AlterPriceList;

void alterPrice(Graph & g, AlterPriceList & list) {

    DynListQueue<Graph::Node *> nodeQueue;

    for (AlterPriceList::Iterator it(list); it.has_current(); it.next()) {

        AlterPriceInfo & info = it.get_current();

        real factor = 1 + info.value / 100;

        info.node->newValue1 *= factor;

        alterPriceInArcs(g, info.node, nodeQueue, factor);
    }

    while (not nodeQueue.is_empty()) {

        Graph::Node * node = nodeQueue.get();

        node->isInQueue = false;

        alterPriceInNode(g, node);

        real factor = node->newValue1 /
                          node->get_info()->getUnitarianPrice();

        alterPriceInArcs(g, node, nodeQueue, factor);

        Laspeyres(g, node);
    }
}


void groupAlterListByLevels(AlterList & list,
                            Map <size_t, Graph::Node *> & mapNumNodes,
                            Array <AlterPriceList> & array) {

    AlterList::Iterator it(list);

    AlterInfo & alterInfo = it.get_current();

    Graph::Node * node = mapNumNodes.find(alterInfo.numNode);

    long minLevel = node->levels.min();

    for ( /* nothing */; it.has_current(); it.next()) {

        AlterInfo & alterInfo = it.get_current();

        Graph::Node * node = mapNumNodes.find(alterInfo.numNode);

        long level = node->levels.min();

        if (level < minLevel)
            minLevel = level;
    }

    it.reset_first();

    for ( /* nothing */; it.has_current(); it.next()) {

        AlterInfo & alterInfo = it.get_current();

        Graph::Node * node = mapNumNodes.find(alterInfo.numNode);

        long level = node->levels.min();

        array.touch(level - minLevel).
            append(AlterPriceInfo(node, alterInfo.value));
    }
}

int main(int argc, char const * argv[]) {

    if (argc < 4) {
        std::cout << "usage: ./ecosim_simulator xmlInputFileName"
                  << " xmlOutputFileName"
                  << "  [db_server_info_file_name]\n";
        return 1;
    }

    std::string xmlInputFileName = argv[1];

    std::string xmlOutputFileName = argv[2];

    std::string dbFileName = argc > 3 ? argv[3] : "dbserver";

    DBProperties::getInstance().readFile(dbFileName);

    IOManager ioManager;

    Graph graph;

    try {

        std::string year = ioManager.readXmlGraph(xmlInputFileName,
                                                  IOManager::GRAPH, graph);

        assert(graph.get_num_nodes() > 0);

        AlterList alterList;

        std::string option;

        ioManager.readAlterInfo(xmlInputFileName, option, alterList);

        if (alterList.size() == 0) {

            std::cout << "No hay elementos para simular\n";

            return 0;
        }

        Map <size_t, Graph::Node *> mapNumNodes;

        size_t i = 0;

        for (Graph::Node_Iterator it(graph); it.has_current(); it.next(), ++i)
             mapNumNodes.insert(i, it.get_current());

        if (option == IOManager::DECREASE) {

            prepareGraphForProduction(graph);

            for (AlterList::Iterator it(alterList); it.has_current();
                 it.next()) {

                AlterInfo & info = it.get_current();

                Graph::Node * node = mapNumNodes.find(info.numNode);

                decreaseProduction(graph, node, info.value);
            }

        } else if (option == IOManager::INCREASE) {

            prepareGraphForProduction(graph);

            SuggestionBuffer buffer;

            MapNodesQuantity increasedNodes;

            MapImports mapImports;

            MapProductNode mapProductNode;

            for (Graph::Node_Iterator it(graph); it.has_current(); it.next()) {

                Graph::Node * currentNode = it.get_current();

                Good * ptrGood = currentNode->get_info().get();

                if (ptrGood->getType() == PRODUCT_GOOD)
                    mapProductNode.insert(ptrGood->getId(), currentNode);
            }

            ArcsIndex arcsIndex(graph);

            for (AlterList::Iterator it(alterList); it.has_current();
                 it.next()) {

                AlterInfo & info = it.get_current();

                Graph::Node * node = mapNumNodes.find(info.numNode);

                increaseProduction(graph, node, info.value, year, buffer,
                                   increasedNodes, mapProductNode, mapImports,
                                   arcsIndex);

            }

        } else if (option == IOManager::COST) {

            prepareGraphForCosts(graph);

            Array <AlterPriceList> array;

            groupAlterListByLevels(alterList, mapNumNodes, array);

            for (size_t i = 0; i < array.size(); ++i)
                alterPrice(graph, array.access(i));

            for (Graph::Node_Iterator it(graph); it.has_current(); it.next()) {

                Graph::Node * currentNode = it.get_current();

                if (currentNode->type == ROOT){

                    dependency_indicator(graph,currentNode);

                }

            }
        }

        ioManager.addGraphToFile(graph, xmlInputFileName, xmlOutputFileName,
                                 IOManager::ALTER_GRAPH);

    } catch(const std::exception & e) {

        std::cout << "Excepción capturada: " << e.what() << std::endl;

        return 2;
    }

    return 0;
}