#include <iostream>
#include <vector>
#include <stdexcept>

using namespace std;

struct Asset {
    string name;
    string type;
    double quantity;
    double purchase_price;
    double current_price;
    double transaction_cost;
};

//  Initial Investment Formula
double InitialInvestment(double quantity, double purchase_price) {
    if (quantity <= 0 || purchase_price < 0) {
        throw runtime_error("Error the Quantity must be positive and purchase price cannot be negative.");
    }
    return quantity * purchase_price;
}

//  Current Value Formula
double CurrentValue(double quantity, double current_price) {
    if (quantity <= 0 || current_price < 0) {
        throw runtime_error("Error the quantity must be positive and current price cannot be negative.");
    }
    return quantity * current_price;
}

//  Net Gain or Loss Formula
double NetGainLoss(double current_value, double initial_investment, double transaction_cost) {
    if (transaction_cost < 0) {
        throw runtime_error(" Error, the transaction cost cannot be negative.");
    }
    return current_value - initial_investment - transaction_cost;
}

//  Net Return (percent) Formula
double NetReturn(double net_gain, double initial_investment) {
    if (initial_investment <= 0) {
        throw runtime_error("[Error] Cannot calculate return: initial investment must be greater than zero.");
    }
    return (net_gain / initial_investment) * 100.0;
}
//ici on definit une formule pour calculer montant total investit qui est en realite la somme 
//des investissement initiaux dans chaque actif
double TotalInvested( vector<Asset> portfolio) {
    double sum = 0.0;
    for (int i = 0; i < portfolio.size(); ++i) {
        sum += InitialInvestment(portfolio[i].quantity, portfolio[i].purchase_price);
    }
    return sum;
}


double CurrentPortfolioValue(vector<Asset> portfolio) {
    double sum = 0.0;
    for (int i = 0; i < portfolio.size(); ++i) {
        sum += CurrentValue(portfolio[i].quantity, portfolio[i].current_price);
    }
    return sum;
}
//ici pour calculer les cout totaux de transaction ,
//on additionne juste les cours de transaction pour tout es actifs.
double TotalCost(vector<Asset> portfolio) {
    double sum = 0.0;
    for (int i = 0; i < portfolio.size(); ++i) {
        sum += portfolio[i].transaction_coast;
    }
    return sum;
}
double NetPortfolioResult(vector<Asset> portfolio)
return CurrentValue(portfolio.quantity, portfolio.current_price)-TotalInvested(portfolio)-TotalCost(portfolio) ;

// pour calculer le rendement du porte feuille est le rapport entre la  fonction qui calcul le resultat
//net du porte feuille et la fonction qui qui calcule les couts totaux investis.
double PortfolioReturn(vector<Asset> portfolio)
return  (NetPortfolioResult(portfolio) /TotalInvested(portfolio) ) * 100.0;