/**
 * stringAux.cpp
 *
 * @author Derzu Omaia
 * @date 27/10/2009
 *
 */

#include "stringAux.h"
#include <stdlib.h>
#include <ctype.h>
#include "dprintf.h"
#include "parseRomanNumbers.h"

namespace Util {

    // UTF-8 eh formado por 2 bytes
    const unsigned char StringAux::specialUTF_8Base = 195;
    const unsigned char StringAux::specialUTF_8[]     = { 160, 161, 162, 163, 164,
                                                          168, 169, 170, 171,
                                                          172, 173, 174, 175,
                                                          178, 179, 180, 181, 182,
                                                          185, 186, 187, 188, 167,
                                                          128, 129, 130, 131, 132,
                                                          136, 137, 138, 139,
                                                          140, 141, 142, 143,
                                                          146, 147, 148, 149, 150,
                                                          153, 154, 155, 156, 135 };
    
    const unsigned char StringAux::specialISO8859_1[] = { 224, 225, 226, 227, 228,
                                                          232, 233, 234, 235,
                                                          236, 237, 238, 239,
                                                          242, 243, 244, 245, 246,
                                                          249, 250, 251, 252, 231,
                                                          192, 193, 194, 195, 196,
                                                          200, 201, 202, 203,
                                                          204, 205, 206, 207,
                                                          210, 211, 212, 213, 214,
                                                          217, 218, 219, 220, 199 };

    const unsigned char StringAux::special[] = {'�', '�', '�', '�', '�',
                                                '�', '�', '�', '�',
                                                '�', '�', '�', '�',
                                                '�', '�', '�', '�', '�',
                                                '�', '�', '�', '�', '�',
                                                '�', '�', '�', '�', '�',
                                                '�', '�', '�', '�',
                                                '�', '�', '�', '�',
                                                '�', '�', '�', '�', '�',
                                                '�', '�', '�', '�', '�'};
    
    const unsigned char StringAux::normal[] = { 'A', 'A', 'A', 'A', 'A',
                                                'E', 'E', 'E', 'E',
                                                'I', 'I', 'I', 'I',
                                                'O', 'O', 'O', 'O', 'O',
                                                'U', 'U', 'U', 'U', 'C',
                                                'A', 'A', 'A', 'A', 'A',
                                                'E', 'E', 'E', 'E',
                                                'I', 'I', 'I', 'I',
                                                'O', 'O', 'O', 'O', 'O',
                                                'U', 'U', 'U', 'U', 'C'};
    const int StringAux::sizeSpecials = 46;


    /**
     * Converte os caracteres acentuados de iso8859 para utf8
     *
     * @param texto um vetor de char
     * @return o texto da entrada convertido, e realocado.
     **/
    char * StringAux::ISO8859_1ToUTF_8(const unsigned char * text) {
        int i, j, k=0;
        bool achou;
        int len = strlen((char*)text) + 1; // +1 do \n
        char * output = (char *) malloc(len);

        // Percorre os caracteres de entrada
        for (i=0 ; i<len ; i++) {
            // Se for um caractere no padr�o utf8
            if (text[i]==specialUTF_8Base && (i<len-1)) {
                achou = false;

                // procura qual eh o caractere
                for (j=0 ; j<sizeSpecials ; j++) {
                    if (text[i+1] == specialUTF_8[j]) {
                        achou = true;
                        break;
                    }
                }

                // se achou o caractere
                if (achou) {
                    // joga na saida o equivalente ao caractere no padrao iso8859-1
                    output[k++] = specialISO8859_1[j];
                    i++; // incrementa o i, pois um caractere em utf8 ocupa dois bytes
                }
                else
                    output[k++] = text[i];
            }
            else
                output[k++] = text[i];
        }

        return output;
    }


    /**
     * Modifica para maiusculo todas as letras do vetor.
     *
     * @param input um vetor de char
     **/
    void StringAux::toUpper(unsigned char * input) {
            int size;
            bool achou;
            if (input)
                size = strlen((char*)input);
            else
                size = 0;

            //bool mostrar = false;
           // if (strcmp((char*) input, "muit�ssimo")==0 || strcmp((char*) input, "MUIT�SSIMO")==0) mostrar=true;
            //if(mostrar) DDPRINTF("Aqui em toUpper, palavra = %s\n", input);
            //DDPRINTF("Aqui em toUpper, palavra = %s\n", input);

            for (int i=0 ; i<size ; i++)
            {
                    if (isalpha(input[i])) {
                        // Deixa tudo em maiusculo
                        input[i] = toupper(input[i]);
                       // if (mostrar) DDPRINTF("isalpha = true para i = %d, palavra = %s, tam=%d\n", i, input, strlen((char*)input));
                    }
                    else
                    {
                        achou = false;
                        // Se nao for alpha, entao pode ser caractere acentuado.
                        // Espaco eh o caractere nao alpha mais comun, enta descarto logo se for espaco
                        if (input[i]>' ' && input[i]!='[' && input[i]!=']') {
                            // esse for percorre os special ate a metade, ou seja apenas os minusculos
                            for (int j=0 ; j< sizeSpecials/2 ; j++) {
                                if ((input[i])==specialISO8859_1[j]) {
                                    //if (mostrar)
                                    //    DDPRINTF("trocando %c(j=%d) por %c(%d), i = %d\n",
                                    //            input[i], j, specialISO8859_1[j+sizeSpecials/2], j+(sizeSpecials/2), i);
                                    // Se for igual substitui pelo maiusculo
                    //                printf("substituindo %d(%c), por %d(%c)\n", specialISO8859_1[j], specialISO8859_1[j], specialISO8859_1[j+sizeSpecials/2], specialISO8859_1[j+sizeSpecials/2]);
                                    input[i] = specialISO8859_1[j+sizeSpecials/2];
                                    achou = true;
                                    //if(mostrar) DDPRINTF("palavra depois de deixar acento maiusculo = %s,tam=%d\n", input,strlen((char*)input));
                                }
                            }
                    //        if (!achou)
                    //            printf("nao achei %d(%c)\n", input[i], input[i]);
                        }
                    }
            }
           // if(mostrar) DDPRINTF("Aqui em toUpper, palavraFinal = %s\n", input);
    }


    /**
     * Verifica se um vetor de char possui acento ou nao.
     *
     * @param input um vetor de char
     * @return true se input possuir acento, e falso se nao possuir.
     * 
     **/
    bool StringAux::hasAcento(char * input) {
        int size;
        if (input)
            size = strlen(input);
        else
            size = 0;

        for (int i=0 ; i<size ; i++)
        {
            if (isascii(input[i])==0) {
                return true;
            }
        }
        return false;
    }


    /**
     * Remove a acentuacao de um vetor de char.
     * Considera que o vetor de entrada esta no padrao iso8859-1.
     *
     * @param input vetor de char no formato iso8859-1.
     * @return o mesmo vetor da entrada, sendo que com os caracteres acentuaveis
     * substituidos pelos equivalentes nao acentudados.
     **/
    unsigned char * StringAux::removeAcentuacao(unsigned char * input) {
        int size = strlen((char *)input);

        for (int i=0 ; i<size ; i++)
            for (int j=0; j<sizeSpecials ; j++) {
                // troca um caractere especial por um normal
                //printf("(%c)%x - >%x<\n", input[i], input[i], special[j]);
                if (input[i]==specialISO8859_1[j]) {
                    //DDPRINTF("Trocando caractere especial %c por %c\n", input[i], (char)normal[j]);
                    //input[i] = normal[j];
                    input[i] = (char)normal[j];
                }
            }

        return input;
    }


    void StringAux::normaliza(char * input) {
            toUpper((unsigned char *)input);
    }



    /**
     * Verifica se um vetor de char esta representando um numero romano.
     *
     * @param token um vetor de char
     * @return true se token estiver representando um numero romano, e falso se nao
     * for uma representacao de numeros romanos.
     * @see isArabicNumber
     **/
    bool StringAux::isRomanNumber(char * token) {
        bool achou;
        const char * romans = "IVXLCDM";

        for (int i=0 ; ; i++) {
            if (token[i]=='\0') break;
            achou = false;
            for (int j=0 ; ; j++) {
                if (romans[j]=='\0') break;
                if (token[i]==romans[j]) {
                    achou = true;
                    break;
                }
            }
            if (!achou)
                return false;
        }

        return true;
    }

    
    /**
     * Verifica se um vetor de char esta representando um numero arabico.
     *
     * @param token um vetor de char
     * @return true se token estiver representando um numero arabico, e falso se nao
     * for uma representacao de numeros arabicos.
     * @see isRomanNumber
     **/
    bool StringAux::isArabicNumber(char * token) {
        bool number = true;

        for (int i=0 ; ; i++) {
            if (token[i]=='\0') break;
            if (!(isdigit(token[i]) || token[i]==',' || token[i]=='.'))
                return false;
        }

        return number;
    }



    /**
     * Verifica se um vetor de char possui um determinado caractere.
     *
     * @param palavra um vetor de char
     * @param caractere o caractere que deseja-se encontrar
     * @return true se palavra possuir caractere, e falso se nao possuir.
     **/
    bool StringAux::hasCaracter(const char * palavra, char caractere) {
        for (int i=0 ; ; i++) {
            if (palavra[i]=='\0') break;
            if (palavra[i]==caractere)
                return true;
        }

        return false;
    }



    /**
     * Verifica a quantidade de vezes que determinado caractere ocorre na string
     *
     * @param palavra um vetor de char
     * @param caractere o caractere que deseja-se procurar
     * @return quantidade de vezes que o caractere ocorreu.
     **/
    int StringAux::getQuantCaracter(const char * palavra, char caractere) {
        int cont = 0;
        for (int i=0 ; ; i++) {
            if (palavra[i]=='\0') break;
            if (palavra[i]==caractere)
                cont++;
        }

        return cont;
    }


    /**
     * Substitui todos os caracteres 'origem' de um vetor pelo caractere 'destino'.
     *
     * @param palavra um vetor de char
     * @param origem o caractere que deseja-se substituir
     * @param destino o caractere pelo qual origem sera substituida.
     **/
    void StringAux::replaceAll(char * palavra, char origem, char destino) {
        for (int i=0 ; ; i++) {
            if (palavra[i]=='\0') break;
            if (palavra[i]==origem)
                palavra[i]=destino;
        }
    }


    char * StringAux::clone(const char * input) {
            char * output = NULL;

            if (input) {
                int length = strlen(input);

                output = (char*) malloc(length + 1);
                memcpy(output, input, length + 1);
            }

            return output;
    }


    char * StringAux::cloneRemovingFinalSpace(const char * input) {
        char * output = NULL;
        int length;

        if (input) {
            length = strlen(input);
            output = (char*) malloc(length + 1);
            memcpy(output, input, length + 1);

            // remove o espaco do inicio
            while (output[0]==' ') {
                shiftEsquerda(output, 1);
                length--;
            }

            // remove o espaco em branco que por acaso tenha no final do string
            for (int i=length-1; i>0 ; i--)
                if (output[i]==' ')
                    output[i]='\0';
                else
                    break;
        }

        return output;
    }

    void StringAux::shiftEsquerda(char * input, int offset) {
        int len = strlen(input);

        //DDPRINTF("antes _%s_\n", input);

        for (int i=0; i<len-offset ; i++)
            input[i] = input[i+offset];
        input[len-offset]='\0';

        //DDPRINTF("depoi _%s_\n", input);
        //getchar();
    }


    /**
     * Ler o texto em portugues de um arquivo
     *
     */
    char * StringAux::readFile(const char * path) {
            FILE * finput = NULL;
            int size;
            char * text = NULL;

            if ((finput = fopen(path, "r"))<=0) {
                    DDDPRINTF("erro abrindo %s", path);
                    return NULL;
            }
            fseek(finput, 0, SEEK_END);
            size = ftell(finput);

    //DDDPRINTF("tamanho input %d\n", size);

            text = (char *) malloc(sizeof(char)*size+1);
            fseek(finput, 0, SEEK_SET);
            fread(text, 1, size, finput);
            fclose(finput);
            text[size] = '\0';

            return text;
    }



    /**
     * Retorna o ultimo indice do caracetere a ser procurado na frase.
     *
     * @param frase a frase onde sera procurado o caractere, deve ser diferente de nulo, se for vai quebrar.
     * @param caracetere caractere a ser procurado.
     *
     * @return retorna o ultimo indice do caracetere a ser procurado na frase. Retorna -1 se nao achar.
     **/
    int StringAux::getLastIndice(const char * frase, char caractere) {
        int i = strlen(frase);
        if (i==0)
            return -1;
        // -- pois o indice i eh o '\0'
        i--;

        for ( ; i>=0 ; i--) {
            if (frase[i]==caractere)
                return i;
        }
        return -1;
    }



}