#include <iostream>

using namespace std;

int gereArguments(char argc,char *argv[]);
void afficheAide();
void compression(const string&,char, const string&);
void decompression(const string&,char, const string&);

int main(char argc,char *argv[])
{
    bool retour;
    /* on envoit les arguments à la fonction pour qu'elle appelle les fonctions de compressions
       ou de décompression :                                                                   */
    try
    {
        retour = gereArguments(argc,argv);
    }

    catch (const string& exceptions)// on récupère les exceptions et on les affiche
    {
        cerr<<exceptions;
        retour = EXIT_FAILURE;
    }
    return retour;
}


int gereArguments(char argc,char *argv[])
{
    if (argc < 3)// si il n'y pas assez d'arguments
    {
        afficheAide();
        return(EXIT_FAILURE);
    }


    string CheminFichier = argv[argc-1];
    string Argument1 = argv[1];// On récupère l'argument de la compression ou décompression

    char flag = '@';
    string FichierResultat = CheminFichier;
    if (argc>3)
    {
        string Argument2 = argv[2];
        if (Argument2.substr(0,2)=="-f")// si l'utilisateur veut préciser le flag
        {
            if (Argument2.size()>4)
                throw string("Le flag ne doit être constitué que d'un seul caractère.\n");
            else if (Argument2.size()<4)
            {
                afficheAide();
                return EXIT_FAILURE;
            }
            flag = Argument2[3];
            if (flag=='3'||flag=='4'||flag=='5'||flag=='6'||flag=='7'||flag=='8'||flag=='9')
                throw string("Le flag ne peut pas être un chiffre supérieur à 2.\n");// pour éviter des problèmes à la décompression
            if (argc==5) // si l'utilisateur veut aussi préciser la destination
            {
                string Argument3 = argv[3];
                if (Argument3.substr(0,2)=="-n"&&Argument3.size()>3)
                    FichierResultat = Argument3.substr(3,Argument3.size());
                else
                {
                    afficheAide();
                    return EXIT_FAILURE;
                }
            }
            else if (argc>5)
            {
                afficheAide();
                return EXIT_FAILURE;
            }
        }
        else if (Argument2.substr(0,2)=="-n"&&Argument2.size()>3) // si l'utilisateur veut seulement préciser la destination
            FichierResultat = Argument2.substr(3,Argument2.size());
        else
        {
            afficheAide();
            return EXIT_FAILURE;
        }
    }
    if (Argument1=="-c")
        // On compresse avec les options (changées ou pas par l'utilisateur)
        compression(CheminFichier,flag,FichierResultat);
    else if (Argument1=="-d")
        // On décompresse avec les options (changées ou pas par l'utilisateur)
        decompression(CheminFichier,flag,FichierResultat);
    else
        afficheAide();

    return EXIT_SUCCESS;
}

void afficheAide()
{
    cout<<"Utiliser ce programme de cette manière :"<< endl<<endl<<
    "Pour la compression, utilisez le parametre -c"<<endl<<endl<<
    "Pour la décompression, utilisez le parametre -d"<<endl<<endl<<
    "Si vous voulez utiliser un flag spécifique :"<<endl<<"Utilisez le paramètre -f=\"flag\""
    "dans lequel vous remplacez flag par la lettre"<<endl<<"(Attention il est nécessaire"
    " d'utiliser le même flag pour la compression et la"<<endl<<"décompression)"<<endl<<endl<<
    "Si vous ne souhaitez pas écraser le fichier original(compressé ou décompressé) :"<<endl<<
    "Vous pouvez indiquer la destination en utilisant le paramètre -n=\"fichier_dest\""<<endl<<endl<<
    "Il est nécessaire d'indiquer le fichier à compresser ou à décompresser à la fin"<<endl<<endl<<
    "Exemple : RLE -c -f=\"&\" mon_fichier.txt"<<endl<<
    "Compresse le fichier \"mon_fichier.txt\" en utilisant le flag &"<<endl<<endl<<
    "RLE -d -n=\"fichier.decompr\" fichier.rle"<<endl<<
    "Décompresse le fichier \"fichier.rle\" dans \"fichier.decompr\" en utilisant"<<endl<<
    "le flag par défaut"<<endl<<endl;
}

//gère la compression ainsi que la fonction de réecriture

#include <iostream>
#include <fstream>
#include <cstdio> //pour la suppression du fichier

using namespace std;

string transformePetit(const string&,char);
//Compresse une chaine de caractere selon les regles du RLE

void reecrit(const string&,const string&, const string&);
//Copie un fichier dans un autre et supprime le premier fichier

//-------------------------------------------------------------------------------------------------

void compression(const string& CheminACompresser,char flag, const string& CheminResultat)
{
    cout<< "compression en cours..."<<endl;

    // On ouvre les fichiers et on teste les ouvertures en lancant des exceptions si besoin
    ifstream FichierSource(CheminACompresser.c_str(), ios::in);

    if (FichierSource.fail())
        throw string("Impossible d'ouvrir le fichier à compresser :\n"+CheminACompresser+"\n");

    const string CheminACompresserTemp = CheminACompresser + ".rle.tmp"; //fichier temporaire qui sera supprimé à la fin
    ofstream FichierResultat(CheminACompresserTemp.c_str(), ios::out | ios::trunc);

    if (FichierResultat.fail())
        throw string("Impossible d'ouvrir le fichier dans lequel on veut compresser :\n");

    //Variables temporaires pour la compression
    string LigneActuelle, LigneConverti;
    unsigned int nombreDeCaractereAvant = 0, nombreDeCaractereApres = 0;
    unsigned int pourcentage = 0;

    // La boucle parcourt tout le fichier ligne par ligne
    while (getline(FichierSource,LigneActuelle))
    {
        // On compresse la ligne actuelle
        LigneConverti = transformePetit(LigneActuelle,flag);

        // On compte les caractères pour afficher le taux de compression
        nombreDeCaractereAvant += LigneActuelle.size();
        nombreDeCaractereApres += LigneConverti.size();

        // on inscrit la ligne compressée dans le fichier temporaire
        FichierResultat<<LigneConverti;

        if (!FichierSource.eof())// et on rajoute une ligne si on a pas atteint la fin du fichier
            FichierResultat<<endl;
    }

    // On calcule le pourcentage et on l'affiche
    cout<<"compression terminée sans erreur : ";
    pourcentage = static_cast<int>(nombreDeCaractereApres*100.0/nombreDeCaractereAvant);
    cout<<"Le fichier fait "<<pourcentage<<" % de sa taille originale."<<endl;
    
    //On gere le cas ou la compression a ete inefficace
    string Continuer = "O";

    if (pourcentage>100.0) // On affiche un message de confirmation
    {
        cout<<"Le taux de compression est mauvais, peut-être essayez vous de compresser"<<endl<<
        "un fichier déjà compressé ?"<<endl<<
        "Sinon il est peut-être nécessaire d'essayer avec un autre flag (option -f)"<<endl<<endl<<
        "Souhaitez vous continuez [O/n] ? ";
        cin >> Continuer;
    }
    
    //On ferme les deux fichiers
    FichierSource.close();
    FichierResultat.close();

    // On réecrit le contenu du fichier temporaire dans le fichier de destination et on supprime
    // le fichier temporaire                                                               
    reecrit(CheminACompresserTemp,Continuer, CheminResultat);
}

//-------------------------------------------------------------------------------------------------

string transformePetit(const string& LigneActuelle, char flag)
{
    char caractereActuel =' ', ancienCaractere=' ';
    int nombreDePresence = 0;
    string LigneConverti;

    // tant que la fin de la ligne n'est pas atteinte
    for (unsigned int i = 0;i<=LigneActuelle.size();i++)
    {
        if (i>=1)
            ancienCaractere = caractereActuel;

        caractereActuel = LigneActuelle[i];

        if (ancienCaractere==flag&&i>=1)// Si il y a un flag dans le texte
        {
            LigneConverti = LigneConverti + flag + flag;
            nombreDePresence = 1;
        }

        // Si le caractère actuel est le même que celui d'avant
        else if (ancienCaractere==caractereActuel&&i>=1&&nombreDePresence<9)
            nombreDePresence++;

        // Sinon si le nombre de présence est <= 2 on les affiche normalement
        else if (nombreDePresence<=2)
        {
            for (int j = 0;j<nombreDePresence;j++)
                LigneConverti+=ancienCaractere;
            nombreDePresence = 1;
        }

        // Si le nombre de présence est > 2 on les affiche compressés (nombre,flag,caractère)
        else
        {
            char nombre = nombreDePresence +48;
            LigneConverti = LigneConverti +nombre+ flag + ancienCaractere;
            nombreDePresence = 1;
        }
    }

    return LigneConverti;
}

//-------------------------------------------------------------------------------------------------

void reecrit(const string& FichierAReecrire,const string& continuer,const string& CheminResultat)
{
    if (continuer=="O"||continuer=="o")// Si l'utilisateur a continué
    {
        // On ouvre les fichiers et on vérifie les ouvertures en lancant des exceptions si besoin
        ifstream FichierSource(FichierAReecrire.c_str(), ios::in);
        ofstream FichierResultat(CheminResultat.c_str(), ios::out | ios::trunc);

        if (FichierSource.fail())
            throw string("Problème interne : fichier1\n");

        if (FichierResultat.fail())
            throw string("Problème interne : fichier2\n");

        string LigneActuelle;
        // on recopie tout le fichier temporaire dans le fichier définitif
        while (getline(FichierSource,LigneActuelle))
        {
            FichierResultat<<LigneActuelle;
            if (!FichierSource.eof())
                FichierResultat<<endl;
        }
        FichierSource.close();
        FichierResultat.close();

    }

    // Suppression du fichier temporaire 
   remove(FichierAReecrire.c_str());

}

// gère la decompression

#include <iostream>
#include <fstream>

using namespace std;

string transformeGrand(const string&,char);
//Decompresse une chaine de caractere selon les regles du RLE

void reecrit(const string&,const string&,const string&);
//Copie un fichier dans un autre et supprime le premier fichier

void decompression(const string& CheminADecompresser,char flag, const string& CheminResultat)
{
    cout<< "décompression en cours..."<<endl;

    // On ouvre les fichiers et on teste les ouvertures en lancant des exceptions si besoin
    ifstream FichierSource(CheminADecompresser.c_str(), ios::in);

    if (FichierSource.fail())
        throw string("Impossible d'ouvrir le fichier à compresser :\n");

    const string CheminADecompresserTemp = CheminADecompresser + ".rle.tmp";
    ofstream FichierResultat(CheminADecompresserTemp.c_str(), ios::out | ios::trunc);

    if (FichierResultat.fail())
        throw string("Impossible d'ouvrir le fichier dans lequel on veut decompresser :\n");

    //Variables temporaires pour la decompression
    string LigneActuelle, LigneConverti;

    // La boucle parcourt tout le fichier ligne par ligne
    while (getline(FichierSource,LigneActuelle))
    {
        // On décompresse la ligne
        LigneConverti = transformeGrand(LigneActuelle,flag);

        // On l'inscrit dans le fichier temporaire
        FichierResultat<<LigneConverti;
        if (!FichierSource.eof())
            FichierResultat<<endl;
    }

    cout<<"décompression terminée sans erreur"<<endl;

    FichierSource.close();
    FichierResultat.close();

    // On réecrit le fichier temporaire dans le fichier de destination
    reecrit(CheminADecompresserTemp,"0", CheminResultat);
}
string transformeGrand(const string& LigneActuelle,char flag)
{

    string LigneConverti;

    // On utilise ces variables pour ne pas se casser la tête avec des LigneActuelle[...] à répétition
    char prochainCaractere =' ', caractereActuel =' ', dernierCaractere =' ', avantDernierCaractere =' ', apresProchainCaractere =' ';
    int nombreDePresence = 0, nombreDeFlagSuccessif = 0;
    unsigned int finDeLigne = LigneActuelle.size();
    bool pasFlag = false;


    for (unsigned int i = 0;i<LigneActuelle.size();i++)
    {
        // On n'initialise les variables que si on n'a le droit de le faire (attention aux début et fin de ligne)
        if (i>=2)
            avantDernierCaractere = dernierCaractere;
        if (i>=1)
            dernierCaractere = caractereActuel;
        caractereActuel = LigneActuelle[i];
        if (i+1<=finDeLigne)
            prochainCaractere = LigneActuelle[i+1];
        if (i+2<=finDeLigne)
            apresProchainCaractere = LigneActuelle[i+2];

        // Permet de vérifier que le fichier a déjà été compressé (test à la fin)
        if (caractereActuel==flag)
            nombreDeFlagSuccessif++;
        else
            nombreDeFlagSuccessif = 0;

        // Si les caractères ont été compressés sous la forme |nombre|flag|caractere|
        if (dernierCaractere ==flag&&caractereActuel!=flag&&avantDernierCaractere!=flag&&i>=2)
        {
            nombreDePresence = avantDernierCaractere;
            nombreDePresence-=48;

            for (int j = 0;j<nombreDePresence;j++)
                LigneConverti+=caractereActuel;
        }
        // Le caractère n'est pas écrit sous forme compressé:

        // Si le caractère est entouré de 2 autres caractères non flag
        else if ((dernierCaractere!=flag&&caractereActuel!=flag&&prochainCaractere!=flag&&i>=1)||
                 // Ou si il est en début de ligne et que le prochain caractère n'est pas un flag
                 (caractereActuel!=flag&&prochainCaractere!=flag&&i==0)||
                 // Ou si il est en début de ligne et que les 2 prochains caractères sont des flags
                 (caractereActuel!=flag&&prochainCaractere==flag&&apresProchainCaractere==flag&&i==0)||
                 // Ou si il est suivi d'au moins 2 flags et précédé par un caractère normal
                 (prochainCaractere==flag&&apresProchainCaractere==flag&&caractereActuel!=flag&&dernierCaractere!=flag&&i>=1&&i+2<=finDeLigne)||
                 // Ou l'inverse
                 (avantDernierCaractere==flag&&dernierCaractere==flag&&caractereActuel!=flag&&prochainCaractere!=flag&&i>=2&&i+1<=finDeLigne)||
                 // Ou si il est précédé par 2 flags et suivi par 2 flags
                 (avantDernierCaractere==flag&&dernierCaractere==flag&&caractereActuel!=flag&&prochainCaractere==flag&&apresProchainCaractere==flag&&i>=2&&i<=finDeLigne))
        {
            LigneConverti+=caractereActuel;
        }
        // Si il y a 2 flags de suite ou plus :
        else if (caractereActuel==flag&&dernierCaractere==flag&&i>=1)
        {
            if (pasFlag)// Si on ne vient pas d'en écrire un
            {
                // On l'écrit
                LigneConverti +=flag;
                pasFlag = false;
            }
            else // Si on vient d'en écrire un
                pasFlag = true;
        }

        else
        {
            pasFlag = true;
            if (nombreDeFlagSuccessif%2==1&&nombreDeFlagSuccessif!=1) // On vérifie le nombre de flags successifs
            {
                string StrFlag;
                StrFlag += flag;
                throw string("Le fichier n'avait pas été compressé ou avait été compressé avec un flag différent\n"
                             "de celui-ci ("+StrFlag+"), ou a été corrompu par la suite.\nAnnulation.\n");
            }
        }
        // On vérifie qu'il n'y a pas plus de 2 caractères identiques
        if (dernierCaractere==caractereActuel&&caractereActuel==prochainCaractere&&i>=1&&dernierCaractere!=flag&&i>=1&&i+1<=finDeLigne)
        {
            // Il est aussi possible qu'il y en est 3 si le premier est précédé par un flag :
            // Si il y en a 3 mais que le premier n'est pas précédé par un flag :
            if (i>=3&&avantDernierCaractere==dernierCaractere&&LigneActuelle[i-3]!=flag)
            {
                // On envoie une exception avec le flag utilisé
                string StrFlag;
                StrFlag += flag;
                throw string("Le fichier n'avait pas été compressé ou avait été compressé avec un flag différent\n"
                             "de celui-ci ("+StrFlag+"), ou a été corrompu par la suite.\nAnnulation.\n");
            }
        }
    }
    return LigneConverti;

}