//://////////////////////////////////////////////
//:: Name
//:: FileName  inc_tableaux
//:: Copyright (c) 2006 MOW Corp.
//://///////////////////////////////////////////
/*
  Bibliotheque de fonctions de gestion des tableaux

  Ce script est une bibliotheque.
  Il contient toutes les fonctions utilisees pour
  emuler des tableaux a 2 dimensions avec le nwnScript.

  Limitations :
  - 1 a n colonnes dans le tableau. (plus on en mets, moins faut mettre de lignes normal )
  - nb de lignes 60 lignes pour un tableau 4 colonnes de 32 caracteres par cellules.
    On peut ptet pousser au dela mais a 75-80 ---> TOO MANY INSTRUCTIONS, nwn jette l'eponge.
  - Oblige de passer par des strings. Donc si une colonne
    ne contient que des int ou des floats il ne faudra pas
    oublier de faire les conversions.
  - Les Tris : Necessite des tableaux 2 a 3 fois moins gros que ce qui est dit
    juste au dessus sinon TOO MANY INSTRUCTIONS
*/
//://///////////////////////////////////////////
//:: Created By:    Marco
//:: Created On:    09/09/2006
//://///////////////////////////////////////////

#include "inc_string"

///////////////////////////////
//DECLARATION DES STRUCTURES//
/////////////////////////////
//La ligne d'indice 1 d'un tableau est la premiere ligne.
struct Tableau {
    string sData; //La chaine contenant les donnees
    int nCol;    //Le nb de colonnes (aucune utilite pour le moment. Mis a la creation, pas touche depuis)
    int nLignes;  //Le nb de lignes (seule utilite, connaitre le nb de ligne tres vite)
    int nTailleMaxCellule;  //Taille maxi de chaque cellule.
    string sCaractereToComplete; //Caractere utilise pour completer les donnees des cellules.
};

///////////////////////////////
//DECLARATION DES CONSTANTES//
/////////////////////////////



/////////////////////////////////////////////////
//REGLE DE CONSTRUCTION DES DONNEES DU TABLEAU//
///////////////////////////////////////////////
/*

La taille des cellules est limitee a la creation du tableau.(cf la structure)
Ainsi, a chaque fois qu'une donnee est ajoutee dans une cellule, elle est
complete avec un caractere pre-defini (cf la structure) pour aller jusqu'a
la taille max de la cellule.

Cette methode permet d'eviter toutes les boucles de la version precedente
de inc_tableaux ou l'on construisait les cellules puis les lignes avec des
separateurs.

Je trouve pas de systeme pour donner aux cellules une taille dynamique tout en
evitant au maximum les boucles. Si quelqu'un a idee je suis preneur, ca reduirait
encore + les ressources necessaire...

*/


////////////////////////////////////////////////
//DECLARATIONS DES FONCTIONS & DES PROCEDURES//
//////////////////////////////////////////////

//Cree un tableau. Le tableau est en fait une structure composee de :
//string sData  :...................une chaine qui contient toutes les donnees
//int nNbCol    :...................le nombre de colonnes du tableau
//int nNbLignes :...................le nombre de lignes
//int nTailleMaxCellule :...........taille maxi de chaque cellule du tableau
//string sCaractereToComplete :.....le caractere qui sert a completer les cellules
//Retourne le tableau cree.
struct Tableau Tab_CreateTableau(string sData, int nNbCol, int nNbLignes, int nTailleMaxCellule, string sCaractereToComplete);

//Retourne la cellule (AVEC les caracteres qui completent) place dans le tableau :
//a l'indice nIndiceCol pour les X
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabCelluleComplete(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne);

//Retourne la ligne (AVEC les caracteres qui completent) placee dans le tableau :
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabLigneComplete(struct Tableau MonTableau, int nIndiceLigne);

//Retourne la cellule (SANS les caracteres qui completent) place dans le tableau :
//a l'indice nIndiceCol pour les X
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabCellule(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne);

//Retourne la ligne (SANS les caracteres qui completent) placee dans le tableau :
//a l'indice nIndiceLigne pour les Y
string Tab_GetTableLigne(struct Tableau MonTableau, int nIndiceLigne);

//Remplace une ligne du tableau a l'indice nIndiceToReplace avec la ligne sLigneToReplace
//Retourne le nouveau tableau
struct Tableau Tab_ReplaceLigne(struct Tableau MonTableau, string sLigneToReplace, int nIndiceToReplace);

//Utilisee pour construire une ligne. Ajoute une cellule a la ligne que l'ont veut construire.
//Les caracteres manquants sont completes pour arriver a MonTableau.nTailleMaxCellule
//sNewLigne = Chaine vide pour la 1ere cellule de la ligne.
//Retourne sNewLigne construite.
string Tab_SetNewCellule(string sNewLigne, string sNewCellule, string sCaractereUseToComplete ,int nMaxSize);

//Ecrit une nouvelle ligne dans le tableau a la fin du tableau
//La ligne doit etre formatee correctement. Pour construire une ligne, utiliser la fonction
//Tab_SetNewCellule et boucler dessus jusqu'a avoir le nb de cellule composant la ligne.
//Retourne le nouveau tableau.
struct Tableau Tab_SetNewLigne(struct Tableau MonTableau, string sNewLigne);

//Insere une ligne sNewLigne a la position nIndiceInsertion
//Retourne le nouveau tableau.
struct Tableau Tab_InsertNewLigne(struct Tableau MonTableau, string sNewLigne, int nIndiceInsertion);

//Supprime la ligne d'indice nIndiceToDelete du tableau MonTableau
//Retourne le nouveau tableau.
//ATTENTION : Supprimer une ligne decale tous les indices > nIndiceToDelete de -1
struct Tableau Tab_DeleteLigne(struct Tableau MonTableau, int nIndiceToDelete);


/////////////////////////////////////////
//***  FONCTIONS DE TRI DES TABLEAUX
///////////////////////////////////////

//Fonction interne du tri Tab_TrieTableauParInsertion
struct Tableau DecaleTabTriParInsertion(struct Tableau MonTableau, int nPosition, int nIndiceCol);

//Trie le tableau
//Algorithme utilise : Tri par insertion (pas Dychotomique car certaines structures de controle indisponibles en nwnScript(ex : Do... While)
//struct Tableau MonTableau : Le tableau a trier
//int nNumCol : defini sur quel numero de colonne on trie le tableau
//******************************************************************
//NOTE_1 : On ne peut trier que sur des int (ptet des floats mais pas essaye) donc
//il faut faire attention sur la colonne a trier sinon ca renvoie vide ("").
//NOTE_2 : A preferer au tri par selection si tableau partiellement trié
//Retourne le nouveau tableau trié.
struct Tableau Tab_TrieTableauParInsertion(struct Tableau MonTableau, int nNumCol);

//Fonction interne de Tab_TrieTableauParSelection
struct Tableau EchangeTabTriParSelection(struct Tableau MonTableau, int nI, int nJ, int nIndiceCol);

//Fonction interne de Tab_TrieTableauParSelection
struct Tableau PlusPetitTabTriParSelection(struct Tableau MonTableau, int nPd, int nN, int nIndiceCol);

//Trie le tableau
//Algorithme utilise : Tri par selection (pas Dychotomique car certaines structures de controle indisponibles en nwnScript(ex : Do... While)
//struct Tableau MonTableau : Le tableau a trier
//int nNumCol : defini sur quel numero de colonne on trie le tableau
//******************************************************************
//NOTE_1 : On ne peut trier que sur des int (ptet des floats mais pas essaye) donc
//il faut faire attention sur la colonne a trier sinon ca renvoie vide ("").
//NOTE_2 : A preferer au tri par insertion si tableau totalement desordonne
//Retourne le nouveau tableau trié.
struct Tableau Tab_TrieTableauParSelection(struct Tableau MonTableau, int nNumCol);


/////////////////////////////////////////////////////
//***  GESTION EN VARIABLES LOCALES DES TABLEAUX
///////////////////////////////////////////////////

//Enregistre le Tableau MonTableau de nom sVarName sur l'objet oObject.
void SetLocalTableau(object oObject, string sVarName, struct Tableau MonTableau);

//Renvoi une structure Tableau nommee sVarName.
//Retourne une structure vide en cas d'erreur.
struct Tableau GetLocalTableau(object oObject, string sVarName);

//Supprime le tableau de nom sVarName stocke sur oObject.
void DeleteLocalTableau(object oObject, string sVarName);


////////////////////////////////////////////////////
//IMPLEMENTATION DES FONCTIONS & DES PROCEDURES /
//////////////////////////////////////////////////

struct Tableau Tab_CreateTableau(string sData, int nNbCol, int nNbLignes, int nTailleMaxCellule, string sCaractereToComplete)
{
    struct Tableau MonTableau;  //Declaration de la structure

    MonTableau.sData = sData; //La chaine contenant les donnees
    MonTableau.nCol = nNbCol;    //Le nb de colonnes
    MonTableau.nLignes = nNbLignes;  //Le nb de lignes
    MonTableau.nTailleMaxCellule = nTailleMaxCellule; //Taille max des cellules
    MonTableau.sCaractereToComplete = sCaractereToComplete; //Caract. pour completer les cells.

    return MonTableau;  //On a cree le tableau, et on le retourne
}

//******************************************************************************

string Tab_GetTabCelluleComplete(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne)
{
    string sCellule, sLigne;
    int nStart, nCount;
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

    nCount = MonTableau.nTailleMaxCellule;
    nStart = (nIndiceCol-1) * nCount;

    sLigne = Tab_GetTabLigneComplete(MonTableau, nIndiceLigne);

    sCellule = GetSubString(sLigne, nStart, nCount);

    return sCellule;
}

//******************************************************************************

string Tab_GetTabLigneComplete(struct Tableau MonTableau, int nIndiceLigne)
{
    int nStart, nCount;
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

    nStart = (nIndiceLigne-1) * nLongLigne;

    string sLigne = GetSubString(MonTableau.sData, nStart, nLongLigne);

    return sLigne;
}

//******************************************************************************

string Tab_GetTabCellule(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne)
{
    string sCellule, sLigne;
    int nStart, nCount;
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

    nCount = MonTableau.nTailleMaxCellule;
    nStart = (nIndiceCol-1) * nCount;

    sLigne = Tab_GetTabLigneComplete(MonTableau, nIndiceLigne);

    sCellule = SupprimeUnString(GetSubString(sLigne, nStart, nCount), MonTableau.sCaractereToComplete);

    return sCellule;
}

//******************************************************************************

string Tab_GetTableLigne(struct Tableau MonTableau, int nIndiceLigne)
{
    int nStart, nCount;
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

    nStart = (nIndiceLigne-1) * nLongLigne;

    string sLigne = SupprimeUnString(GetSubString(MonTableau.sData, nStart, nLongLigne), MonTableau.sCaractereToComplete);

    return sLigne;
}

//******************************************************************************

struct Tableau Tab_ReplaceLigne(struct Tableau MonTableau, string sLigneToReplace, int nIndiceToReplace)
{
    string sDataTab = ReplaceString(MonTableau.sData, sLigneToReplace, nIndiceToReplace);
    MonTableau.sData = sDataTab;

    return MonTableau;
}

//******************************************************************************

string Tab_SetNewCellule(string sNewLigne, string sNewCellule,
                        string sCaractereUseToComplete ,int nMaxSize)
{
    sNewLigne += CompleteString(sNewCellule, sCaractereUseToComplete, nMaxSize);
    return sNewLigne;
}

//******************************************************************************

struct Tableau Tab_SetNewLigne(struct Tableau MonTableau, string sNewLigne)
{
    int nNbLignes = MonTableau.nLignes;
    nNbLignes++;
    MonTableau.nLignes = nNbLignes;

    string sDataTab = MonTableau.sData;
    sDataTab += sNewLigne;
    MonTableau.sData = sDataTab;

    return MonTableau;
}

//******************************************************************************

struct Tableau Tab_InsertNewLigne(struct Tableau MonTableau, string sNewLigne, int nIndiceInsertion)
{
    int nNbLignes = MonTableau.nLignes;
    nNbLignes++;
    MonTableau.nLignes = nNbLignes;

    int nPosition;
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

    nPosition = (nIndiceInsertion-1) * nLongLigne;

    MonTableau.sData = InsertString(MonTableau.sData, sNewLigne, nPosition);

    return MonTableau;
}

//******************************************************************************

struct Tableau Tab_DeleteLigne(struct Tableau MonTableau, int nIndiceToDelete)
{
    int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;
    string sDataGauche = "";
    string sDataDroite = "";
    int nTailleData = GetStringLength(MonTableau.sData);
    int nNbPositions = nTailleData / nLongLigne;
    int nCountGauche = ((nIndiceToDelete - 1) * nLongLigne);
    int nCountDroite = ((nNbPositions - nIndiceToDelete) * nLongLigne);
    if (nCountGauche < 0)
    {
        nCountGauche = 0;
    }
    if (nCountDroite < 0)
    {
        nCountDroite = 0;
    }

    sDataGauche = GetStringLeft(MonTableau.sData, nCountGauche);

    sDataDroite = GetStringRight(MonTableau.sData, nCountDroite);

    MonTableau.sData = sDataGauche + sDataDroite;

    return MonTableau;
}

//******************************************************************************

struct Tableau DecaleTabTriParInsertion(struct Tableau MonTableau, int nPosition, int nIndiceCol)
{
    int nDpg = nPosition-1;
    struct Tableau WorkingTableau = MonTableau;

    string sTamponCellule = Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nPosition);
    string sTamponLigne = Tab_GetTabLigneComplete(WorkingTableau, nPosition);

    while ( ( StringToInt((Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nDpg))) > StringToInt(sTamponCellule) ) && (nDpg >= 0) )
    {
        WorkingTableau = Tab_ReplaceLigne(WorkingTableau, (Tab_GetTabLigneComplete(WorkingTableau, nDpg)),(nDpg+1));
        nDpg--;
    }
    WorkingTableau = Tab_ReplaceLigne(WorkingTableau, sTamponLigne, (nDpg+1));
    return WorkingTableau;
}

//******************************************************************************

struct Tableau Tab_TrieTableauParInsertion(struct Tableau MonTableau, int nNumCol)
{
    struct Tableau WorkingTableau = MonTableau;
    int nPosition;
    for(nPosition = 1; nPosition < WorkingTableau.nLignes+1; nPosition++)
    {
        WorkingTableau = DecaleTabTriParInsertion(WorkingTableau, nPosition, nNumCol);
    }
    return WorkingTableau;
}

//******************************************************************************

struct Tableau EchangeTabTriParSelection(struct Tableau MonTableau, int nI, int nJ, int nIndiceCol)
{
    struct Tableau WorkingTableau = MonTableau;
    string sTamponCellule = Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nI);
    string sTamponLigne = Tab_GetTabLigneComplete(WorkingTableau, nI);

    WorkingTableau = Tab_ReplaceLigne(WorkingTableau, (Tab_GetTabLigneComplete(WorkingTableau, nJ)),(nI));
    WorkingTableau = Tab_ReplaceLigne(WorkingTableau, sTamponLigne, nJ);

    return WorkingTableau;
}
//******************************************************************************

struct Tableau PlusPetitTabTriParSelection(struct Tableau MonTableau, int nPd, int nN, int nIndiceCol)
{
    struct Tableau WorkingTableau = MonTableau;

    int nI;
    int nPp = nPd;

    for(nI = nPd+1; nI < nN; nI++)
        {
            if ( StringToInt(Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nI)) < StringToInt(Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nPp)) )
            {
                nPp = nI;
            }
        }

    WorkingTableau = EchangeTabTriParSelection(WorkingTableau, nPp, nPd, nIndiceCol);

    return WorkingTableau;
}
//******************************************************************************

struct Tableau Tab_TrieTableauParSelection(struct Tableau MonTableau, int nNumCol)
{
    struct Tableau WorkingTableau = MonTableau;

    int nPd;
    int nN = WorkingTableau.nLignes+1;

    for(nPd = 1; nPd < (nN-1); nPd++)
    {
        WorkingTableau = PlusPetitTabTriParSelection(WorkingTableau, nPd, nN, nNumCol);
    }

    return WorkingTableau;
}

//******************************************************************************

void SetLocalTableau(object oObject, string sVarName, struct Tableau MonTableau)
{
    string sDataVarName = sVarName + "String";                        //Pour sData
    string sLignesVarName = sVarName + "Lignes";                      //Pour sLignes
    string sColVarName = sVarName + "Col";                            //Pour sCol
    string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule";  //Taille maxi de chaque cellule
    string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

    SetLocalString(oObject, sDataVarName, MonTableau.sData);
    SetLocalInt(oObject, sLignesVarName, MonTableau.nLignes);
    SetLocalInt(oObject, sColVarName, MonTableau.nCol);
    SetLocalInt(oObject, sTailleMaxCelluleVarName, MonTableau.nTailleMaxCellule);
    SetLocalString(oObject, sCaractereToCompleteVarName, MonTableau.sCaractereToComplete);

}

//******************************************************************************

struct Tableau GetLocalTableau(object oObject, string sVarName)
{
    struct Tableau MonTableau;
    string sDataVarName = sVarName + "String";      //Pour sData
    string sLignesVarName = sVarName + "Lignes";    //Pour sLignes
    string sColVarName = sVarName + "Col";          //Pour sCol
    string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule";  //Taille maxi de chaque cellule
    string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

    MonTableau = Tab_CreateTableau(GetLocalString(oObject, sDataVarName),
                                  GetLocalInt(oObject, sColVarName),
                                  GetLocalInt(oObject, sLignesVarName),
                                  GetLocalInt(oObject, sTailleMaxCelluleVarName),
                                  GetLocalString(oObject, sCaractereToCompleteVarName));

    return MonTableau;
}

//******************************************************************************

void DeleteLocalTableau(object oObject, string sVarName)
{
    string sDataVarName = sVarName + "String";      //Pour sData
    string sLignesVarName = sVarName + "Lignes";    //Pour sLignes
    string sColVarName = sVarName + "Col";          //Pour sCol
    string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule";  //Taille maxi de chaque cellule
    string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

    DeleteLocalString(oObject, sDataVarName);
    DeleteLocalInt(oObject, sLignesVarName);
    DeleteLocalInt(oObject, sColVarName);
    DeleteLocalInt(oObject, sTailleMaxCelluleVarName);
    DeleteLocalString(oObject, sCaractereToCompleteVarName);
}

//******************************************************************************

//void main(){}