/*

 *  Ottoman_test.cpp

 *  Ottoman

 *

 *  Created by Jens Alfke on 9/11/09.

 *  Copyright 2009 Jens Alfke. All rights reserved.

 *  BSD-Licensed: See the file "LICENSE.txt" for details.

 */

#include <gtest/gtest.h>

#include "TestUtils.h"

#include "Chunk.h"

#include "Ottoman.h"

#include "VersionDictionary.h"

#include <fcntl.h>

#include <stdio.h>

using namespace Mooseyard;

TEST(Ottoman,Build) {

    ASSERT_EQ(8, sizeof(Chunk));

    ASSERT_EQ(8, sizeof(KeyValueChunk));

    time_t startTime = ::time(NULL);

    time_t createTime;

    {

        Ottoman otto;

        EXPECT_EQ((void*)NULL, otto.lastVersion());

        ASSERT_NE((void*)NULL, otto.currentVersion());

        readWords();

        for( int i=0; i<sNWords; i++) {

            Blob kv(sWords[i]);

            otto.currentVersion()->put(Key(kv),kv);

        }

        Timer t("Saving Ottoman", sNWords);

        otto.saveAs("/tmp/test.ottoman");

        VersionDictionary *last = otto.lastVersion();

        ASSERT_NE((void*)NULL, last);

        EXPECT_EQ(sNWords, last->count());

        ASSERT_NE((void*)NULL, otto.currentVersion());

        EXPECT_FALSE(otto.currentVersion()->isChanged());

        createTime = last->timestamp();

        EXPECT_GE(createTime, startTime);

        EXPECT_LE(createTime, ::time(NULL));

    }

    {

        Ottoman otto("/tmp/test.ottoman");

        VersionDictionary *last = otto.lastVersion();

        ASSERT_NE((void*)NULL, last);

        ASSERT_EQ(0, last->generation());

        ASSERT_EQ(createTime, last->timestamp());

        {

            Timer t("Reading from Ottoman", sNWords);

            EXPECT_EQ( sNWords ,  last->count() );

            for( int i=0; i<sNWords; i++) {

                Key key(sWords[i]);

                Blob value = last->get(key);

                ASSERT_TRUE(value);

                ASSERT_TRUE( value.equals(key) ) << "expected '" << key << "', got '" << value << "' (i=" << i <<")";

            }

        }

        printf("Iterating through the Ottoman...\n");

        Timer t("Iterating Ottoman", sNWords);

        int n=0;

        for( VersionDictionary::Iterator it(last); it; ++it) {

            n++;

            ASSERT_TRUE(it.key().length > 0 && it.key().length < 50);

            ASSERT_TRUE(it.key().equals(it.value()));

            ASSERT_EQ( 0, ((size_t)it.value().bytes & 0x3) );  // 4-byte aligned

        }

        ASSERT_EQ(sNWords, n);

    }

    {

        printf("Opening Ottoman...\n");

        Ottoman otto("/tmp/test.ottoman");

        OverlayDictionary *current = otto.currentVersion();

        ASSERT_TRUE(current != NULL);

        EXPECT_EQ( sNWords ,  current->count() );

        EXPECT_TRUE(current->get("asparagus").equals("asparagus"));

        current->put("animal", "AMINAL");

        current->put("growf", "growf");

        EXPECT_TRUE(current->remove("asparagus"));

        EXPECT_EQ( sNWords, current->count() );

        EXPECT_TRUE(current->get("animal").equals("AMINAL"));

        EXPECT_TRUE(current->get("growf").equals("growf"));

        EXPECT_EQ( NULL, current->get("asparagus").bytes );

        EXPECT_TRUE(!current->contains("asparagus"));

        int n=0;

        for( OverlayDictionary::Iterator it(*current); it; ++it) {

            n++;

            ASSERT_TRUE(!it.key().equals("asparagus"));

        }

        ASSERT_EQ(sNWords, n);

        printf("Saving Ottoman...\n");

        {

            Timer t("Saving Ottoman");

            otto.save();

        }

        EXPECT_EQ( sNWords, current->count() );

        EXPECT_TRUE(current->get("animal").equals("AMINAL"));

        EXPECT_TRUE(current->get("growf").equals("growf"));

        EXPECT_EQ( NULL, current->get("asparagus").bytes );

        EXPECT_TRUE(!current->contains("asparagus"));

        n=0;

        for( OverlayDictionary::Iterator it(*current); it; ++it) {

            n++;

            ASSERT_TRUE(!it.key().equals("asparagus"));

        }

        ASSERT_EQ(sNWords, n);

        EXPECT_EQ(1, otto.lastVersion()->generation());

        const VersionDictionary *prev = otto.lastVersion()->previousVersion();

        ASSERT_TRUE(prev != NULL);

        EXPECT_EQ(0, prev->generation());

        EXPECT_TRUE(prev->get("asparagus").equals("asparagus"));

        EXPECT_TRUE(prev->get("growf").equals(NULL));

    }

    {

        printf("Re-opening Ottoman...\n");

        Ottoman otto("/tmp/test.ottoman", false);

        ASSERT_EQ(NULL, otto.currentVersion());

        VersionDictionary *last = otto.lastVersion();

        ASSERT_TRUE(last != NULL);

        EXPECT_EQ(1, last->generation());

        EXPECT_GE(last->timestamp(), createTime);

        EXPECT_LE(last->timestamp(), ::time(NULL));

        EXPECT_EQ( sNWords ,  last->count() );

        EXPECT_TRUE(last->get("animal").equals("AMINAL"));

        EXPECT_TRUE(last->get("growf").equals("growf"));

        EXPECT_EQ( NULL, last->get("asparagus").bytes );

        EXPECT_TRUE(!last->contains("asparagus"));

        int n=0;

        for( VersionDictionary::Iterator it(last); it; ++it) {

            n++;

            ASSERT_TRUE(!it.key().equals("asparagus"));

        }

        ASSERT_EQ(sNWords, n);

    }

    {

        printf("Writing Ottoman to a new file...\n");

        Ottoman oldhf("/tmp/test.ottoman");

        oldhf.saveAs("/tmp/test2.ottoman");

    }

    {

        printf("Opening new file...\n");

        Ottoman otto("/tmp/test2.ottoman");

        OverlayDictionary *current = otto.currentVersion();

        ASSERT_TRUE(current != NULL);

        EXPECT_EQ( sNWords ,  current->count() );

        EXPECT_TRUE(current->get("animal").equals("AMINAL"));

        EXPECT_TRUE(current->get("growf").equals("growf"));

        EXPECT_EQ( NULL, current->get("asparagus").bytes );

        EXPECT_TRUE(!current->contains("asparagus"));

        int n=0;

        for( OverlayDictionary::Iterator it(*current); it; ++it) {

            n++;

            ASSERT_TRUE(!it.key().equals("asparagus"));

        }

        ASSERT_EQ(sNWords, n);

        printf("Iterating the chunks...\n");

        int lastType = -1;

        int count = 0;

        n = 0;

        ChunkIterator *it = otto.chunkIterator();

        for (; *it; it->next()) {

            uint16_t type = it->chunk()->type();

            if (type != lastType) {

                if (count > 0)

                    printf("%6d\n", count);

                printf("type %u ... ", type);

                lastType = type;

                count = 0;

            }

            count++;

            ASSERT_LE(type, 3);

            if (type != 0)      // don't count padding chunks

                n++;

        }

        if (count > 0)

            printf("%6d\n", count);

        printf("Iterated over %i chunks\n",n);

        EXPECT_EQ(sNWords+256+1, n);

        EXPECT_TRUE(it->atEOF());

        printf("Scavenging...\n");

        EXPECT_TRUE( otto.scavenge() );

    }

}