Double-O-Users

#if defined _dou_included
    #endinput
#endif
#define _dou_included

#include <a_samp>
#include <Double-O-Files_2>

/*
native RegisterUser(playerid, password[]);
native CheckUserLogin(playerid, password[]);
native LoginUser(playerid);
native StoreUserData(playerid);
native IsUserRegistered(playerid);
native IsUserLoggedIn(playerid);
native SetUserPassword(playerid, password[]);
native SetAutoLogin(playerid, bool:autologin);
native SetUVarInt(playerid, uvar[], value);
native UpdateUVarInt(playerid, uvar[], value);
native GetUVarInt(playerid, uvar[]);
native SetUVarFloat(playerid, uvar[], Float:value);
native UpdateUVarFloat(playerid, uvar[], Float:value);
native Float:GetUVarFloat(playerid, uvar[]);
native SetUVarString(playerid, uvar[], string[]);
native GetUVarString(playerid, uvar[], string[], len = sizeof string);
native DeleteUVar(playerid, uvar[]);
*/

/*
 *  Definitionen:
 *      Einfachheitshalber kann man all dass,
 *      was unten definiert einfach definieren,
 *      bevor man #include <Double-O-Users> benutzt.
 */

#if !defined USER_ACCOUNT_PATH
    #define USER_ACCOUNT_PATH       "Users\\%s.ini"
#endif

#if !defined MAX_USER_FILE
    #define MAX_USER_FILE           (MAX_UVAR_NAME)
#endif

#if !defined MAX_UVAR_STRING
    #define MAX_UVAR_STRING         (256)
#endif

#if !defined UVAR_TAG
    #define UVAR_TAG                "UVAR_"
#endif

#if !defined MAX_UVAR_NAME
    #define MAX_UVAR_NAME           (64)
#endif

#if !defined MIN_USER_PW
    #define MIN_USER_PW             (3)
#endif

#if !defined INT_DATA_SECTION
    #define INT_DATA_SECTION        "IntData"
#endif

#if !defined FLOAT_DATA_SECTION
    #define FLOAT_DATA_SECTION      "FloatData"
#endif

#if !defined STRING_DATA_SECTION
    #define STRING_DATA_SECTION     "StringData"
#endif

/*
 *  Variablen & zusätzliche Callbacks
 *      Die einzige globale Variable, welche benötigt wird,
 *      ist nicht ausserhalb dieser Include verwendbar.
 *      Die Callbacks OnUserLogin und OnUserRegister können
 *      im Gamemode oder so verwendet werden.
 */

forward OnUserLogin(playerid, bool:autologin);
forward OnUserRegister(playerid);

static stock
    bool:UserLoggedIn[MAX_PLAYERS char];

/*
 *  Callback-Hooks
 */

public OnPlayerConnect(playerid)
{
    new
        userfile[MAX_USER_FILE];

    DOF2::SetCaseSensitivity(false);

    userfile = GetUserFile(playerid);
    UserLoggedIn{playerid} = false;

    if (DOF2::FileExists(userfile))
    {
        new
            bool:autologin = DOF2::GetBool(userfile, "AutoLogin", "Settings"),
            ip[16];

        if (autologin)
        {
            GetPlayerIp(playerid, ip, sizeof ip);
            if (!strcmp(ip, DOF2::GetString(userfile, "IP", "Settings")))
                LoginUser(playerid);
        }
    }
    return CallLocalFunction("DOU_OnPlayerConnect", "i", playerid);
}

#if defined _ALS_OnPlayerConnect
    #undef OnPlayerConnect
#else
    #define _ALS_OnPlayerConnect
#endif
#define OnPlayerConnect DOU_OnPlayerConnect
forward DOU_OnPlayerConnect(playerid);

public OnPlayerDisconnect(playerid, reason)
{
    if (UserLoggedIn{playerid})
    {
        StoreUserData(playerid);
        UserLoggedIn{playerid} = false;
    }
    DOF2::Exit();
    return CallLocalFunction("DOU_OnPlayerDisconnect", "ii", playerid, reason);
}

#if defined _ALS_OnPlayerDisconnect
    #undef OnPlayerDisconnect
#else
    #define _ALS_OnPlayerDisconnect
#endif
#define OnPlayerDisconnect DOU_OnPlayerDisconnect
forward DOU_OnPlayerDisconnect(playerid, reason);

/*
 *  Funktionen
 */

static stock GetUserFile(playerid)
{
    new
        string[MAX_USER_FILE];

    GetPlayerName(playerid, string, sizeof string);
    format(string, sizeof string, USER_ACCOUNT_PATH, DOF2::udb_encode(string));
    return string;
}

stock RegisterUser(playerid, password[], bool:autologin = false)
{
    new
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);

    if (strlen(password) < MIN_USER_PW || DOF2::FileExists(userfile))
        return 0;

    new
        string[MAX_UVAR_NAME],
        day,
        month,
        year;

    DOF2::CreateFile(userfile);
    DOF2::SetInt(userfile, "PasswordHash", DOF2::num_hash(password), "Settings");
    getdate(year, month, day);
    format(string, sizeof string, "%d.%d.%d", day, month, year);
    DOF2::SetString(userfile, "RegistrationDate", string, "Settings");
    GetPlayerIp(playerid, string, sizeof string);
    DOF2::SetString(userfile, "RegistrationIP", string, "Settings");
    DOF2::SetString(userfile, "IP", string, "Settings");
    DOF2::SetBool(userfile, "AutoLogin", autologin, "Settings");
    DOF2::WriteFile();
    UserLoggedIn{playerid} = true;
    CallRemoteFunction("OnUserRegister", "i", playerid);
    return 1;
}

// Passwort überprüfen.
stock bool:CheckUserLogin(playerid, password[])
{
    new
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);

    if (!password[0] || !DOF2::FileExists(userfile))
        return false;

    return (DOF2::num_hash(password) == DOF2::GetInt(userfile, "PasswordHash", "Settings"));
}

// Spieler einloggen. Sollte erst angewendet werden, wenn Passwort mit CheckUserLogin überprüft wurde.
stock LoginUser(playerid)
{
    if (!UserLoggedIn{playerid} && LoadUserData(playerid))
    {
        new
            ip[16];

        UserLoggedIn{playerid} = true;
        GetPlayerIp(playerid, ip, sizeof ip);
        DOF2::SetString(GetUserFile(playerid), "IP", ip, "Settings");
        CallRemoteFunction("OnUserLogin", "i", playerid);
        return 1;
    }
    return 0;
}

// Unwichtig. Für dich.
OnDefaultParseFile(extraid, value[], key[], tag[], file[])
{
    #pragma unused file
    #pragma unused value

    /*
     *  Diese Funktion wird von DOF2::ParseFile aufgerufen.
     *  Da weder die Anzahl noch die Namen der zu ladenden UVars
     *  bestimmt ist, überprüft man, aus welcher Sektion ein Eintrag aus
     *  dem Userfile kommt und speichert diese dann einfach als UVar ab.
     *  Sektionen:
     *      - IntData
     *      - FloatData
     *      - StringData
     */

    if (IsPlayerConnected(extraid) && tag[0])
    {
        if (!strcmp(tag, INT_DATA_SECTION, true))
        {
            new
                varname[MAX_UVAR_NAME] = UVAR_TAG;

            strcat(varname, key);
            SetPVarInt(extraid, varname, DOF2::ParseInt());
            return 1;
        }

        if (!strcmp(tag, FLOAT_DATA_SECTION, true))
        {
            new
                varname[MAX_UVAR_NAME] = UVAR_TAG;

            strcat(varname, key);
            SetPVarFloat(extraid, varname, DOF2::ParseFloat());
            return 1;
        }

        if (!strcmp(tag, STRING_DATA_SECTION, true))
        {
            new
                varname[MAX_UVAR_NAME] = UVAR_TAG;

            strcat(varname, key);
            SetPVarString(extraid, varname, value);
            return 1;
        }
    }
    return 0;
}

// Finger weg davon.
static stock LoadUserData(playerid)
{
    new
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);

    if (!DOF2::FileExists(userfile))
        return 0;

    return DOF2::ParseFile(userfile, playerid, true);
}

// Zur Sicherheit zwischendurch abspeichern? Benutze das hier.
stock StoreUserData(playerid)
{
    if (!UserLoggedIn{playerid})
        return 0;

    new
        upperindex = GetPVarsUpperIndex(playerid),
        varname[MAX_UVAR_NAME],
        string[MAX_UVAR_STRING],
        userfile[MAX_USER_FILE],
        taglen = strlen(UVAR_TAG);

    userfile = GetUserFile(playerid);

    if (!DOF2::FileExists(userfile))
        return 0;

    for (new i = 0; i < upperindex; i++)
    {
        /*
         *  Alle PVars durchgehen, überprüfen ob der Name der PVar mit UVAR_ beginnt,
         *  falls ja, Typ der PVar bestimmen und in die entsprechende Sektion
         *  im Userfile speichern.
         */

        GetPVarNameAtIndex(playerid, i, varname, sizeof varname);
        if (!strcmp(varname, UVAR_TAG, .length = taglen))
        {
            switch (GetPVarType(playerid, varname))
            {
                case PLAYER_VARTYPE_INT:
                    DOF2::SetInt(userfile, varname[taglen], GetPVarInt(playerid, varname), INT_DATA_SECTION);

                case PLAYER_VARTYPE_FLOAT:
                    DOF2::SetFloat(userfile, varname[taglen], GetPVarFloat(playerid, varname), FLOAT_DATA_SECTION);

                case PLAYER_VARTYPE_STRING:
                {
                    GetPVarString(playerid, varname, string, sizeof string);
                    DOF2::SetString(userfile, varname[taglen], string, STRING_DATA_SECTION);
                }
            }
        }
    }

    DOF2::WriteFile();
    return 1;
}

// Ist Spieler eingeloggt?
stock bool:IsUserLoggedIn(playerid)
    return UserLoggedIn{playerid};

// Ist Spieler registriert?
stock bool:IsUserRegistered(playerid)
    return DOF2::FileExists(GetUserFile(playerid));

// Passwort ändern?
stock SetUserPassword(playerid, password[])
{
    if (!UserLoggedIn{playerid})
        return 0;

    new
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);

    if (strlen(password) < MIN_USER_PW || !DOF2::FileExists(userfile))
        return 0;

    DOF2::SetInt(userfile, "PasswordHash", DOF2::num_hash(password), "Settings");
    return 1;
}

// Autologin für Spieler einstellen.
stock SetAutoLogin(playerid, bool:autologin)
{
    if (!UserLoggedIn{playerid})
        return 0;

    new
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);

    if (!DOF2::FileExists(userfile))
        return 0;

    DOF2::SetBool(userfile, "AutoLogin", autologin, "Settings");
    return 1;
}

/*
 *  UVars:
 *      UVar anstatt PVar anwenden, falls automatisch gespeichert werden soll.
 */

stock SetUVarInt(playerid, uvar[], value)
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return SetPVarInt(playerid, varname, value);
}

// Dies rechnet einfach 'value' zum derzeitigen Wert hinzu (oder zieht ab, falls 'value' negativ).
stock UpdateUVarInt(playerid, uvar[], value)
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return SetPVarInt(playerid, varname, value + GetPVarInt(playerid, varname));
}

stock GetUVarInt(playerid, uvar[])
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return GetPVarInt(playerid, varname);
}

stock SetUVarFloat(playerid, uvar[], Float:value)
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return SetPVarFloat(playerid, varname, value);
}

// Dies rechnet einfach 'value' zum derzeitigen Wert hinzu (oder zieht ab, falls 'value' negativ).
stock UpdateUVarFloat(playerid, uvar[], Float:value)
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return SetPVarFloat(playerid, varname, value + GetPVarFloat(playerid, varname));
}

stock Float:GetUVarFloat(playerid, uvar[])
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return GetPVarFloat(playerid, varname);
}

stock SetUVarString(playerid, uvar[], string[])
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return SetPVarString(playerid, varname, string);
}

stock GetUVarString(playerid, uvar[], string[], len = sizeof string)
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG;

    strcat(varname, uvar);
    return GetPVarString(playerid, varname, string, len);
}

stock DeleteUVar(playerid, uvar[])
{
    new
        varname[MAX_UVAR_NAME] = UVAR_TAG,
        userfile[MAX_USER_FILE];

    userfile = GetUserFile(playerid);
    strcat(varname, uvar);

    if (DOF2::FileExists(userfile) && UserLoggedIn{playerid})
    {
        switch GetPVarType(playerid, varname)
        {
            case PLAYER_VARTYPE_INT:
                DOF2::Unset(userfile, uvar, INT_DATA_SECTION);

            case PLAYER_VARTYPE_FLOAT:
                DOF2::Unset(userfile, uvar, FLOAT_DATA_SECTION);

            case PLAYER_VARTYPE_STRING:
                DOF2::Unset(userfile, uvar, STRING_DATA_SECTION);
        }
    }
    return DeletePVar(playerid, varname);
}