#include <iostream>
using namespace std;

//dichiarazione della struttura nodo
struct nodo{
  int inf;
  struct nodo *next;
};
int h=0;


//Funzione per la creazione della lista
void *crealista(nodo*& testa1){
  //dichiarazione del puntatore che verra' utilizzato per creare un nuovo nodo
  struct nodo *p;
  testa1=NULL;
  //inizializzazione variabile per le risposte
  char r;
  //ciclo nel quale vengono letti i velori della lista
  while(1) {
    //creazione del noto
    p= new nodo;
    //assegnazione di un valore al campo 'inf' del nodo
    std::cout << "Inserisci valore" << '\n';
    std::cin >> p->inf;
    //posizionamento dei puntatori
    p->next=testa1;
    testa1=p;
    //ciclo nel quale viene effettuato un controllo per aggiungere o no un altro elemento
    do {
      std::cout << "Vuoi aggiungere un altro elemento?" << '\n'<<"s/n\n";
      std::cin >> r;
      if (r!='s'&&r!='S'&&r!='n'&&r!='N') {
        std::cout << "Scelta non valida" << '\n';
      }
    } while(r!='s'&&r!='S'&&r!='n'&&r!='N');
    if (r=='n'||r=='N'){
            system("CLS");
      break;
    }
  }
}

//funzione per la stampa della lista
void *stampalista(nodo*& testa1){
  //dichiarazione puntatore che scorrera' la lista
  struct nodo *p;
  cout<<"\n";
  //assegnazione a p del valore di testa. Ora p puntera' al primo valore della lista
  p=testa1;
  std::cout << "Lista: ";
  //ciclo in cui si scorre la lista e si stampano gli elementi
  while(1){
    if (p->next==NULL) {
      cout << p->inf << ".\n";
      break;
    }
    else{
      cout << p->inf << ", ";
      p=p->next;
    }
  }
}

//funzioni per l'aggiunta di elementi
//funzione per l'aggiunta in testa
void *aggiungit(nodo*& testa1) {
  //dichiarazione puntatore
  struct nodo *p;
  //creazione del nuovo nodo
  p= new nodo;
  //assegnazione di un valore al campo 'inf' del nuovo nodo
  std::cout << "Inserisci il valore del nuovo elemento: " ;
  std::cin >> p->inf;
  //posizionamento in testa del nuovo nodo
  p->next=testa1;
  testa1=p;
}

//funzione per l'aggiunta in coda
void *aggiungic(nodo*& testa1){
  struct nodo *p,*q;
  //assegnazione del valore di testa a p
  p=testa1;
  //si scorre la lista fino ad arrivare al penultimo elemento
  while(p->next!=NULL){
      p=p->next;
    }
    //si crea il nuovo nodo
    q=new nodo;
    //si assegna un valore al campo 'inf' del nuovo nodo
    std::cout << "Inserisci il valore del nuovo elemento: ";
    std::cin >> q->inf;
    //si aggiunge il nuovo nodo in coda
    q->next=NULL;
    p->next=q;
}

//funzione per l'aggiunta al centro
void *aggiungin(nodo*& testa1) {
  struct nodo *p,*q;
  //inizializzazione variabili per confronti e conteggi
  int x,y,c,z;
  char scelta;
  //lettura del valore da aggiungere
  std::cout << "Inserisci il valore del nuovo elemento: ";
  std::cin >> x;
  //individuazione della posizione nella quale l'elemento va aggiunto
  do{
    std::cout << "Dopo quale valore della lista deve essere inserito?" << '\n';
    stampalista(testa1);
    std::cin >> y;
    //controllo sull'esistenza della posizione richiesta
    c=0;
    p=testa1;
    while(1){
      if (p->next==NULL) {
        if (p->inf==y) {
          c=c+1;
        }
        break;
      }
      else{
        if (p->inf==y) {
          c=c+1;
        }
        p=p->next;
      }
    }
    //in caso di presenza di piu' posizioni che rispettano le condizioni si procede in questo modo
    if (c>1){
      //viene scelto dove aggiungere
      std::cout << "Sono stati individuati " << c << " valori pari a "<<y<< ". Inserire "<<x<<"\n";
                    std::cout << "Dopo quale "<<y<<" deve essere inserito il numero?\n(1-"<<c<<")\n";
     std::cin >> z;
     p=testa1;
     c=0;
     while (1) {
     if (p->inf==y) {    /*  questi                                                                          */
     c++;             /*                                                                                  */
     if (c==z) {     /*controlli si occupano di stabilire qual'e' la posizione corretta per il nuovo nodo*/
            q=new nodo;
            q->inf=x;
            q->next=p->next;
            p->next=q;
       }
     }
     if (p->next==NULL) {
           break;
     }
     p=p->next;

       }
    }
     else{
      //se invece e' presente una sola posizione compatibile si procede alla creazione
      if (c==1) {
       p=testa1;
       while (1) {
           if (p->inf==y) {
             q=new nodo;
                q->inf=x;
                q->next=p->next;
               p->next=q;
            }
            if (p->next==NULL) {
             break;
           }
           p=p->next;
         }
    }
        //nel caso in cui non ci siano posizioni compatibili si restituisce un messaggio d'errore
        else{
          system("CLS");
         std::cout << "Il valore scelto non esiste." << '\n';
        }
    }
            }while(c==0);
    system("CLS");

}


//funzioni per l'eliminazione di elementi
//funzione per l'eliminazione in testa
void *eliminat(nodo*& testa1) {
  struct nodo *p;
  p=testa1;
  p=p->next;
  delete(testa1);
  testa1=p;
}
//funzione per l'eliminazione in coda
void *eliminac(nodo*& testa1) {
  //creazione dei puntatori che scorreranno la lista
  struct nodo *p,*q;
  p=testa1;
  q=p;
  //in questo ciclo i puntatori si muovono esattamente uno dietro l'altro, per non perdere l'indirizzo del penultimo elemento e assegnargli valore NULL
  while(p->next!=NULL){
      q=p;
      p=p->next;
    }
    q->next=NULL;
    delete(p);
  }
//funzione per l'eliminazione al centro
void *eliminan(nodo*& testa1) {
  struct nodo *p,*q;
  //variabili per il controllo degli elementi
  int y,c,z;
  char scelta;
  //scelta del valore da eliminare
  do{
  std::cout << "Quale valore della lista deve essere rimosso?" << '\n';
  stampalista(testa1);
  std::cin >> y;
  //si controlla che il valore da eliminare esista
  c=0;
  p=testa1;
  while(1){
    if (p->next==NULL) {
      if (p->inf==y) {
        c=c+1;
      }
      break;
    }
    else{
      if (p->inf==y) {
        c=c+1;
      }
      p=p->next;
    }
  }
  //per quanto riguarda la possibilita' di nessuna, una o piu' posizioni compatibili, si procede come nell'aggiunta al centro
  // in questi casi pero', i puntatori sono 2, uno dietro l'altro. il primo andrà a puntare il valore da eliminare, q servira' per puntare all'elemento successivo a p, mantenendo collegata la lista
  if (c>1){
    std::cout << "Sono stati individuati " << c << " valori pari a "<<y<< "\n";
      std::cout << "Quale "<<y<<" deve essere eliminato?\n(1-"<<c<<")\n";
      std::cin >> z;
      p=testa1;
      q=p;
      c=0;
      while (1) {
        if (p->inf==y) {
            c++;
            if (c==z) {
            q->next=p->next;
            delete(p);
            break;
          }
          }
        }
      q=p;
      p=p->next;

                                                }
  else{
    if (c==1) {
      p=testa1;
      q=p;
      while (1) {
          if (p->inf==y) {
            q->next=p->next;
            delete(p);
            break;
          }
          q=p;
          p=p->next;
      }
    }
    else{
      system("CLS");
      std::cout << "Il valore scelto non esiste." << '\n';
    }
  }
    }while(c==0);
    system("CLS");
}

//funzione per il calcolo delle occorrenze
void *occorrenze(nodo*& testa1){
        int k,c=0;
        struct nodo *p;
        cout<<"Inserisci l'elemento da cercare: ";
        cin>>k;
        p=testa1;
        while(1){
                cout<<p->inf;
                if(p->inf==k){
                    c++;
                }
                if(p->next==NULL){
                    break;
                }
                p=p->next;
        }
        system("CLS");
        cout<<"Il valore si ripete nella lista "<<c<<" volte\n";
}

void *max(nodo*& testa1){
            int max;
        struct nodo *p;
        p=testa1;
        max=p->inf;
        p=p->next;
        while(1){
                cout<<p->inf;
                if(p->inf>max){
                    max=p->inf;
                }
                if(p->next==NULL){
                    break;
                }
                p=p->next;
        }
        system("CLS");
        cout<<"Valore massimo della lista: "<<max;
}

void *min(nodo*& testa1){
            int min;
        struct nodo *p;
        p=testa1;
        min=p->inf;
        p=p->next;
        while(1){
                cout<<p->inf;
                if(p->inf<min){
                    min=p->inf;
                }
                if(p->next==NULL){
                    break;
                }
                p=p->next;
        }
        system("CLS");
        cout<<"Valore minimo della lista: "<<min;
}
//funzione principale
int  main() {
    //dichiarazione della testa della lista
    struct nodo *testa;
    if (h==0){
        cout<<"Questo programma si occupa di eseguire delle funzioni su una lista di interi. Le funzioni disponibili sono: inserimento di un elemento, eliminazione di un elemento, conteggio delle occorrenze, individuazione di valore massimo e minimo.\n\n";
    h++;
        }
        crealista(testa);
  while (1) {
    struct nodo *p;
    stampalista(testa);
    std::cout << "-Funzioni disponibili- \n";
    std::cout << "\nFunzioni di inserimento: \n1) Inserimento elemento in coda \n2) Inserimento elemento in testa \n3) Inserimento elemento al centro \n";
    std::cout << "\nFunzioni di eliminazione: \n4) Eliminazione elemento in coda \n5) Eliminazione elemento in testa \n6) Eliminazione elemento al centro \n";
    std::cout << "\n\nFunzioni di conteggio occorrenze e individuazione valore massimo e minimo:\n7) Calcolo occorrenze\n8) Individuazione massimo\n9) Idividuazione minimo\n";
                std::cout << "\n\nr) Leggi nuova lista \n";
    std::cout << "\n\nx) Chiudi \n";

    //controllo del numero di elementi nella lista, questo permetterà di evitare operazioni impossibili come l'eliminazione al centro, nel caso ci fosse solo un elemento nella lista
    int c=0;
    p=testa;
      while (1) {
        if (p->next==NULL) {
            c++;
            break;
        }
        else{
          c++;
          p=p->next;
        }
      }
                cout<<"Inserisci il simbolo della funzione da richiamare: ";
    char scelta;
    std::cin >> scelta;
    //scelta della funzione da richiamare con il controllo sulla possibilita' di essere eseguita.
    switch (scelta) {
      case ('1'):
          if (testa!=NULL) {
            aggiungic(testa);
            system("CLS");
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;
      case ('2'):
          if (testa!=NULL) {
            aggiungit(testa);
            system("CLS");
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;
      case ('3'):
      system("CLS");
          if (testa!=NULL) {
            aggiungin(testa);
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;
      case ('4'):
          if (c>1) {
            eliminac(testa);
            system("CLS");
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;

      case ('5'):
          if (c>1) {
            eliminat(testa);
            system("CLS");
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;

      case ('6'):
          if (c>2) {
            eliminan(testa);
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;

      case ('7'):
          if (c>=2) {
            occorrenze(testa);
          }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;

      case ('8'):
                    if (testa!=NULL){
                            max(testa);
                                        }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;

      case ('9'):
                    if (testa!=NULL){
                            min(testa);
                                        }
          else{
            system("CLS");
            std::cout << "Non e' possibile utilizzare questa funzione sulla lista corrente" << '\n';
          }
          break;
      case ('r'):
          return main();
      case ('x'):
          return 0;
      case ('R'):
          return main();
      case ('X'):
          return 0;
      default:
          std::cout << "Scelta non valida" << '\n';
    }
  }
}