/************************************************************
 *                                                          *
 * Copyright(c) 2001-2003 McObject,LLC. All Right Reserved. *
 *                                                          *
 ************************************************************/

#include "load.h"

MCO_RET mov_cursor(mco_db_h db, mco_cursor_h c, const code)
{
    mco_trans_h t;
    MCO_RET rc = 0;

    for (;;)
    {
        mco_trans_start(db, MCO_READ_ONLY, MCO_TRANS_FOREGROUND, &t);
        rc = mco_cursor_next(t, c);
        if (rc)
        {
            mco_trans_commit(t);
            break;
        }
        switch (code)
        {
            case Blobs_code:
                rc = read_blob(t, c);
                break;
            case Dynamic_code:
                rc = read_dynamic(t, c);
                break;
            case Fixed_code:
                read_fixed(t, c);
                break;
            case Idxs_code:
                rc = read_idxs(t, c);
                break;
            default:
                mco_trans_rollback(t);
                return  - 1;
        }
        mco_trans_commit(t);
        if (!SUCCESS(rc))
        {
            return rc;
        }
    }

    if (rc != MCO_S_CURSOR_END)
    {
        return rc;
    }
    else
    {
        return 0;
    }

}


MCO_RET set_cursor(mco_db_h db, mco_cursor_h c, const code)
{
    mco_trans_h t;
    MCO_RET rc = 0;

    mco_trans_start(db, MCO_READ_ONLY, MCO_TRANS_FOREGROUND, &t);

    switch (code)
    {
        case Blobs_code:
            #ifdef USE_LISTS
                rc = Blobs_list_cursor(t, c);
            #else 
                rc = Blobs_tU8_index_cursor(t, c);
            #endif 
            break;
        case Dynamic_code:
            rc = Dynamic_list_cursor(t, c);
            break;
        case Fixed_code:
            #ifdef USE_LISTS
                rc = Fixed_list_cursor(t, c);
            #else 
                rc = Fixed_tU4_index_cursor(t, c);
            #endif 
            break;
        case Idxs_code:
            #ifdef USE_LISTS
                rc = Idxs_list_cursor(t, c);
            #else 
                rc = Idxs_tIdx_index_cursor(t, c);
            #endif 
            break;
        default:
            mco_trans_rollback(t);
            return  - 1;

    }

    if (rc)
    {
        mco_trans_rollback(t);
        return rc;
    }
    rc = mco_cursor_first(t, c);
    if (rc)
    {
        // not found
        mco_trans_rollback(t);
        return rc;
    }
    switch (code)
    {
        case Blobs_code:
            rc = read_blob(t, c);
            break;
        case Dynamic_code:
            rc = read_dynamic(t, c);
            break;
        case Fixed_code:
            read_fixed(t, c);
            break;
        case Idxs_code:
            read_idxs(t, c);
            break;
        default:
            return  - 1;
    }
    mco_trans_commit(t);
    return rc;
}


MCO_RET read_idxs(mco_trans_h t, mco_cursor_h c)
{
    MCO_RET rc;
    Idxs obj;
    uint2 val, vsz;

    rc = Idxs_from_cursor(t, c, &obj);
    if (SUCCESS(rc))
    {
        int idx;
        Item item;
        char* str;
        uint4 idval;
        uint2 sz;
        dbtest_oid oid;

        rc = Idxs_oid_get(&obj, &oid);
        if (!SUCCESS(rc))
        {
            return rc;
        }
        Idxs_u2_get(&obj, &val);
        Idxs_items_size(&obj, &vsz);

        for (idx = 0; idx < vsz; idx++)
        {
            rc = Idxs_items_at(&obj, (uint2)idx, &item);
            if (!SUCCESS(rc))
            {
                return rc;
            }
            Item_id_get(&item, &idval);
            Item_name_size(&item, &sz);
            if (sz != 0)
            {
                if (NULL != (str = malloc(sz + 1)))
                {
                    rc = Item_name_get(&item, str, sz, NULL);
                    free(str);
                    if (!SUCCESS(rc))
                    {
                        return rc;
                    }
                }
            }
        }
    }
    iv++;
    return rc;
}


MCO_RET read_blob(mco_trans_h t, mco_cursor_h c)
{
    MCO_RET rc, rc1;
    Blobs blob, v_blob;
    uint2 val = 0;
    uint4 size = 0;
    char* buff = 0;

    rc = Blobs_from_cursor(t, c, &blob);
    if (SUCCESS(rc))
    {
        Blobs_num_get(&blob, &val);
        Blobs_blo_size(&blob, &size);
        if (size)
        {
            buff = malloc(size);
            if (buff)
            {
                uint4 len = 0;
                rc = Blobs_blo_get(&blob, 0, buff, size, &len);
                if (SUCCESS(rc))
                {
                    bv++;
                }
                free(buff);
            }
        }
    }

    /* verify history */

    if (info.mco_versioning_supported)
    {
        for (;;)
        {
            if (MCO_S_OK != (rc1 = Blobs_version_prev(&blob, &v_blob)))
            {
                break;
            }
            blob = v_blob;
            Blobs_blo_size(&blob, &size);
            if ((buff = malloc(size)) == 0)
            {
                break;
            }
            rc = Blobs_blo_get(&blob, 0, buff, size, NULL);
            free(buff);
            if (SUCCESS(rc))
            {
                bh++;
            }
            else
            {
                break;
            }
        };
    };

    return rc;
}


MCO_RET read_fixed(mco_trans_h t, mco_cursor_h c)
{
    MCO_RET rc;
    Fixed fixed;
    char txt[5];
    uint4 u4;
    uint2 u2;
    float f;
    dbtest_oid oid;

    rc = Fixed_from_cursor(t, c, &fixed);
    if (SUCCESS(rc))
    {

        Fixed_oid_get(&fixed, &oid);

        //printf ("OID= %ld\n", oid.seq);

        Fixed_c4_get(&fixed, txt, sizeof txt);

        Fixed_u4_get(&fixed, &u4);

        Fixed_f_get(&fixed, &f);

        rc = Fixed_u2_get(&fixed, &u2);
        if (!SUCCESS(rc))
        {
            return rc;
        }
        fv++;
    }
    return rc;
}


MCO_RET read_dynamic(mco_trans_h t, mco_cursor_h c)
{
    MCO_RET rc;
    uint2 sz, idx;
    uint4 val;
    Dynamic dyn;
    Item hItem;

    rc = Dynamic_from_cursor(t, c, &dyn);
    if (!SUCCESS(rc))
    {
        return rc;
    }

    /* read string */
    Dynamic_str_size(&dyn, &sz);
    if (sz)
    {
        uint2 len;
        char* str = malloc(sz + 1);
        if (str)
        {
            rc = Dynamic_str_get(&dyn, str, (uint2)(sz + 1), &len);
            free(str);

        }
    }
    if (!SUCCESS(rc))
    {
        return rc;
    }

    /* read vector */
    Dynamic_vu4_size(&dyn, &sz); // sz is vector size
    for (idx = 0; idx < sz; idx++)
    {
        if (MCO_S_OK != (rc = Dynamic_vu4_at(&dyn, idx, &val)))
        {
            return rc;
        }
    }

    /* optional structure */
    rc = Dynamic_item_read_handle(&dyn, &hItem);
    if (rc == MCO_S_OK)
    {
        // every other Item should be there...
        rc = Item_id_get(&hItem, &val);

        Item_name_size(&hItem, &sz);
        if (sz != 0)
        {
            uint2 len = 0;
            char* str = malloc(sz + 1);
            if (str)
            {
                rc = Item_name_get(&hItem, str, (uint2)sz, &len);
                free(str);
            }
        }

    }
    else if (rc != MCO_E_EMPTYOPTIONAL)
    {
        printf("\tfailed reading optional\n\n");
        return rc;
    }
    dv++;
    return MCO_S_OK;
}


/* 
 * We don't intend to verify the content of each object, but only
 * fields accessibility. This is to make sure that our pointer
 * conversions to file offsets and back are done correctly.
 */
int verify_db(mco_db_h db)
{

    MCO_RET rc = 0;
    mco_cursor_t c;

    //  printf("\nReading restored OIDs from Fixed\n");
    rc = set_cursor(db, &c, Fixed_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }
    rc = mov_cursor(db, &c, Fixed_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }

    rc = set_cursor(db, &c, Dynamic_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }
    rc = mov_cursor(db, &c, Dynamic_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }
    rc = set_cursor(db, &c, Blobs_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }
    rc = mov_cursor(db, &c, Blobs_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }

    rc = set_cursor(db, &c, Idxs_code);
    if (!SUCCESS(rc))
    {
        return rc;
    }
    rc = mov_cursor(db, &c, Idxs_code);

    return rc;
}