#include "PrecompiledHeader.h"

#include "utils.h"
#include "MTGDefinitions.h"
#include "Subtypes.h"

using std::vector;

int randValuesCursor = -1;
vector<int> randValues;

int loadRandValues(string s)
{
    randValues.clear();
    randValuesCursor = -1;
    while (s.size())
    {
        unsigned int value;
        size_t limiter = s.find(",");
        if (limiter != string::npos)
        {
            value = atoi(s.substr(0, limiter).c_str());
            s = s.substr(limiter + 1);
        }
        else
        {
            value = atoi(s.c_str());
            s = "";
        }
        if (value) randValues.push_back(value);
    }
    if (randValues.size()) randValuesCursor = 0;
    return 1;
}

int WRand()
{
    if (randValuesCursor == -1) return rand();
    int result = randValues[randValuesCursor];
    randValuesCursor++;
    if ((size_t) randValuesCursor >= randValues.size()) randValuesCursor = 0;
    return result;
}

int filesize(const char * filename)
{
    int file_size = 0;
#if defined (WIN32) || defined (LINUX) || defined (IOS)
    FILE * file = fopen(filename, "rb");
    if (file != NULL)
    {
        fseek(file, 0, SEEK_END);
        file_size = ftell(file);
        fclose(file);
    }

#else
    int file = sceIoOpen(filename, PSP_O_RDONLY, 0777);
    if (file > 0)
    {
        file_size = sceIoLseek(file, 0, PSP_SEEK_END);
        sceIoClose(file);
    }

#endif
    return file_size;
}

int fileExists(const char * filename)
{
    std::ifstream fichier(filename);
    if (fichier)
    {
        fichier.close();
        return 1;
    }

    std::ifstream fichier2(JGE_GET_RES(filename).c_str());
    if (fichier2)
    {
        fichier2.close();
        return 1;
    }
    return 0;
}

/*
 #ifdef LINUX

 #include <execinfo.h>
 void dumpStack()
 {
 void* buffer[50];
 int s = backtrace(buffer, 50);
 char** tab = backtrace_symbols(buffer, s);
 for (int i = 1; i < s; ++i) printf("%s\n", tab[i]);
 printf("\n");
 free(tab);
 }

 #endif
 */

/* RAM simple check functions source */

// *** FUNCTIONS ***

u32 ramAvailableLineareMax(void)
{
    u32 size, sizeblock;
    u8 *ram;

    // Init variables
    size = 0;
    sizeblock = RAM_BLOCK;

    // Check loop
    while (sizeblock)
    {
        // Increment size
        size += sizeblock;

        // Allocate ram
        ram = (u8 *) malloc(size);

        // Check allocate
        if (!(ram))
        {
            // Restore old size
            size -= sizeblock;

            // Size block / 2
            sizeblock >>= 1;
        }
        else
            free(ram);
    }

    return size;
}

u32 ramAvailable(void)
{
    u8 **ram, **temp;
    u32 size, count, x;

    // Init variables
    ram = NULL;
    size = 0;
    count = 0;

    // Check loop
    for (;;)
    {
        // Check size entries
        if (!(count % 10))
        {
            // Allocate more entries if needed
            temp = (u8**) realloc(ram, sizeof(u8 *) * (count + 10));
            if (!(temp)) break;

            // Update entries and size (size contains also size of entries)
            ram = temp;
            size += (sizeof(u8 *) * 10);
        }

        // Find max lineare size available
        x = ramAvailableLineareMax();
        if (!(x)) break;

        // Allocate ram
        ram[count] = (u8 *) malloc(x);
        if (!(ram[count])) break;

        // Update variables
        size += x;
        count++;
    }

    // Free ram
    if (ram)
    {
        for (x = 0; x < count; x++)
            free(ram[x]);
        free(ram);
    }

    return size;
}

string& trim(string &str)
{
    str = ltrim(str);
    str = rtrim(str);
    return str;
}

string& ltrim(string &str)
{
    str.erase(0, str.find_first_not_of(" \t"));
    return str;
}

string& rtrim(string &str)
{
    str.resize(str.find_last_not_of(" \t") + 1);
    return str;
}

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim))
    {
        elems.push_back(item);
    }
    return elems;
}

std::vector<std::string> split(const std::string &s, char delim)
{
    std::vector<std::string> elems;
    return split(s, delim, elems);
}

std::string wordWrap(std::string sentence, int width)
{
    std::string::iterator it = sentence.begin();

    //remember how long next word is
    int nextWordLength = 0;
    int distanceFromWidth = width;

    while (it != sentence.end())
    {
        while (*it != ' ')
        {
            nextWordLength++;
            distanceFromWidth--;

            ++it;

            // check if done
            if (it == sentence.end())
            {
                return sentence;
            }
        }

        if (nextWordLength > distanceFromWidth)
        {
            *it = '\n';
            distanceFromWidth = width;
            nextWordLength = 0;
        }

        //skip the space
        ++it;
    }

    return sentence;
}

// Given a delimited string of abilities, add the ones to the list that are "Basic"  MTG abilities
void PopulateAbilityIndexVector( list<int>& abilities, const string& abilityStringList, char delimiter )
{
    vector<string> abilitiesList = split( abilityStringList, delimiter);
    for ( vector<string>::iterator iter = abilitiesList.begin(); iter != abilitiesList.end(); ++iter)
    {
        int abilityIndex = Constants::GetBasicAbilityIndex( *iter );

        if (abilityIndex != -1)
            abilities.push_back( abilityIndex );
    }
}


void PopulateColorIndexVector( list<int>& colors, const string& colorStringList, char delimiter )
{
    vector<string> abilitiesList = split( colorStringList, delimiter);
    for ( vector<string>::iterator iter = abilitiesList.begin(); iter != abilitiesList.end(); ++iter)
    {
        for (int colorIndex = Constants::MTG_COLOR_ARTIFACT; colorIndex < Constants::MTG_NB_COLORS; ++colorIndex)
        {
            // if the text is not a basic ability but contains a valid color add it to the color vector
            if ( (Constants::GetBasicAbilityIndex( *iter ) != -1) && ((*iter).find( Constants::MTGColorStrings[ colorIndex ] ) != string::npos) )
                colors.push_back(colorIndex);
        }
    }
}

void PopulateSubtypesIndexVector( list<int>& types, const string& subTypesStringList, char delimiter)
{
    vector<string> subTypesList = split( subTypesStringList, delimiter);
    for (vector<string>::iterator it = subTypesList.begin(); it != subTypesList.end(); ++it)
    {
        string subtype = *it;
        size_t id = Subtypes::subtypesList->find( subtype );
        if ( id != string::npos )
            types.push_back(id);
    }
}