/*

 *  VersionDictionary_test.cpp

 *  Ottoman

 *

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

 *  Copyright 2009 Jens Alfke. All rights reserved.

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

 */

#define VERSIONDICTIONARY_TESTING 1

#include <gtest/gtest.h>

#include "TestUtils.h"

#include "Chunk.h"

#include "File.h"

#include "VersionDictionary.h"

#include "Hash.h"

#include <fcntl.h>

#include <stdio.h>

using namespace Mooseyard;

class OverlayVersionDictionary :public OverlayDictionary {

public:

    OverlayVersionDictionary (File *file)

    :OverlayDictionary(new VersionDictionary(file))

    { }  

    int generation() const                  {return ((VersionDictionary*)base())->generation();}

    time_t timestamp() const                {return ((VersionDictionary*)base())->timestamp();}

    void save(){

        saveAs(((VersionDictionary*)base())->file());

    }

    void saveAs (File *dstFile) {

        VersionDictionary* oldBase = (VersionDictionary*) base();

        revertTo( ((VersionDictionary*)base())->_appendAndOpen(overlay(), dstFile, baseReplaced()) );

        delete oldBase;

    }

};

TEST(File,HasPath) {

    {

        File f("/tmp/jubba", O_RDWR | O_CREAT | O_TRUNC);

        f.write("howdy");

    }

    {

        File f("/tmp/jubba", O_RDWR);

        EXPECT_TRUE(f.hasPath("/tmp/jubba"));

        File::unlink("/tmp/jubba");

        EXPECT_FALSE(f.hasPath("/tmp/jubba"));

        File f2("/tmp/jubba", O_RDWR | O_CREAT | O_TRUNC);

        f2.write("howdy");

        f2.flush();

        EXPECT_FALSE(f.hasPath("/tmp/jubba"));

        EXPECT_TRUE(f2.hasPath("/tmp/jubba"));

    }

    File::unlink("/tmp/jubba");

}

static int TestIterate (File *file) {

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

    int lastType = -1;

    int count = 0;

    int n = 0;

    ChunkIterator it(file, 4);

    for (; it; ++it) {

        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++;

        EXPECT_LE(type, 3);

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

            n++;

    }

    if (count > 0)

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

    EXPECT_TRUE(it.atEOF());

    return n;

}    

static void TestWithWords (const int nWords) {

    ASSERT_EQ(8, sizeof(Chunk));

    ASSERT_EQ(8, sizeof(KeyValueChunk));

    printf("Building dictionary of %i words...\n", nWords);

    readWords();

    HashDictionary dict;

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

        Blob kv(sWords[i]);

        dict.put(Key(kv),kv);

    }

    time_t startTime = ::time(NULL);

    time_t createTime;

    {

        File file("/tmp/hashfiletest", O_RDWR | O_CREAT | O_TRUNC);

        VersionDictionary *hf;

        {

            Timer t("Creating & writing VersionDictionary", nWords);

            file.write("Ha5h", 4);     // VersionDictionary won't write to an empty file

            hf = VersionDictionary::create(&file, &dict);

        }

        printf("File size: %llu bytes\n", file.length());

        ASSERT_TRUE(hf!=NULL);

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

        createTime = hf->timestamp();

        ASSERT_GE(createTime, startTime);

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

        delete hf;

    }

    {

        File file("/tmp/hashfiletest");

        VersionDictionary hf(&file);

        ASSERT_EQ(0, hf.generation());

        ASSERT_EQ(createTime, hf.timestamp());

        {

            Timer t("Reading from VersionDictionary", nWords);

            EXPECT_EQ( nWords ,  hf.count() );

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

                Key key(sWords[i]);

                Blob value = hf.get(key);

                ASSERT_TRUE(value);

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

            }

        }

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

        Timer t("Iterating VersionDictionary", nWords);

        int n=0;

        for( VersionDictionary::Iterator it(&hf); 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(nWords, n);

    }

    {

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

        File file("/tmp/hashfiletest", O_RDWR);

        OverlayVersionDictionary hf(&file);

        EXPECT_EQ( nWords ,  hf.count() );

        EXPECT_TRUE(hf.get("abatement").equals("abatement"));

        hf.put("abaser", "DEBASER");

        hf.put("growf", "growf");

        EXPECT_TRUE(hf.remove("abatement"));

        EXPECT_EQ( nWords, hf.count() );

        EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

        EXPECT_TRUE(hf.get("growf").equals("growf"));

        EXPECT_EQ( NULL, hf.get("abatement").bytes );

        EXPECT_TRUE(!hf.contains("abatement"));

        int n=0;

        for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

            n++;

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

        }

        ASSERT_EQ(nWords, n);

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

        {

            Timer t("Saving OverlayVersionDictionary");

            hf.save();

        }

        printf("File size: %llu bytes\n", file.length());

        EXPECT_EQ( nWords, hf.count() );

        EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

        EXPECT_TRUE(hf.get("growf").equals("growf"));

        EXPECT_EQ( NULL, hf.get("abatement").bytes );

        EXPECT_TRUE(!hf.contains("abatement"));

        n=0;

        for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

            n++;

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

        }

        ASSERT_EQ(nWords, n);

    }

    {

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

        File file("/tmp/hashfiletest");

        OverlayVersionDictionary hf(&file);

        ASSERT_EQ(1, hf.generation());

        ASSERT_GE(hf.timestamp(), createTime);

        ASSERT_LE(hf.timestamp(), ::time(NULL));

        EXPECT_EQ( nWords ,  hf.count() );

        EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

        EXPECT_TRUE(hf.get("growf").equals("growf"));

        EXPECT_EQ( NULL, hf.get("abatement").bytes );

        EXPECT_TRUE(!hf.contains("abatement"));

        int n=0;

        for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

            n++;

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

        }

        ASSERT_EQ(nWords, n);

        n = TestIterate(&file);

        EXPECT_GE(n, nWords+1+4);

        if (nWords > 1000)

            EXPECT_GE(n, nWords+256+4);

    }

    {

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

        File oldFile("/tmp/hashfiletest");

        OverlayVersionDictionary oldhf(&oldFile);

        File newFile("/tmp/hashfiletest2", O_RDWR | O_CREAT | O_TRUNC);

        newFile.write("Ha5h", 4);     // VersionDictionary won't write to an empty file

        oldhf.saveAs(&newFile);

        printf("File size: %llu bytes\n", newFile.length());

    }

    {

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

        File file("/tmp/hashfiletest2");

        OverlayVersionDictionary hf(&file);

        EXPECT_EQ( nWords ,  hf.count() );

        EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

        EXPECT_TRUE(hf.get("growf").equals("growf"));

        EXPECT_EQ( NULL, hf.get("abatement").bytes );

        EXPECT_TRUE(!hf.contains("abatement"));

        int n=0;

        for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

            n++;

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

        }

        ASSERT_EQ(nWords, n);

        n = TestIterate(&file);

        EXPECT_GE(n, nWords+1+1);

        if (nWords > 1000)

            EXPECT_EQ(nWords+256+1, n);

    }

}    

TEST(VersionDictionary,BuildSmall) {

    TestWithWords(100);

}

TEST(VersionDictionary,BuildLarge) {

    TestWithWords(sNWords);

}