class DistributoreAutomatico {
  //////////////////////////////////////////////////////////////////////////
  // Attributi costanti
  //////////////////////////////////////////////////////////////////////////
  // Le bevande disponibili
  public static final int CHINOTTO   = 0;
  public static final int ARANCIATA  = 1;
  public static final int THE_FREDDO = 2;

  // Le monete inseribili
  public static final int CINQUE    = 5;
  public static final int DIECI     = 10;
  public static final int CINQUANTA = 50;

  // Il costo di una bevanda
  public static final int COSTO_BEVANDA = 55;

  // Segnalazione di errata chiave elettronica
  public static final int ERRORE = -1;

  //////////////////////////////////////////////////////////////////////////
  // Attributi variabili comuni a tutte le istanze
  //////////////////////////////////////////////////////////////////////////
  // La somma totale contenuta nelle casse
  // di tutti i distributori (euro e centesimi di euro)
  private static int introitoEuro = 0;
  private static int introitoCentesimi = 0;

  //////////////////////////////////////////////////////////////////////////
  // Attributi dell'oggetto distributore
  //////////////////////////////////////////////////////////////////////////
  // Le quantità disponibili per le varie bibite
  private int numeroChinotti;
  private int numeroAranciate;
  private int numeroThe;

  // Il credito utilizzabile dall'utente (in centesimi)
  private int creditoUtente;

  // La somma totale contenuta nel distributore (in centesimi)
  private int introitoDistributore;

  // Chiave elettronica di accesso al distributore (per la
  // ricarica delle bevande e l'interrogazione dell'introito)
  private int chiaveElettronica;

  //////////////////////////////////////////////////////////////////////////
  // Costruttori
  //////////////////////////////////////////////////////////////////////////
  // Questo costruttore consente di impostare una chiave elettronica
  // per l'autorizzazione alle operazioni di ricarica e interrogazione
  // del saldo del distributore
  public DistributoreAutomatico(int chiaveElettronica) {
    numeroChinotti = numeroAranciate = numeroThe = 0;
    creditoUtente = 0;
    introitoDistributore = 0;
    this.chiaveElettronica = chiaveElettronica;
  }

  //////////////////////////////////////////////////////////////////////////
  // Interfaccia per l'utente
  //////////////////////////////////////////////////////////////////////////
  // Metodo per inserire monete
  // Restituisce false se la moneta inserita non è accettata
  public boolean inserisciMonete(int moneta, int quantità) {
    switch (moneta) {
      case CINQUE :
      case DIECI :
      case CINQUANTA :
        creditoUtente += moneta * quantità;
        return true;
      default : return false;
    }
  }

  // Restituzione delle monete inserite: il credito viene azzerato
  public void restituisciMonete() {
    creditoUtente = 0;
  }

  // Metodo per ottenere una bevanda
  // Restituisce false se il credito non è sufficiente, se la
  // selezione della bevanda è errata, oppure se la bevanda
  // selezionata è esaurita; true altrimenti
  public boolean richiediBevanda(int bevanda) {
    if (creditoUtente < COSTO_BEVANDA) {
      // Le monete inserite non sono sufficienti a coprire il costo
      return false;
    } else {
      // Le monete inserite coprono il costo, quindi la
      // quantità della bevanda selezionata diminuisce di 1
      switch (bevanda) {
        case CHINOTTO :
          if (numeroChinotti > 0) {
            --numeroChinotti; break;
          } else {
            // I chinotti sono esauriti
            return false;
          }
        case ARANCIATA :
          if (numeroAranciate > 0) {
            --numeroAranciate; break;
          } else {
            // Le aranciate sono esaurite
            return false;
          }
        case THE_FREDDO :
          if (numeroThe > 0) {
            --numeroThe; break;
          } else {
            // I the sono esauriti
            return false;
          }
        default : return false;
      }
      // La bevanda è stata selezionata correttamente
      // quindi è necessario aggiornare il credito e l'introito
      creditoUtente -= COSTO_BEVANDA;
      aggiornaIncasso();
      return true;
    }
  }

  //////////////////////////////////////////////////////////////////////////
  // Interfaccia per la ditta di servizio (protetta con chiave di accesso)
  //////////////////////////////////////////////////////////////////////////
  // Metodo per ricaricare il distributore
  // Restituisce true se la ricarica è stata eseguita correttamente
  // e false nel caso in cui (i) la bevanda non sia stata specificata
  // correttamente o (ii) la chiaveElettronica non sia corretta
  public boolean ricarica(int chiaveElettronica, int bevanda, int quantità) {
    if (chiaveElettronica == this.chiaveElettronica) {
      switch (bevanda) {
        case CHINOTTO : numeroChinotti += quantità; return true;
        case ARANCIATA : numeroAranciate += quantità; return true;
        case THE_FREDDO : numeroThe += quantità; return true;
        default : return false;
      }
    } else {
      return false;
    }
  }

  // Metodo per interrogare l'incasso del distributore (in centesimi)
  // Restituisce ERRORE se la chiave elettronica inserita è scorretta
  public int richiediIntroito(int chiaveElettronica) {
    if (chiaveElettronica == this.chiaveElettronica) {
      return introitoDistributore;
    } else {
      return ERRORE;
    }
  }

  // Metodo per prelevare l'introito del distributore
  // Restituisce ERRORE se la chiave elettronica inserita è scorretta
  public int prelevaIntroito(int chiaveElettronica) {
    if (chiaveElettronica == this.chiaveElettronica) {
      int somma = introitoDistributore + creditoUtente;
      introitoDistributore = creditoUtente = 0;
      return somma;
    } else {
      return ERRORE;
    }
  }

  // Metodo per interrogare l'introito totale dei distributori
  // Per avere tale importo è sufficiente conoscere la chiave
  // elettronica di un solo distributore
  // Restituisce ERRORE se la chiave di accesso è scorretta
  public double richiediIntroitoTotale() {
    if (chiaveElettronica == this.chiaveElettronica) {
      return ((double)introitoEuro +
              (double)introitoCentesimi / (double)100);
    } else {
      return ERRORE;
    }
  }

  //////////////////////////////////////////////////////////////////////////
  // Metodi private
  //////////////////////////////////////////////////////////////////////////
  private void aggiornaIncasso() {
    // Aggiorna la cassa del distributore (in centesimi)
    introitoDistributore += COSTO_BEVANDA;
    // Aggiorna l'introito complessivo dei distributori
    introitoCentesimi += COSTO_BEVANDA;
    if (introitoCentesimi > 100) {
      introitoCentesimi -= 100;
      ++introitoEuro;
    }
  }

}