Googulator v2 - James Carson

#include <a_samp>
#include <a_http>
#include <zcmd>

#define     QUERY_CALC      0
#define     QUERY_CONV      1

new
    QueryType[ MAX_PLAYERS ]
;

public OnFilterScriptInit( )
{
    print("-----------------------------------");
    print( "Googulator by James has loaded!" );
    print("-----------------------------------");

    return 1;
}

public OnPlayerConnect( playerid )
{
    QueryType[ playerid ] = -1;
    return 1;
}

CMD:calc( playerid, params[ ] )
{
    if( !isnull( params ) )
    {
        new
            URL[ 128 ],
            ErrorLevel
        ;

        for( new i; i < strlen( params ); i++ )
        {
            switch( params[ i ] )
            {
                case 0 .. 9: continue;

                case ' ': {
                    strdel( params, i, i + 1 );
                    i--;
                }

                case 'a' .. 'z': {

                    SendClientMessage( playerid, 0xFFFFFFFF, "Error: Equation does not support variables yet." );
                    ErrorLevel = 1;
                    break;

                }

                case 'A' .. 'Z': {

                    SendClientMessage( playerid, 0xFFFFFFFF, "Error: Equation does not support variables yet." );
                    ErrorLevel = 1;
                    break;

                }
            }
        }

        if( ErrorLevel == 0 )
        {
            format( URL, sizeof( URL ), "www.google.com/ig/calculator?q=%s", str_replace( "+", "\%2B", params ) );

            QueryType[ playerid ] = QUERY_CALC;
            HTTP( playerid, HTTP_GET, URL, "", "QueryResponse");
        }
    }
    else
    {
        SendClientMessage( playerid, 0xFFFFFFFF, "Syntax: /calc [Equation]" );
    }

    return 1;
}

CMD:convert( playerid, params[ ] )
{
    new
        URL[ 128 ],
        From[ 32 ],
        To[ 32 ],
        Amount[ 32 ],
        ErrorLevel
    ;

    if( !sscanf( params, "sss", Amount, From, To ) )
    {
        for( new i; i < strlen( Amount ); i++ )
        {
            switch( Amount[ i ] )
            {
                case '0' .. '9': continue;

                case '.': continue;

                default: {

                    SendClientMessage( playerid, 0xFFFFFFFF, "Error: Amount is not a valid number." );
                    ErrorLevel = 1;
                    break;
                }
            }
        }

        if( ErrorLevel == 0 )
        {
            format( URL, sizeof( URL ), "www.google.com/ig/calculator?q=%s+%s+in+%s", Amount, From, To );

            QueryType[ playerid ] = QUERY_CONV;
            HTTP( playerid, HTTP_GET, URL, "", "QueryResponse");
        }
    }
    else
    {
        SendClientMessage( playerid, 0xFFFFFFFF, "Syntax: /convert [Amount] [From] [To]" );
    }

    return 1;
}

forward QueryResponse( playerid, response_code, rawData[ ] );
public QueryResponse( playerid, response_code, rawData[ ] )
{
    if( response_code == 200 )
    {
        new
            Data[ 6 ][ 64 ],
            Output[ 128 ]
        ;

        explode( Data, rawData, "\"" );

        if( isnull( Data[ 5 ] ) )
        {
            switch( QueryType[ playerid ] )
            {
                case QUERY_CALC: {

                    format( Output, sizeof( Output ), "Googulator: %s = %s", Data[ 1 ], Data[ 3 ] );

                }

                case QUERY_CONV: {

                    format( Output, sizeof( Output ), "Googulator: %s = %s", Data[ 1 ], Data[ 3 ] );

                }
            }

            SendClientMessage( playerid, 0xFFFFFFFF, Output );
        }
        else
        {
            if( strval( Data[ 5 ] ) == 4 )
            {
                format( Output, sizeof( Output ), "Googulator: An error occurred, Specifications: Unknown unit." );
            }
            else
            {
                format( Output, sizeof( Output ), "Googulator: An error occurred, Specifications: %s", Data[ 5 ] );
            }
            SendClientMessage( playerid, 0xFFFFFFFF, Output );
        }

        QueryType[ playerid ] = -1;

    }
    else
    {
        SendClientMessage( playerid, 0xFFFFFFFF, "Error: Unable to query google, please contact an admin." );
        print( "ERR" );
    }

    return 1;
}

stock explode(aExplode[][], const sSource[], const sDelimiter[] = " ", iVertices = sizeof aExplode, iLength = sizeof aExplode[])
{
    new
        iNode,
        iPointer,
        iPrevious = -1,
        iDelimiter = strlen(sDelimiter);

    while(iNode < iVertices)
    {
        iPointer = strfind(sSource, sDelimiter, false, iPointer);

        if(iPointer == -1)
        {
            strmid(aExplode[iNode], sSource, iPrevious, strlen(sSource), iLength);
            break;
        }
        else
        {
            strmid(aExplode[iNode], sSource, iPrevious, iPointer, iLength);
        }

        iPrevious = (iPointer += iDelimiter);
        ++iNode;
    }

    return iPrevious;
}

stock str_replace(sSearch[], sReplace[], const sSubject[], &iCount = 0)
{
    new
        iLengthTarget = strlen(sSearch),
        iLengthReplace = strlen(sReplace),
        iLengthSource = strlen(sSubject),
        iItterations = (iLengthSource - iLengthTarget) + 1;

    new
        sTemp[128],
        sReturn[256];

    strcat(sReturn, sSubject, 256);
    iCount = 0;

    for(new iIndex; iIndex < iItterations; ++iIndex)
    {
        strmid(sTemp, sReturn, iIndex, (iIndex + iLengthTarget), (iLengthTarget + 1));

        if(!strcmp(sTemp, sSearch, false))
        {
            strdel(sReturn, iIndex, (iIndex + iLengthTarget));
            strins(sReturn, sReplace, iIndex, iLengthReplace);

            iIndex += iLengthTarget;
            iCount++;
        }
    }

    return sReturn;
}

stock sscanf(string[], format[], {Float,_}:...)
{
    #if defined isnull
        if (isnull(string))
    #else
        if (string[0] == 0 || (string[0] == 1 && string[1] == 0))
    #endif
        {
            return format[0];
        }
    #pragma tabsize 4
    new
        formatPos = 0,
        stringPos = 0,
        paramPos = 2,
        paramCount = numargs(),
        delim = ' ';
    while (string[stringPos] && string[stringPos] <= ' ')
    {
        stringPos++;
    }
    while (paramPos < paramCount && string[stringPos])
    {
        switch (format[formatPos++])
        {
            case '\0':
            {
                return 0;
            }
            case 'i', 'd':
            {
                new
                    neg = 1,
                    num = 0,
                    ch = string[stringPos];
                if (ch == '-')
                {
                    neg = -1;
                    ch = string[++stringPos];
                }
                do
                {
                    stringPos++;
                    if ('0' <= ch <= '9')
                    {
                        num = (num * 10) + (ch - '0');
                    }
                    else
                    {
                        return -1;
                    }
                }
                while ((ch = string[stringPos]) > ' ' && ch != delim);
                setarg(paramPos, 0, num * neg);
            }
            case 'h', 'x':
            {
                new
                    num = 0,
                    ch = string[stringPos];
                do
                {
                    stringPos++;
                    switch (ch)
                    {
                        case 'x', 'X':
                        {
                            num = 0;
                            continue;
                        }
                        case '0' .. '9':
                        {
                            num = (num << 4) | (ch - '0');
                        }
                        case 'a' .. 'f':
                        {
                            num = (num << 4) | (ch - ('a' - 10));
                        }
                        case 'A' .. 'F':
                        {
                            num = (num << 4) | (ch - ('A' - 10));
                        }
                        default:
                        {
                            return -1;
                        }
                    }
                }
                while ((ch = string[stringPos]) > ' ' && ch != delim);
                setarg(paramPos, 0, num);
            }
            case 'c':
            {
                setarg(paramPos, 0, string[stringPos++]);
            }
            case 'f':
            {

                new changestr[16], changepos = 0, strpos = stringPos;
                while(changepos < 16 && string[strpos] && string[strpos] != delim)
                {
                    changestr[changepos++] = string[strpos++];
                    }
                changestr[changepos] = '\0';
                setarg(paramPos,0,_:floatstr(changestr));
            }
            case 'p':
            {
                delim = format[formatPos++];
                continue;
            }
            case '\'':
            {
                new
                    end = formatPos - 1,
                    ch;
                while ((ch = format[++end]) && ch != '\'') {}
                if (!ch)
                {
                    return -1;
                }
                format[end] = '\0';
                if ((ch = strfind(string, format[formatPos], false, stringPos)) == -1)
                {
                    if (format[end + 1])
                    {
                        return -1;
                    }
                    return 0;
                }
                format[end] = '\'';
                stringPos = ch + (end - formatPos);
                formatPos = end + 1;
            }
            case 'u':
            {
                new
                    end = stringPos - 1,
                    id = 0,
                    bool:num = true,
                    ch;
                while ((ch = string[++end]) && ch != delim)
                {
                    if (num)
                    {
                        if ('0' <= ch <= '9')
                        {
                            id = (id * 10) + (ch - '0');
                        }
                        else
                        {
                            num = false;
                        }
                    }
                }
                if (num && IsPlayerConnected(id))
                {
                    setarg(paramPos, 0, id);
                }
                else
                {
                    #if !defined foreach
                        #define foreach(%1,%2) for (new %2 = 0; %2 < MAX_PLAYERS; %2++) if (IsPlayerConnected(%2))
                        #define __SSCANF_FOREACH__
                    #endif
                    string[end] = '\0';
                    num = false;
                    new
                        name[MAX_PLAYER_NAME];
                    id = end - stringPos;
                    foreach (Player, playerid)
                    {
                        GetPlayerName(playerid, name, sizeof (name));
                        if (!strcmp(name, string[stringPos], true, id))
                        {
                            setarg(paramPos, 0, playerid);
                            num = true;
                            break;
                        }
                    }
                    if (!num)
                    {
                        setarg(paramPos, 0, INVALID_PLAYER_ID);
                    }
                    string[end] = ch;
                    #if defined __SSCANF_FOREACH__
                        #undef foreach
                        #undef __SSCANF_FOREACH__
                    #endif
                }
                stringPos = end;
            }
            case 's', 'z':
            {
                new
                    i = 0,
                    ch;
                if (format[formatPos])
                {
                    while ((ch = string[stringPos++]) && ch != delim)
                    {
                        setarg(paramPos, i++, ch);
                    }
                    if (!i)
                    {
                        return -1;
                    }
                }
                else
                {
                    while ((ch = string[stringPos++]))
                    {
                        setarg(paramPos, i++, ch);
                    }
                }
                stringPos--;
                setarg(paramPos, i, '\0');
            }
            default:
            {
                continue;
            }
        }
        while (string[stringPos] && string[stringPos] != delim && string[stringPos] > ' ')
        {
            stringPos++;
        }
        while (string[stringPos] && (string[stringPos] == delim || string[stringPos] <= ' '))
        {
            stringPos++;
        }
        paramPos++;
    }
    do
    {
        if ((delim = format[formatPos++]) > ' ')
        {
            if (delim == '\'')
            {
                while ((delim = format[formatPos++]) && delim != '\'') {}
            }
            else if (delim != 'z')
            {
                return delim;
            }
        }
    }
    while (delim > ' ');
    return 0;
}