#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define N 1000000

struct sequence_t {
    int lg;
    char tab[1000000];
};
typedef struct sequence_t sequence;

struct ensemble_t {
    int card;
    sequence * tab[1000000];
};
typedef struct ensemble_t ensemble;

/* ------------------------------------------------------------------------------------------------ */
/*  Copier coller dans un fichier et compiler

    C'est pas comme le fichier c de l'APP3 donner par les profs mais c'est la meme chose dans le fond

    Mon idee :

    -> On a un ou plusieurs brins et la signature du virus
    -> On "balise" la signature du virus si on le trouve (autant de fois qu'il y en a) dans le brin
    -> On découpe en sous-séquences
    -> Puis on rajoute dans l'ensemble de brins

    Exemple :

    Brin : ACGTCGACGATTTACGATATACGATACG
    Signature du virus : ACG

    -> étape 1 : on "balise" avec le caractère '|' (fonction chercheSousSeq)
    -> résultat : ACG|TCG|ACG|ATT|ACG|ATAT|ACG|ATACG

    -> étape 2 : on découpe en sous-séquences
    -> résultat :  ACG
                    TCG
                    ACG
                    ATT
                    ACG
                    ATAT
                    ACG
                    ATACG

    -> étape 3 : on rajoute dans l'ensemble de brins   (fonction decoupe)
    -> résultat : Ensemble au départ = ACGTCGACGATTTACGATATACGATACG
                  Ensemble à la fin = ACG
                                      TCG
                                      ACG
                                      ATT
                                      ACG
                                      ATAT
                                      ACG
                                      ATACG

    Perso je pense que ma méthode est trop coûteuse à cause de l'étape 1 O(n^3)
*/

/* Cree une nouvelle sequence */
sequence * nouvelleSequence(){

    sequence * seq = malloc(sizeof(sequence));
    if ( seq == NULL ){
        printf("Dans fonction  : nouvelleSequence() \nseq == NULL \n\n");
        exit(1);
    }

    seq->lg = 0;

    return seq;
}

/* Cree un nouveauEnsemble */
ensemble * nouvelleEnsemble(){

    ensemble * E = malloc(sizeof(ensemble));
    if ( E == NULL ){
        printf("Dans fonction  : nouvelleEnsemble() \nE == NULL \n\n");
        exit(1);
    }
    E->card = 0;

    return E;
}

/* Verifie si la sequence est vide */
int estVideSequence(sequence * seq){

    if ( seq == NULL ){
        printf("Dans fonction  : estVideSequence(seq) \nseq == NULL \n\n");
        exit(1);
    }
    else {
        if ( seq->lg == 0 )
            return 1;
        else
            return 0;
    }
}

/* Verifie si un ensemble est vide */
int estVideEnsemble(ensemble * E){

    if ( E == NULL ){
        printf("Dans fonction  : estVideEnsemble(E) \nE == NULL \n\n");
        exit(1);
    }
    else {
        if ( E->card == 0 )
            return 1;
        else
            return 0;
    }
}

/* Affiche une sequence de caractere */
void afficherSequence(sequence * seq){

     if ( seq == NULL ){
        printf("Dans fonction  : afficherSequence(seq) \nseq == NULL \n\n");
        exit(1);
    }
    else {
        int i = 0;
        while ( i < seq->lg ){

            printf("%c",seq->tab[i]);
            i++;
        }
        printf("\n");
    }
}

/* Affiche un ensemble de sequence de caractere */
void afficherEnsemble(ensemble * E){

    if ( E == NULL ){
        printf("Dans fonction  : afficherEnsemble(E) \nE == NULL \n\n");
        exit(1);
    }
    else {

        int i = 0;
        while ( i < E->card ){

            afficherSequence(E->tab[i]);
            i++;
        }
    }
}

/* Ajoute l'element e a la fin de seq */
void ajouterElementEnFin(sequence * seq, char e){

     if ( seq == NULL ){
        printf("Dans fonction  : ajouterElementEnFin(seq,e) \nseq == NULL \n\n");
        exit(1);
    }
    else if ( seq->lg == N ){
        printf("Dans fonction : ajouterElementEnFin(seq,e) \nsequence pleine \n\n");
    }
    else if ( e == 'A' || e == 'C' || e == 'T' || e == 'G' ||e == '|' ) {
        seq->tab[seq->lg] = e;
        seq->lg++;
    }
    else {
        printf("Dans fonction : ajouterElementEnFin(seq,e) \ncaractere %c invalide \n\n",e);
    }
}

/* Ajoute mot dans seq */
void ajouterMotDansSequence(sequence * seq, char * mot){

     if ( seq == NULL ){
        printf("Dans fonction  : ajouterMotDansSequence(seq,mot) \nseq == NULL \n\n");
        exit(1);
    }
    else if ( seq->lg == N ){
        printf("Dans fonction : ajouterMotDansSequence(seq,mot) \nsequence pleine \n\n");
    }
    else if ( mot == NULL ){
        printf("Dans fonction : ajouterMotDansSequence(seq,mot) \nmot == NULL \n\n");
        exit(1);
    }
    else if ( strlen(mot) == 0 ){
        printf("Dans fonction : ajouterMotDansSequence(seq,mot) \nmot vide \n\n");
    }
    else {
        int i = 0;

        while ( mot[i] != '\0' ){

            ajouterElementEnFin(seq,mot[i]);
            i++;
        }
    }
}

/* Ajoute e a seq apres l'indice i */
void ajouterApresIndice(sequence * seq, char e, int indice){

     if ( seq == NULL ){
        printf("Dans fonction  : ajouterApresIndice(seq,e,indice) \nseq == NULL \n\n");
        exit(1);
    }
    else if ( seq->lg == N ){
        printf("Dans fonction : ajouterApresIndice(seq,e,indice) \nsequence pleine \n\n");
    }
    else if ( indice < 0 || indice >= seq->lg ){
        printf("Dans fonction : ajouterApresIndice(seq,e,indice) \nindice %i invalide \n\n",indice);
    }
    else if ( e == 'A' || e == 'C' || e == 'T' || e == 'G' || e == '|' ) {

        if ( indice == seq->lg - 1 ){
            ajouterElementEnFin(seq,'|');
        }

        else {
            int i = seq->lg;
            for (i = seq->lg; i > indice; i--){
                seq->tab[i] = seq->tab[i-1];
            }
            if ( i >= 0 && i < seq->lg + 1 ){
                seq->tab[i+1] = '|';
                seq->lg++;
            }
         }
    }
    else {
        printf("Dans fonction : ajouterApresIndice(seq,e,indice) \ncaractere %c invalide \n\n",e);
    }
}

void chercheSousSeq(sequence * seq, char * mot){

     if ( seq == NULL ){
        printf("Dans fonction  : chercheSousSeq(seq,mot) \nseq == NULL \n\n");
        exit(1);
    }
    else if ( mot == NULL ){
        printf("Dans fonction : chercherSousSeq(seq,mot) \nmot == NULL \n\n");
        exit(1);
    }
    else if ( strlen(mot) > seq->lg ){
        printf("Dans fonction : chercheSousSeq(seq,mot) \ntaille du mot trop grand ,taille mot = %i\n\n",strlen(mot));
    }
    else if ( strlen(mot) == 0 ){
        printf("Dans fonction : chercheSousSeq(seq,mot)\nmot vide \n\n");
    }
    else if ( estVideSequence(seq) ){
        printf("Dans fonction : chercheSousSeq(seq,mot)\nSequence vide \n\n");
    }
    else {

        int i = 0;
        while ( i < seq->lg ){

                if ( seq->tab[i] == mot[0] ){

                    int tailleMot = strlen(mot);
                    int debut = i;
                    int k = i + 1;
                    int j = 1;

                    while ( k < seq->lg && j < tailleMot ){

                            if ( seq->tab[k] != mot[j] )
                                break;
                    j++;
                    k++;
                    }

                    if ( j == tailleMot ){

                        int fin = k-1;

                        if ( debut == 0 )
                            ajouterApresIndice(seq,'|',fin);
                        else if ( seq->tab[debut-1] == '|' )
                            ajouterApresIndice(seq,'|',fin);
                        else {
                            ajouterApresIndice(seq,'|',fin);
                            ajouterApresIndice(seq,'|',debut-1);
                        }
                    i = k;
                    }

                }
        i++;
        }
    }
}

void ajouterSequenceDansEnsemble(ensemble * E, sequence * seq){

    if ( E == NULL ){
        printf("Dans fonction : ajouterSequenceDansEnsemble(E,seq)\nE == NULL \n\n");
        exit(1);
    }
    else if ( seq == NULL ){
        printf("Dans fonction  : ajouterSequenceDansEnsemble(E,seq)\nseq == NULL \n\n");
        exit(1);
    }
    else if ( E->card == N ){
        printf("Dans fonction : ajouterSequenceDansEnsemble(E,seq)\nEnsemble plein \n\n");
    }
    else {
        E->tab[E->card] = nouvelleSequence();

        int i = 0;
        while ( i < seq->lg ){

                ajouterElementEnFin(E->tab[E->card],seq->tab[i]);
        i++;
        }
        E->card++;
    }

}

void decoupe(ensemble * E, sequence * seq){

    if ( seq == NULL ){
        printf("Dans fonction  : decoupe(seq) \nseq == NULL \n\n");
        exit(1);
    }
    else if ( E == NULL ){
        printf("Dans fonction  : decoupe(E,seq)\nE == NULL \n\n");
        exit(1);
    }
    else if ( estVideSequence(seq) ){
        printf("Dans fonction : decoupe(seq)\nSequence vide \n\n");
    }
    else {

        int i = 0;
        while ( i < seq->lg ){

            sequence * sousSeq = nouvelleSequence();
            int j = i;

            while ( j < seq->lg && seq->tab[j] != '|'  ){

                    ajouterElementEnFin(sousSeq,seq->tab[j]);
            j++;
            }

            if ( !estVideSequence(sousSeq) )
                ajouterSequenceDansEnsemble(E,sousSeq);

        i = j + 1;
        }
    }
}
int main()
{
    sequence * seq = nouvelleSequence();
    ensemble * E = nouvelleEnsemble();

    srand(time(NULL));
    ajouterMotDansSequence(seq,"ATACGATAAAATTTACGACGATACGACG");
    afficherSequence(seq);

    chercheSousSeq(seq,"AAAATTTA");
    afficherSequence(seq);
    printf("\n");
    decoupe(E,seq);

    afficherEnsemble(E);
    return 0;
}