#ifndef AUTOMATON_H
#define AUTOMATON_H

#define FALSE 0
#define TRUE 1
#define EPSILON 0

typedef int bool;

/* Représente une transition depuis un état de l' automate */
typedef struct {
    int symbol;
    int destination;
} Arc;

/* Représente un état d'un automate */
typedef struct {
    int num_arcs;
    bool is_final;
    Arc* arcs;
} State;

/* Représente un automate */
typedef struct {
    int num_states;
    int initial_state;
    State* states;
} Automaton;


/********************************/
/* Fonctions liées à l'automate */
/********************************/
/* Alloue de la mémoire pour représenter un automate, initialise ses champs et retourne l'adresse de l'automate créé */
Automaton* create_automaton(void);

/* Libère la mémoire occupée par l'automate */
void destroy_automaton(Automaton* a);

/* Retourne le nombre d'états de l'automate a */
int get_num_states(Automaton *a);

/* Réalise l'affichage à l'écran de l'automate a */
void print_automaton(Automaton* a);

/* Rajoute les états et transitions de l'automate a2 dans l'automate a1 : sera utile pour les opérations concat et union (feuille TP2) */
void append_automaton(Automaton *a1, Automaton *a2);

/* Effectue une copie de l'automate a et retourne l'adresse de l'automate créé */
Automaton* copy_automaton(Automaton* a);


/****************************/
/* Fonctions liés aux états */
/****************************/
/* Ajoute un nouvel état à l'automate a et retourne le numéro de l'état créé */
int add_state(Automaton* a);

/* Retourne TRUE si l'automate a possède un état numéroté state. Retourne FALSE sinon */
bool has_state(Automaton* a, int state);

/* Fait de l'état state l'état initial de l'automate a */
void set_initial(Automaton *a, int state);

/* Retourne le numero de l'état initial */
int get_initial(Automaton *a);

/* Ajoute l'état state à l'ensemble des états d'acceptation de l'automate a */
void set_final(Automaton *a, int state);

/* Supprime l'état state de l'ensemble des états d'acceptation de l'automate a */
void unset_final(Automaton *a, int state);

/* Retourne TRUE si l'état state de l'automate a est un état d'acceptation */
bool is_final(Automaton *a, int state);

/* Retoune le nombre de transitions partant de l'état state */
int get_num_arcs(Automaton *a, int state);


/**********************************/
/* Fonctions liés aux transitions */
/**********************************/
/* Ajoute une transition étiquetée symbol entre l'état numéro from et l'état numéro to. La transition est ajoutée s'il
n'existe pas déjà une telle transition dans l'automate a.
Les états from et to doivent exister au préalable dans a, sans quoi, la transition n'est pas créée. */
void add_arc(Automaton* a, int from, int to, int symbol);

/* Retourne TRUE s'il existe une transition de l'état from à l'état to étiquetée
par le symbole symbol dans l'automate a. Retourne FALSE sinon. */
bool has_arc(Automaton* a, int from, int to, int symbol);

/* Supprime la transition étiquetée symbol entre l'état numéro from et l'état numéro to : sera utile pour supprimer les transitions epsilon (feuille TP3) */
void rm_arc(Automaton *a, int from, int to, int symbol);

/* Retourne le symbole associé à la transition arc_num partant de state dans l'automate a */
int get_symbol(Automaton *a, int state, int arc_num);

/* Retourne l'état de destination de la transition arc_num partant de state dans l'automate a */
int get_destination(Automaton *a, int state, int arc_num);

#endif /* AUTOMATON_H */