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

/* This samples demonstartes various data types supported
 * by eXtremeDB.
 * insert() function creates an object that contains fields
 * of various types - integers, arrays, vectors, blob, string
 * see types.mco
 * erase() function deletes previously created objects one
 * by-one. Memory statistics is collected before and after
 * the objects are inserted and deleted.
 */

#include <platform.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "typesdb.h"

static const char* dbname = "TypesDb";
static const int SEGSZ = 1024 * 8000UL;
#ifndef MCO_PLATFORM_X64
    static const int PAGESIZE = 96;
#else 
    static const int PAGESIZE = 192;
#endif 

const int MAP_ADDRESS = 0x20000000;

static int obj_count = 0;

#define NUMOBJECTS 2000

void _SH_(void)
{

    char text[] = 
    {
        "\nThis samples demonstartes various data types supported\n"
            "by eXtremeDB. It creates and than deletes a number of objects\n"
            "with fields of different types - integer numbers, arrays, vectors\n"
            "and blobs. Class statistics and memory usage is displayed\n"
    };

    char text1[] = 
    {
        "Copyright (c) 2001-2007 McObject LLC. All Right Reserved.\n\n"
    };

    printf("%s\neXtremeDB runtime version %d.%d, build %d\n%s\n\nPress Enter to start", text, MCO_COMP_VER_MAJOR,
           MCO_COMP_VER_MINOR, MCO_COMP_BUILD_NUM, text1);

    getchar();

}


void showStat(mco_db_h db, uint2 class_code)
{
    MCO_RET rc = 0;
    mco_trans_h t;
    mco_class_stat_t stat;

    mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t);
    rc = mco_class_stat_get(t, class_code, &stat);
    mco_trans_commit(t);

    if (rc == MCO_S_OK)
    {
        printf("\n\tStatistics for the class with code %d:\n""\tNumber of objects:\t%ld\n"
               "\tTotal core pages used:\t%ld\n""\tTotal blob pages used:\t%ld\n""\tTotal core space used:\t%ld\n",
               class_code, stat.objects_num, stat.core_pages, stat.blob_pages, stat.core_space);
    }
}


void showMem(mco_db_h db)
{
    mco_puint totalpg, freepg;

    mco_db_free_pages(db, &freepg);
    mco_db_total_pages(db, &totalpg);

    printf("\n\tMemory Report:\n\ttotal pages=%d (%dK)\n\tfree pages=%d (%dK)\n\tused %dK\n", totalpg, totalpg*
           PAGESIZE / 1024, freepg, freepg* PAGESIZE / 1024, (totalpg - freepg)* PAGESIZE / 1024);
}


static int random_string(int len, char* str)
{
    int ind;

    for (ind = 0; ind < len; ind++)
    {
        int num = 'A' + rand() % ('Z' - 'A');
        str[ind] = (char)num;
    }
    str[len] = '\0';
    return 0;

}


static uint2 rand2(uint2 lowlimit, uint2 uplimit)
{
    int n = rand();
    return (n % (uplimit - lowlimit + 1)) + lowlimit;
}


static void get_random_string(char* to)
{
    static const char* exchange[3] = 
    {
        "NASDAQ", "AMEX", "NYSE"
    };
    strcpy(to, exchange[rand2(0, 2)]);
}


/* 
 */
static int erase(mco_db_h db)
{
    mco_cursor_t csr;
    mco_trans_h t;
    AllTypes types_obj;
    int8 u8;
    MCO_RET rc;

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

    /* initialize cursor */
    rc = AllTypes_list_cursor(t, &csr);

    if (rc != MCO_S_OK)
    {
        mco_trans_commit(t);
        return rc;
    }

    rc = mco_cursor_first(t, &csr);
    AllTypes_from_cursor(t, &csr, &types_obj);

    AllTypes_autoid_get(&types_obj, &u8);
    rc = AllTypes_delete(&types_obj);
    if (rc)
    {
        mco_trans_rollback(t);
        #ifdef MCO_CFG_QUAD_STRUCT
            printf("\nError erasing object with autoid = {%ld, %ld}\n", u8.lo, u8.hi);
        #else /* MCO_CFG_QUAD_STRUCT */
            printf("\nError erasing object with autoid = {%lld}\n", u8);
        #endif /* MCO_CFG_QUAD_STRUCT */
    }

    mco_trans_commit(t);
    //  printf("\nObject with autoid = {%ld, %ld} deleted successfully\n", u8.lo, u8.hi);
    obj_count++;

    return 0;
}


static int insert(mco_db_h db, int num)
{

    int i;
    MCO_RET rc;
    mco_trans_h t;
    AllTypes types_obj;

    char str[8];
    DynStruct ds;
    FixedStruct fs;
    time_t ltime;

    static mco_uquad u8 = 
    {
        0
    };

    rc = mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t);
    if (rc)
    {
        return rc;
    }

    rc = AllTypes_new(t, &types_obj);
    if (rc)
    {
        //printf("rc=%d\n", rc);
        goto err;
    }

    /* mco_time . This is unformatted time that corresponds
    to ANSI time_t */
    time(&ltime);
    AllTypes_time_in_put(&types_obj, (mco_time)ltime);

    /* integers */
    AllTypes_u1_put(&types_obj, (uint1)num);
    AllTypes_u2_put(&types_obj, (uint2)num);
    AllTypes_u4_put(&types_obj, (uint4)num);

    mco_uquad_increment(&u8);
    AllTypes_u8_put(&types_obj, u8);

    /* arrays */
    for (i = 0; i < AllTypes_ds_length; i++)
    {
        AllTypes_ds_put(&types_obj, (uint2)i, &ds);
        get_random_string(str);
        DynStruct_s_put(&ds, str, (uint2)strlen(str));
    }

    for (i = 0; i < AllTypes_fs_length; i++)
    {
        AllTypes_fs_put(&types_obj, (uint2)i, &fs);

        FixedStruct_u4_put(&fs, (uint4)rand());
        FixedStruct_u8_put(&fs, u8);

    }

    for (i = 0; i < AllTypes_vint4_length; i++)
    {
        AllTypes_vint4_put(&types_obj, (uint2)i, (uint4)rand());
    }

    /* vectors */
    {
        uint2 nelem = rand2(1, 20);
        AllTypes_vs_alloc(&types_obj, nelem);
        for (i = 0; i < nelem; i++)
        {
            get_random_string(str);
            AllTypes_vs_put(&types_obj, (uint2)i, str, (uint2)strlen(str));
        }
    }

    /* blob */
    {
        char text[2000];
        random_string(sizeof(text) - 1, text);
        rc = AllTypes_blo_put(&types_obj, text, (uint4)strlen(text));
    }

    rc = mco_trans_commit(t);
    obj_count++;
    return rc;

    err: rc = mco_trans_rollback(t);
    return rc;
}


/* fatal error handler */
static void errhandler(int n)
{
    printf("\neXtremeDB runtime fatal error: %d", n);
    getchar();
    exit( - 1);
}


int main(void)
{
    MCO_RET rc;
    mco_db_h db = 0;
    int num = NUMOBJECTS;
    char* start_mem;
    mco_runtime_info_t info;

    _SH_();
    mco_get_runtime_info(&info);
    if (info.mco_shm_supported)
    {
        start_mem = (char*)MAP_ADDRESS;
    }
    else
    {
        start_mem = (char*)malloc(SEGSZ);
        if (!start_mem)
        {
            printf("Couldn't allocated memory\n");
            exit(1);
        }
    };

    /* set fatal error handler */
    mco_error_set_handler(&errhandler);

    rc = mco_runtime_start();

    rc = mco_db_open(dbname, typesdb_get_dictionary(), start_mem, SEGSZ, (uint2)PAGESIZE);

    if (rc)
    {
        printf("\nerror creating database");
        if (!info.mco_shm_supported)
        {
            free(start_mem);
        }
        exit(1);
    }

    /* connect to the database, obtain a database handle */
    mco_db_connect(dbname, &db);
    printf(
           "\nDatabase created successfully, db handle = %d\n%dK allocated for the database\nDatabase pagesize is %d bytes\n\n", db, SEGSZ / 1024, PAGESIZE);

    showStat(db, AllTypes_code);
    showMem(db);

    srand((unsigned)time(NULL));
    while (0 < num--)
    {
        /* create a new object */
        rc = insert(db, num);
        if (rc != 0)
        {
            break;
        }
    }

    showStat(db, AllTypes_code);

    num = NUMOBJECTS;
    obj_count = 0;
    /* delete all objects */
    while (0 < num--)
    {
        rc = erase(db);
        if (rc != 0)
        {
            break;
        }
    }

    showStat(db, AllTypes_code);
    showMem(db);

    /* disconnect from the database, db is no longer valid */
    mco_db_disconnect(db);
    /* destroy the db */
    mco_db_close(dbname);
    mco_runtime_stop();

    if (!info.mco_shm_supported)
    {
        free(start_mem);
    }

    printf("\nPress Enter key to exit");
    getchar();
    PROG_EXIT(0);

}