package pbxlogique;
//Nom: Paul M. Baillot
//N° étudiant 2273596
//Nom du projet: Devoir 1, Question 1
//Classe: CSI1501
//Groupe : Lundi
//T.A. : Olivier

public class Time1 {

    // constantes: varialbes de classe (final)

    static public final int HOURS_PER_DAY      = 24;
    static public final int MINUTES_PER_HOUR   = 60;
    static public final int SECONDS_PER_MINUTE = 60;
    //***AJOUT MANUEL***
    static private final boolean DEBUG = false;

    // variables d'instance

    private int hours ;    // intervalle de valeurs 0 à 23 (inclusivement)
    private int minutes ;  // intervalle de valeurs 0 à 59 (inclusivement)
    private int seconds ;  // intervalle de valeurs 0 à 59 (inclusivement)

    // constructeur

    public Time1(int hours, int minutes, int seconds) {
    /*La modification du constructeur pour ne PAS accepté les temps négatifs
    va faire de sorte que la différence du temps pourra facilement être
    calculer sans complications majeures! */
    //DÉBUTS DES MODIFICATIONS
    if (seconds<0) seconds=0;
    if (minutes<0) minutes=0;
    if (hours<0) hours=0;
    //FIN DES MODIFICATIONS
        this.seconds = seconds % SECONDS_PER_MINUTE ;

        int m = (seconds / SECONDS_PER_MINUTE) + minutes ;
        this.minutes = m % MINUTES_PER_HOUR ;

        this.hours = ((m / MINUTES_PER_HOUR) + hours) % HOURS_PER_DAY ;
    }

    // méthodes d'accès

    public int getHours() {
	return hours ;
    }

    public int getMinutes() {
	return minutes ;
    }

    public int getSeconds() {
	return seconds ;
    }

    // méthodes standards

    public String toString() {
	return hours+":"+minutes+":"+seconds ;
    }

    public boolean equals(Time1 t) {
	return  (  (hours   == t.getHours())
		   && (minutes == t.getMinutes())
		   && (seconds == t.getSeconds()) ) ;
    }

    // autres méthodes

    public void increase() {
	seconds++ ;
	int carry = seconds / SECONDS_PER_MINUTE ;
	seconds = seconds % SECONDS_PER_MINUTE ;
	minutes = minutes + carry ;
	carry = minutes / MINUTES_PER_HOUR ;
	minutes = minutes % MINUTES_PER_HOUR ;
	hours = (hours + carry) % HOURS_PER_DAY ;
    }

    // nouvelles méthodes
    // INSÉREZ VOS MÉTHODES POUR LA QUESTION #1 ICI

    private int toSeconds(Time1 t)
    //Converti un "Time1" en secondes
    {
    return (t.getSeconds() + t.getMinutes()*(SECONDS_PER_MINUTE) + t.getHours()*(SECONDS_PER_MINUTE*MINUTES_PER_HOUR));
    }//END FUNCTION

    private Time1 toTime1(int second)
    {
    if (second<0) second*=-1; //Fait sur que le temps est positif.
    //Le temps négatif est accepté à ce point ci, car ceci est une fonction
    //interne.  La variable Time1 elle-meme ne peut contenir un temps négatif.
    int tHour=0, tMinute=0;
    tHour = second / (SECONDS_PER_MINUTE * MINUTES_PER_HOUR);
    second -= tHour * (SECONDS_PER_MINUTE * MINUTES_PER_HOUR);
    tMinute = second / (SECONDS_PER_MINUTE);
    second -= tMinute * (SECONDS_PER_MINUTE);
    return new Time1(tHour, tMinute, second);
    }

    public Time1 difference(Time1 t)
    //Retourne la différence (absolue) entre 'CE' temps et "t"
    {
    return toTime1(toSeconds(this)-toSeconds(t));
    }

    public boolean plusTot(Time1 t)
    {
    //Vérifie si la variable "t" est plus petit que 'cette' variable;
    if (this.toSeconds(t)<this.toSeconds(this))
      {
      return true;
      }else
      {
      return false;
      }//END IF
    }//END FUNCTION

    public boolean plusTard(Time1 t)
    /*Utilise exactement le meme code que dans la fonction "plusTot",
    mais retourne les valeurs contraire de façons à retourner VRAI si le
    temps dans la variable "t" est plus haut que le temps de "cette" instance.
    */
    {
    if (this.toSeconds(t)<this.toSeconds(this))
      {
      return false;
      }else
      {
      return true;
      }//END IF
    }//END FUNCTION

    public boolean jeSuisEntre(Time1 heure_Debut, Time1 heure_Fin)
    /*Compare heure du début et l'heure de la fin à CETTE heure pour
    vérifier si CETTE heure est ENTRE ces deux heures:
    Si heure_Début = 0:0:0
    Si heure_Fin = 1:0:0
    Si CETTE heure est 0:0:0, cette fonction retourne false, met si CETTE heure
    est 0:0:01 alors la fonction retourne TRUE pour dire que CETTE heure
    se retrouve ENTRE
    */
    {
    if (toSeconds(this)>toSeconds(heure_Debut) && toSeconds(this)<toSeconds(heure_Fin))
      {
      return true;
      }
    return false;
    }
    //MAIN
    public static void main(String[] argv)
    {
    int gHour = Integer.parseInt(argv[0]); //Paramètre #1 (heure)
    int gMinute = Integer.parseInt(argv[1]); //Paramètre #2 (Minute)
    int gSecond = Integer.parseInt(argv[2]); //Paramètre #3 (Seconde)
    Time1 temps = new Time1 (gHour, gMinute, gSecond); //Conversion des paramètres en "Time1"
    Time1[] tCompare = new Time1[5]; //5 temps pré-définie
    int compteur; //Misc.
    tCompare[0] = new Time1(02,12,40); //Temps pré-définie
    tCompare[1] = new Time1(12,00,00);
    tCompare[2] = new Time1(13,11,43);
    tCompare[3] = new Time1(20,40,30);
    tCompare[4] = new Time1(20,41,30);
//////////////////////////////////////////////////////
    if (DEBUG) //OFF PAR DÉFAUT
      {
      Time1 test1 = new Time1(12,59,60);
      Time1 test2 = new Time1(00,00,01);
      Time1 test3 = new Time1(-1, 1, -10); //EST égal à 0:01:00 heures (VOIR les modifications au Constructeur)
      System.out.println(test1);
      System.out.println(test3);
      System.out.println(test2.difference(test1)); //DEVRAIT ÊTRE 12:59:59
      System.out.println(test2.plusTot(test1)); //DEVRAIT ÊTRE FALSE
      System.out.println(test2.plusTard(test1)); //DEVRAIT ÊTRE TRUE
      }//END IF
//////////////////////////////////////////////////////
    //Note pour moi-meme: Avec les fonctions PBXLogique, j'aurais pu faire sur
    //que les paramètres entré sont belle-et-bien des nombres

    System.out.println("Temps entré par l'utilisateur: "+gHour+":"+gMinute+":"+gSecond);
    System.out.println("Temps reconnue par se programme: "+temps.getHours()+":"+temps.getMinutes()+":"+temps.getSeconds());
    System.out.println("-------------");
    for (compteur=0; compteur<=4; compteur++)
      {
      if (temps.plusTard(tCompare[compteur])) //TRUE si "tCompare" est plus tard que "temps"
        {
        System.out.println(temps+" est avant "+tCompare[compteur]+" et la différence est "+temps.difference(tCompare[compteur]));
        }else
        {
        System.out.println(temps+" est après "+tCompare[compteur]+" et la différence est "+temps.difference(tCompare[compteur]));
        }//END IF
      }//END FOR
    System.out.println(new Time1(0,0,1).jeSuisEntre(new Time1(0,0,0), new Time1(2,0,0)));
    }//END MAIN
}
//Nom: Paul M. Baillot
//N° étudiant 2273596
//Nom du projet: Devoir 1, Question 1
//Classe: CSI1501
//Groupe : Lundi
//T.A. : Olivier