#include <konkret/konkret.h>
#include "Cura_Account.h"

#include <time.h>
#include <stdbool.h>

#include <glib.h>

#include <libuser/entity.h>
#include <libuser/user.h>

#include <cmpi/cmpidt.h>
#include <cmpi/cmpift.h>
#include <cmpi/cmpimacs.h>


#include "aux_lu.h"
#include "macros.h"
#include "globals.h"

static const CMPIBroker* _cb = NULL;

static void Cura_AccountInitialize()
{
}

static CMPIStatus Cura_AccountCleanup(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    CMPIBoolean term)
{
    CMReturn(CMPI_RC_OK);
}

static CMPIStatus Cura_AccountEnumInstanceNames(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop)
{
    return KDefaultEnumerateInstanceNames(
        _cb, mi, cc, cr, cop);
}

static CMPIStatus Cura_AccountEnumInstances(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const char** properties)
{
    Cura_Account la;
    struct lu_context *luc = NULL;
    struct lu_error *error = NULL;
    GPtrArray *accounts = NULL;
    struct lu_ent *lue = NULL;

    size_t i;
    const char *nameSpace = KNameSpace(cop);
    const char *hostname = get_system_name();
    char *uid = NULL;
    long expire;
    CMPIUint64 binTime = 0;
    CMPIStatus *rc = NULL;
    char *password = NULL;

    luc = lu_start(NULL, lu_user, NULL, NULL, lu_prompt_console_quiet, NULL, &error);
    if (!luc)
      {
        fprintf(stderr, "Error initializing: %s\n", lu_strerror(error));
        exit(1);
      }

    uid = malloc(256 * sizeof(char));
    accounts = lu_users_enumerate_full(luc, "*", &error);
    for (i = 0;  (accounts != NULL) && (i < accounts->len); i++)
      {
        lue = g_ptr_array_index(accounts, i);

        Cura_Account_Init(&la, _cb, nameSpace);
        Cura_Account_Set_CreationClassName(&la, Cura_Account_ClassName);
        Cura_Account_Set_SystemName(&la, hostname);
        Cura_Account_Set_SystemCreationClassName(&la, get_system_creation_class_name());
        Cura_Account_Set_Name(&la, aux_lu_get_str(lue, LU_USERNAME));

        Cura_Account_Init_OrganizationName(&la, 1); /* XXX */
        Cura_Account_Set_OrganizationName(&la, 0, ""); /* XXX */

        /* Need to convert long int UID to the string */
        snprintf(uid, 255, "%ld", aux_lu_get_long(lue, LU_UIDNUMBER));
        Cura_Account_Set_UserID(&la, uid);

        Cura_Account_Init_Host(&la, 1);
        Cura_Account_Set_Host(&la, 0, hostname);
        Cura_Account_Set_ElementName(&la, aux_lu_get_str(lue, LU_GECOS));
        Cura_Account_Set_HomeDirectory(&la, aux_lu_get_str(lue,
          LU_HOMEDIRECTORY));
        Cura_Account_Set_LoginShell(&la, aux_lu_get_str(lue, LU_LOGINSHELL));

        Cura_Account_Set_PasswordLastChange(&la,
          CMNewDateTimeFromBinary(_cb,
            DAYSTOMS(aux_lu_get_long(lue, LU_SHADOWLASTCHANGE)),false, rc));

        password = aux_lu_get_str(lue, LU_SHADOWPASSWORD);
        Cura_Account_Init_UserPassword(&la, 1);
        Cura_Account_Set_UserPassword(&la, 0, password);
        /* Assume all passwords (encrypted or not) are in ascii encoding */
        Cura_Account_Set_UserPasswordEncoding(&la, 2);
        if(strstr(password, ""))

        expire = aux_lu_get_long(lue, LU_SHADOWEXPIRE);
        if (expire != -1)
          {
            binTime = DAYSTOMS(expire);
            Cura_Account_Set_PasswordExpiration(&la,
                CMNewDateTimeFromBinary(_cb, binTime, false, rc));
          }
        else
          {
            Cura_Account_Null_PasswordExpiration(&la);
          }

        KReturnInstance(cr, la);
        lu_ent_free(lue);
      } /* for */
    free(uid);

    if (accounts)
      {
        g_ptr_array_free(accounts, TRUE);
      }

    lu_end(luc);

    CMReturn(CMPI_RC_OK);
}

static CMPIStatus Cura_AccountGetInstance(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const char** properties)
{
    return KDefaultGetInstance(
        _cb, mi, cc, cr, cop, properties);
}

static CMPIStatus Cura_AccountCreateInstance(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const CMPIInstance* ci)
{
    CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
}

static CMPIStatus Cura_AccountModifyInstance(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const CMPIInstance* ci,
    const char** properties)
{
    CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
}

static CMPIStatus Cura_AccountDeleteInstance(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop)
{
    CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
}

static CMPIStatus Cura_AccountExecQuery(
    CMPIInstanceMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const char* lang,
    const char* query)
{
    CMReturn(CMPI_RC_ERR_NOT_SUPPORTED);
}

CMInstanceMIStub(
    Cura_Account,
    Cura_Account,
    _cb,
    Cura_AccountInitialize())

static CMPIStatus Cura_AccountMethodCleanup(
    CMPIMethodMI* mi,
    const CMPIContext* cc,
    CMPIBoolean term)
{
    CMReturn(CMPI_RC_OK);
}

static CMPIStatus Cura_AccountInvokeMethod(
    CMPIMethodMI* mi,
    const CMPIContext* cc,
    const CMPIResult* cr,
    const CMPIObjectPath* cop,
    const char* meth,
    const CMPIArgs* in,
    CMPIArgs* out)
{
    return Cura_Account_DispatchMethod(
        _cb, mi, cc, cr, cop, meth, in, out);
}

CMMethodMIStub(
    Cura_Account,
    Cura_Account,
    _cb,
    Cura_AccountInitialize())

KUint32 Cura_Account_RequestStateChange(
    const CMPIBroker* cb,
    CMPIMethodMI* mi,
    const CMPIContext* context,
    const Cura_AccountRef* self,
    const KUint16* RequestedState,
    KRef* Job,
    const KDateTime* TimeoutPeriod,
    CMPIStatus* status)
{
    KUint32 result = KUINT32_INIT;

    KSetStatus(status, ERR_NOT_SUPPORTED);
    return result;
}

KONKRET_REGISTRATION(
    "root/cimv2",
    "Cura_Account",
    "Cura_Account",
    "instance method")