#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lecture.h"
#include "utils.h"

int lecture(char *nom_fichier,
            cell * tabcell, cell_link * tablinks,
            struct cell_option_force_link *tab_option_force_link,
            unsigned char lire_seulement_tag,
            char *buffer_erreur, int maxlen_erreur)
{
    FILE *hinput;
    char s[250], u[251], v[251];
    char *t;
    int ret = 0;
    int len = 0;
    unsigned long i, j, ok;
    cell_link *links_debut = tablinks;

    struct cell_option_force_link *tab_force_link_tmp;
    unsigned char path_ou_wall;

    unsigned long tab_liens[50];
    unsigned long nb_tab_liens;

    unsigned long tab_liens_tag[50];
    unsigned long nb_tab_liens_tag;

    /* (!) tout est déjà préalloué => aucune allocation */
    tab_force_link_tmp = tab_option_force_link;
    hinput = fopen(nom_fichier, "rb");
    if (hinput == NULL) {
        snprintf(buffer_erreur, maxlen_erreur,
                 "Erreur d'ouverture du fichier <%s>.\n", nom_fichier);
        return -1;
    }

    while (fgets(s, sizeof(s), hinput) != NULL) {

        len = strlen(s);
        /* supprimer retour chariot : */
        while (len) {
            if (s[len - 1] >= ' ')
                break;
            s[len - 1] = 0;
            len--;
        }
        if (len == 0)
            continue;

        t = s;
        while (t[0]) {
            if ((t[0] != ' ') && (t[0] != 9))
                break;
            t++;
        }
        if (strlen(t) == 0)
            continue;
        if (t[0] == ';')
            continue;

        /* arrivé ici, chaine valide => analyse */
        ok = sscanf(t, "force_walls:%lu=%lu", &i, &j);
        if (ok == 2) {
            path_ou_wall = 1;
        } else {
            ok = sscanf(t, "force_paths:%lu=%lu", &i, &j);
            if (ok == 2) {
                path_ou_wall = 0;
            }
        }
        if (ok == 2) {
            tab_force_link_tmp->id_cell = i;
            tab_force_link_tmp->id_link = j;
            tab_force_link_tmp->path_ou_wall = path_ou_wall;
            tab_force_link_tmp++;
            continue;
        }

        /* pour chaque cellule
           - no_cellule:tag=(lien_Xx_cellule_destination,[...]) (lien_Xx_tag,[...])
         */
        ok = sscanf(t, "%lu:%lu=(%250s (%250s", &i, &j, u, v);
        if (ok == 4) {
            /* déclaration d'une cellule */
            /* (!) NB : aucune vérif, le fichier *doit* être valide
               (=> à valider via common/verif.c avant d'appeler cette fonction ) */
            /* remplacer la parenthèse de fin par ','
               pour simplifier l'analyse */
            u[strlen(u) - 1] = ',';
            v[strlen(v) - 1] = ',';
            /* Ok => u et v du type 'nombre,nombre,...'
             * (!) NB (bis) : aucune vérif, le fichier *doit* être valide 
             */
            t = u;
            nb_tab_liens = 0;
            do {
                recup_ul(&t, &tab_liens[nb_tab_liens]);
                nb_tab_liens++;
            } while (*t);

            /* (!) NB (ter) : aucune vérif, le fichier *doit* être valide */
            t = v;
            nb_tab_liens_tag = 0;
            do {
                recup_ul(&t, &tab_liens_tag[nb_tab_liens_tag]);
                nb_tab_liens_tag++;
            } while (*t);

            /* on a tout lu */
            i--;
            tabcell[i].tag = j;
            /* Ne réécrire par dessus les autres attributs
               que si on n'applique aucun filtre : */
            if (lire_seulement_tag == 0) {

                tabcell[i].links = links_debut;
                tabcell[i].nb_links = nb_tab_liens;
                for (j = 0; j < nb_tab_liens; j++) {
                    tabcell[i].links[j].link = &tabcell[tab_liens[j] - 1];
                    tabcell[i].links[j].tag = tab_liens_tag[j];
                    links_debut++;
                }
            }
        }
    }

    fclose(hinput);

/* (!) 
Note : à un moment donné, je voulais appliquer 
un algo *en fonction* de la cellule concernée.
C'est tellement complexe que j'ai mis tout ça
de côté, et qu'en s'organisant bien, il doit être
possible de "séparer" les cellules de manière à 
calculer de chaque côté les labyrinthes avec 
chacun leurs propres algos, et une fois que
tous les labyrinthes avec chaque algos
ont été crées, de les fusionner (= étape pas
du tout faite, même pas entamée du tout).

Je laisse mon vieux commentaire au cas où un 
jour je décide de tout reprendre :

boucle pour appliquer partout algo en paramètre :
while (1) {
    tabcell[total_cells].id_algo = id_algo;
    if (total_cells == 0)
        break;
    total_cells--;
} 
*/

    return ret;
}
