#ifndef BeursHVar  // voorkom dat dit bestand meerdere keren
#define BeursHVar  // ge-include wordt

#include <vector>
#include "constantes.h"
#include "dag.h"

using namespace std;

class Beurs
{ public:

    // Default constructor
    Beurs ();

    // Lees de invoerparameters en -waardes in uit tekstbestand invoernaam.
    // Het formaat van het bestand is als volgt:
    // * een regel met twee integers tw en n: respectievelijk het aantal dagen
    //   waarna je de balans opmaakt, en het aantal bedrijven
    // * een regel met een double p:  het provisiepercentage
    // * een regel met een double b0: het geldbedrag waarmee je start
    // * (tw+1) regels met elk n doubles: voor elke dag een regel met
    //   de koersen van de aandelen van de n bedrijven
    // * tw regels met een double: voor elke dag (TOT de laatste) het dan
    //   geldende rentepercentage.
    //
    // Retourneer:
    // * true als het lukt om het tekstbestand te openen, en de eerste
    //   twee getallen binnen de grenzen van de opdracht liggen
    // * false als het niet lukt om het tekstbestand te openen, of de eerste
    //   twee getallen niet beide binnen de grenzen van de opdracht liggen.
    // Pre:
    // * als het lukt om het tekstbestand te openen, en de eerste twee
    //   getallen binnen de grenzen van de opdracht liggen, liggen alle andere
    //   getallen in het bestand ook binnen de grenzen van de opdracht
    // Post:
    // * Als de returnwaarde true is, zijn alle ingelezen getallen
    //   opgeslagen in membervariabelen.
    bool leesIn (const char* invoernaam);

    // Druk, ter controle, de complete invoer af op het scherm.
    void drukAfInvoer ();

    // Bepaal met behulp van bottom-up dynamisch programmeren het maximale
    // bedrag dat de belegger aan het eind van dag tw in kas kan hebben
    // (op dat moment heeft hij geen aandelen meer).
    // De tabel met bedragen wordt iteratief ingevuld.
    // Pre:
    // * Er is een geldige instantie ingelezen.
    // Post:
    // * Parameter transacties bevat de transacties die nodig zijn om tot
    //   het maximale bedrag te komen.
    //   In het bijzonder: transacties[t] is een vector met de transacties
    //   die nodig zijn op dag t (de size van transacties is dus tw+1). Elke
    //   transactie is een pair bestaande uit een boolean en een integer i.
    //   De boolean is true als aandeel i gekocht moet worden, en false als
    //   aandeel i verkocht moet worden.
    // Retourneer:
    // * Het maximale bedrag op dag tw.
    double bepaalMaxBedragBU
             (vector <vector <pair <bool,int> > > &transacties);

    // Bepaal recursief het maximale bedrag dat de belegger aan het eind
    // van dag tw in kas kan hebben (op dat moment heeft hij geen aandelen
    // meer). Als parameter memo = true worden berekende deelresultaten
    // opgeslagen in tabel bedrag en hergebruikt. Als memo = false, worden
    // deelresultaten steeds opnieuw berekend.
    // De benodigde transacties om het maximale bedrag te behalen, hoeven
    // niet bepaald te worden.
    // Pre:
    // * Er is een geldige instantie ingelezen.
    // Retourneer:
    // * Het maximale bedrag op dag tw.
    double bepaalMaxBedragRec (bool memo);

    // Druk de transacties in parameter transacties (koop en verkoop
    // van aandelen) dag voor dag af op het scherm.
    // Bereken ook, uitgaande van startbedrag b0, het resulterende
    // eindbedrag, en druk dat af op het scherm.
    // Voor de betekenis van parameter transacties, zie functie
    // bepaalMaxBedragBU.
    // Nuttig als controle voor het antwoord van dynamisch programmeren.
    // Pre:
    // * Er is een geldige instantie ingelezen.
    // * De transacties in parameter transacties zijn geldige transacties
    //   bij deze instantie.
    void drukAfTransacties (vector <vector <pair <bool,int> > > transacties);

    private:
        int tw,            // Tijdstip_wereldreis
            n,             // Het aantal verschillende aandelen
            aantalDagen;   // Het aantal dagen vanaf dag 0 tot en met tw
        double provisie,   // Provisie op transacties, in procenten.
               b0;         // Bedrag op tijdstip 0
        vector<Dag> dagen; // Vector met alle dag objecten

        // Reset de waardes van de opzet voor een beurs
        void resetBeursOpzet();

        // Haalt alle waardes uit transacties en vult transacties
        // met zoveel vectoren als het aantal dagen.
        void transactiesResetten(vector<vector<pair <bool, int>>> &transacties) const;

        // Retourneert bedrag dat erbij komt door rente
        double rente(double const bedrag, int const dag) const;

        // Retourneert bedrag dat je krijgt bij verkopen
        double verkopen(int const aandeel, int const dag) const;

        // Retourneert bedrag dat eraf gaat bij kopen
        double kopen(int const aandeel, int const dag) const;

        // Retourneert of het aandeel in de bitstring met combinatie van aandelen zit
        bool aandeelInCombinatie(int const aandeel, int combinatieAandelen) const;

        // Berekent het eindbedrag dat de gebruiker op dag tw zal hebben
        // na het uitvoeren van de transacties uit de vector en de rentes van elke dag
        double berekenEindbedrag(vector<vector<pair<bool, int>>> const transacties) const;

        // Hulp functie voor het berekenen van het bedrag met 
        // een gegeven vorigeCombinatie naar een huidige combinatie.
        // Als rente true is wordt de rente op vorigeBedrag eerst nog berekend
        double berekenBedrag(double vorigeBedrag, int const vorigeCombinatie,
                            int const nieuweCombinatie, int const dag) const;

        // Voegt de transacties van de dag van combinatie toe aan de vector met transacties
        void addTransacties(int combinatie, int combinatieVorige,
                            vector<vector<pair<bool,int>>> &transacties, int const dag);

        // Berekent recursief het maximale bedrag waarbij deelresultaten worden
        // opgeslagen in bedrag
        double berekenRecBedragMemo(pair<bool, double> bedrag[MaxAs][MaxTw],
                            int const dag, int const laatsteDag) const;

        // Berekent recursief het maximale bedrag zonder deelresultaten op te slaan
        double berekenRecBedrag(int const dag, int const laatsteDag, int const combinatie) const;

        // Vult de waardes in, in de bedragentabel op de juiste dag en
        // bij de juiste aandelencombinatie
        void setBedrag(pair<bool, double> bedrag[MaxAs][MaxTw], double const nieuwBedrag,
                            int const dag, int const aandeelCombinatie) const;

        // Haalt de waardes uit de dubbele array op de juiste dag en bij de
        // juiste aandelencombinatie
        void resetBedrag(pair<bool, double> bedrag[MaxAs][MaxTw], int const dag,
                            int const aandeelCombinatie) const;

        // Kijkt of tempbedrag groter is dan maxBedrag en verandert, als nodig, maxBedrag
        void nieuwMaxBedrag(double const tempBedrag, double &maxBedrag) const;

};

#endif