#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <time.h>
#include <signal.h>
#include <sys/wait.h>
#include "table.h"
/** Version minimale de la fonction sauve qui peut.

    Appeler cette fonction n'a de sens qu'après un appel système qui a
    échoué (puisqu'elle appelle perror()).

    \param[in] msg Une chaîne de caractère passée à perror()
*/
void raler (const char * msg)
{
    perror (msg);
    exit (EXIT_FAILURE);
}
/** Une fonction que vous pouvez utiliser comme printf pour afficher
    une ligne précédée du numéro de processus et des minute/seconde.
*/
#ifdef __GNUC__
__attribute__ ((format (printf, 1, 2)))
#endif
void chronos_log (const char * fmt, ...)
{
    va_list ap;
    va_start (ap, fmt);
    time_t t = time (NULL);
    struct tm * tm = localtime (&t);
    fprintf (stderr, "[%d @ %02d:%02d] ",
             getpid(), tm->tm_min, tm->tm_sec);
    vfprintf (stderr, fmt, ap);
    fflush (stderr);
    va_end (ap);
}

volatile sig_atomic_t continuer=1;
volatile sig_atomic_t afficher=1;

volatile sig_atomic_t recu_usr2=0;
volatile sig_atomic_t recu_usr1=0;
volatile sig_atomic_t recu_term=0;
volatile sig_atomic_t recu_alarm=0;
//volatile sig_atomic_t recu_child=0;

void affiche (int sig)
{
    (void)sig;
    recu_usr2=1;
    return;
}

void active_affichage(int sig)
{
    (void) sig;
    return;
}

void stop (int sig)
{
    (void)sig;
    recu_term=1;
    return;

}
void alarme (int sig)
{
    (void)sig;
    recu_alarm=1;
    return;

}

/*void child (int sig)
{
    (void)sig;
    recu_child=1;
    return;

}*/


void chronos (char* table)
{
    FILE*fd;
    if((fd=fopen(table,"r")) == NULL)
        raler("Impossible d 'ouvrir le fichier");

    struct table * tbl=table_parse(fd);

    if(fclose(fd) == EOF)
        raler("Fermeture du fichier");

    struct sigaction s;
    s.sa_flags=0;
    s.sa_handler=affiche;
    sigemptyset(&s.sa_mask);
    sigset_t vide, masque;
    sigemptyset(&vide);
    sigemptyset(&masque);


    struct sigaction s1;
    s1.sa_flags=0;
    s1.sa_handler=active_affichage;
    sigemptyset(&s1.sa_mask);

    struct sigaction sterm;
    sterm.sa_flags=0;
    sterm.sa_handler=stop;
    sigemptyset(&sterm.sa_mask);

    struct sigaction salarm;
    sterm.sa_flags=0;
    sterm.sa_handler=alarme;
    sigemptyset(&salarm.sa_mask);

   /* struct sigaction schld;
    schld.sa_flags=0;
    schld.sa_handler=child;
    sigemptyset(&schld.sa_mask);*/

    sigaction(SIGUSR2,&s,NULL);
    sigaction(SIGUSR1,&s1,NULL);
    sigaction(SIGTERM,&sterm,NULL);
    sigaction(SIGALRM,&sterm,NULL);

    sigaddset(&masque,SIGUSR2);
    sigaddset(&masque,SIGUSR1);
    sigaddset(&masque,SIGTERM);
    sigaddset(&masque,SIGCHLD);
    sigaddset(&masque,SIGALRM);

    int pid,reason;

    chronos_log("HELLO\n");
    while (continuer){
        alarm(tbl->jobs->delay);
        /* Attente d'un signal, ou plusieurs */
        if( sigprocmask(SIG_BLOCK,&masque, NULL) == -1)
            raler("masquage");

       //chronos_log("J'attends un signal\n");
        sigsuspend(&vide);
        /* Traitement des signaux reçus */
        if( (recu_usr2 == 1) && (afficher == 1)){
            table_print(tbl,1);
            recu_usr2=0;
        }
        if(recu_usr1 == 1){

            if(afficher==0)
                afficher=1;
            else
                afficher=0;

            recu_usr1=0;
        }

        if(recu_term == 1){
            continuer=0;
            recu_term=0;
        }
        if(recu_alarm == 1){
            switch (pid=fork()){
            case -1:
                raler("fork");
                break;

            case 0:
                tbl->jobs->pid=getpid();
                chronos_log("INIT %s %d\n",tbl->jobs->id,tbl->jobs->pid);
                execvp(tbl->jobs->cmd[0],tbl->jobs->cmd);
                break;

            default:
                chronos_log("Je suis ton père\n");

                if((pid=waitpid(tbl->jobs->pid,&reason,WNOHANG)) == -1)
                    raler("waitpid");
                chronos_log("%d s'est arrêté\n",pid);
                if(pid == tbl->jobs->pid){
                    if(reason == 0){
                        chronos_log("FINI %s %d ok\n",tbl->jobs->id,tbl->jobs->pid);
                    } else {
                        chronos_log("FINI %s %d ko\n",tbl->jobs->id,tbl->jobs->pid);
                    }
                } else{
                    continue;
                }
                break;
            }
            recu_alarm=0;
        }
    }
    chronos_log("BYE\n");
    table_free (tbl);
return;
}

int main(int argc, char * argv [])
{

    if(argc!=2)
        raler("Usage : ./chronos <fichier.table>");

    chronos(argv[1]);

    return EXIT_SUCCESS;
}