// Hoofdprogramma voor oplossing voor programmeeropdracht 2 Algoritmiek,
// voorjaar 2026: Bergen Beklimmen
//
// Biedt de gebruiker een hoofdmenu, om
// * een instantie in te lezen uit een bestand
// * een instantie random te laten genereren
// * een experiment te doen
// In de eerste twee gevallen biedt het programma de gebruiker
// een `oplosmenu', om
// * de instantie rechtstreeks recursief op te lossen
// * de instantie met top-down DP op te lossen
// * de instantie met bottom-up DP op te lossen
// * de instantie gretig op te lossen
//
// Namen studenten:
// Datum:

#include <iostream>
#include <ctime>  // voor clock() en clock_t
#include "standaard.h"
#include "gebergte.h"
using namespace std;
const int MaxBestandsNaamLengte = 30; // maximale lengte van een bestandsnaam

//*************************************************************************

// Bied de gebruiker een menu met oplossingsmogelijkheden aan voor een
// gebergte, en vraag hem om een keuze te maken.
// Retourneer:
// * de gemaakte keuze
int vraagKeuzeOplosmenu ()
{ int keuze;

  do
  { cout << endl;
    cout << "1. De instantie rechtstreeks recursief oplossen" << endl;
    cout << "2. De instantie met top-down DP oplossen" << endl;
    cout << "3. De instantie met bottom-up DP oplossen" << endl;
    cout << "4. De instantie gretig oplossen" << endl;
    cout << "5. Stoppen met deze instantie" << endl;
    cout << endl;
    cout << "Maak een keuze: ";
    cin >> keuze;
  } while (!integerInBereik ("keuze", keuze, 1, 5));

  return keuze;

}  // vraagKeuzeOplosmenu

//*************************************************************************

// Verwerk om parameters waarmee een random instantie kan worden
// gegenereerd.
void vraagParameters (int &n, int &minP, int &maxP, int &minH, int &maxH)
{
  n = vraagInteger ("aantal bergen n", 1, MaxN);

  maxP = vraagInteger ("maximale prijs", MinPrijs, MaxPrijs);
  minP = vraagInteger ("minimale prijs", MinPrijs, maxP);

  maxH = vraagIntegerMinstens ("maximale hoogte", MinHoogte);
  minH = vraagInteger ("minimale hoogte", MinHoogte, maxH);

}  // vraagParameters

//*************************************************************************

// Druk de reis in parameter `reis' af op het scherm,
// met de bijbehorende kosten `kosten'.
void drukAfOplossing (int k, int kosten, vector<int> reis)
{ int grootte;   // grootte van vector reis

  cout << endl;
  cout << "De bijbehorende reis is:" << endl;
  grootte = reis.size ();
  for (int i=0;i<grootte;i++)
  { cout << reis[i];
    if (i<grootte-1)
      cout << ' ';
    else
      cout << endl;
  }
//  cout << "Dit zijn " << k << " bergen." << endl;
//  cout << "De kosten hiervan bedragen: " << kosten << endl;

} // drukAfOplossing

//*************************************************************************

// Bied de gebruiker een menu met oplossingsmogelijkheden aan voor gebergte
// geb1, en verwerk zijn keuze.
void oplosmenu (Gebergte *geb1)
{ int keuze,
      b,        // budget voor klimreis
      k,        // maximaal aantal bergen dat we kunnen beklimmen
      kosten;   // minimale kosten om k bergen te beklimmen
  vector<int> reis;
  clock_t t1, t2;

  geb1 -> drukAfInstantie ();

  do
  { keuze = vraagKeuzeOplosmenu ();  // is altijd in {1,2,3,4,5}

    if (integerInBereik (keuze, 1, 4))
    { b = vraagIntegerMinstens ("budget b", 1);

      t1 = clock ();
      switch (keuze)
      { case 1: geb1 -> losOpRec (b, k, kosten);
                break;
        case 2: geb1 -> losOpTD (b, k, kosten);
                break;
        case 3: geb1 -> losOpBU (b, k, kosten, reis);
                break;
        default:  // case 4
                geb1 -> losOpGretig (b, k, kosten, reis);
      }
      t2 = clock ();

      cout << endl;
      if (kosten!=0)
      { cout << "We kunnen " << k << " bergen beklimmen." << endl;
        cout << "De kosten bedragen " << kosten << endl;
      }
      else
        cout << "Er is geen oplossing mogelijk." << endl;

      if (keuze>=3 && k!=0)
        drukAfOplossing (k, kosten, reis);

      cout << endl;
      cout << "Deze berekening kostte " << (t2-t1) << " clock ticks, ofwel "
           << (((double)(t2-t1))/CLOCKS_PER_SEC) << " seconden." << endl;
    }  // if integerInBereik

  } while (keuze!=5);

}  // oplosmenu

//*************************************************************************

// Bied de gebruiker het hoofdmenu aan, en vraag hem om een keuze te maken.
// Retourneer:
// * de gemaakte keuze
int vraagKeuzeHoofdmenu ()
{ int keuze;

  do
  { cout << endl;
    cout << "1. Een instantie inlezen uit een bestand" << endl;
    cout << "2. Een random instantie genereren" << endl;
    cout << "3. Een experiment uitvoeren" << endl;
    cout << "4. Stoppen" << endl;
    cout << endl;
    cout << "Maak een keuze: ";
    cin >> keuze;
  } while (!integerInBereik ("keuze", keuze, 1, 4));

  return keuze;

}  // vraagKeuzeHoofdmenu

//*************************************************************************
  
// Doe het experiment zoals beschreven in de opdracht.
void doeExperiment ()
{

// TODO implementeer deze functie

}  // doeExperiment

//*************************************************************************

// Bied de gebruiker het hoofdmenu aan en verwerk zijn keuze.
void hoofdmenu ()
{ Gebergte *geb1;   // pointer, om makkeijk nieuwe objecten te kunnen maken
                    // en weer weg te gooien
  int keuze,
      n,            // aantal bergen
      minP, maxP,   // minimale/maximale prijs voor beklimmen berg
      minH, maxH;   // minimale/maximale hoogte van berg
  char invoernaam[MaxBestandsNaamLengte+1];

  do
  { keuze = vraagKeuzeHoofdmenu ();  // is altijd in {1,2,3,4}

    if (keuze<=2)
      geb1 = new Gebergte ();

    switch (keuze)
    { case 1: cout << endl;
              cout << "Geef de naam van het tekstbestand met de instantie: ";
              cin >> invoernaam;
              if (geb1 -> leesInBergen (invoernaam))
                oplosmenu (geb1);
              break;
      case 2: vraagParameters (n, minP, maxP, minH, maxH);
              geb1 -> genereerRandomInstantie (n, minP, maxP, minH, maxH);
              oplosmenu (geb1);
              break;
      case 3: doeExperiment ();
              break;
      default: ; // case 4
    }

    if (keuze<=2)
      delete geb1;

  } while (keuze!=4);

}  // hoofdmenu

//*************************************************************************
  
int main ()
{
  hoofdmenu ();

  return 0;

}