/*
 * Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
 *
 * Distributable under the terms of either the Apache License (Version 2.0) or 
 * the GNU Lesser General Public License, as specified in the COPYING file.
 *
 * Changes are Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
*/
#ifndef _lucene_store_RAMDirectory_
#define _lucene_store_RAMDirectory_

#if defined(_LUCENE_PRAGMA_ONCE)
#   pragma once
#endif

#include <QtCore/QString>
#include <QtCore/QStringList>

#include "Lock.h"
#include "Directory.h"
#include "CLucene/util/VoidMap.h"
#include "CLucene/util/Arrays.h"

CL_NS_DEF(store)

class RAMFile : LUCENE_BASE
{
public:
    CL_NS(util)::CLVector<uint8_t*, CL_NS(util)::Deletor::Array<uint8_t> > buffers;
    int64_t length;
    uint64_t lastModified;

#ifdef _DEBUG
    QString filename;
#endif

    RAMFile();
    ~RAMFile();
};

class RAMIndexOutput : public BufferedIndexOutput
{
protected:
    RAMFile* file;
    int32_t pointer;
    bool deleteFile;

    // output methods: 
    void flushBuffer(const uint8_t* src, const int32_t len);

public:
    RAMIndexOutput(RAMFile* f);
    RAMIndexOutput();
    /** Construct an empty output buffer. */
    virtual ~RAMIndexOutput();

    virtual void close();

    // Random-at methods
    virtual void seek(const int64_t pos);
    int64_t length();
    /** Resets this to an empty buffer. */
    void reset();
    /** Copy the current contents of this buffer to the named output. */
    void writeTo(IndexOutput* output);
};

class RAMIndexInput : public BufferedIndexInput
{
private:
    RAMFile* file;
    int32_t pointer;
    int64_t _length;

protected:
    /** IndexInput methods */
    RAMIndexInput(const RAMIndexInput& clone);
    void readInternal(uint8_t *dest, const int32_t len);

    /** Random-at methods */
    void seekInternal(const int64_t pos);

public:
    RAMIndexInput(RAMFile* f);
    ~RAMIndexInput();
    IndexInput* clone() const;

    void close();
    int64_t length();
    QString getDirectoryType() const;
};


/**
* A memory-resident {@link Directory} implementation.
*/
class RAMDirectory : public Directory
{
    class RAMLock : public LuceneLock
    {
    private:
        RAMDirectory* directory;
        QString fname;
    public:
        RAMLock(const QString& name, RAMDirectory* dir);
        virtual ~RAMLock();
        bool obtain();
        void release();
        bool isLocked();
        virtual QString toString() const;
    };

    typedef CL_NS(util)::CLHashMap<QString, RAMFile*,
        CL_NS(util)::Compare::Qstring, CL_NS(util)::Equals::Qstring,
        CL_NS(util)::Deletor::DummyQString,
        CL_NS(util)::Deletor::Object<RAMFile> > FileMap;

protected:
    /// Removes an existing file in the directory. 
    virtual bool doDeleteFile(const QString& name);

    /**
    * Creates a new <code>RAMDirectory</code> instance from a different
    * <code>Directory</code> implementation.  This can be used to load
    * a disk-based index into memory.
    * <P>
    * This should be used only with indices that can fit into memory.
    *
    * @param dir a <code>Directory</code> value
    * @exception IOException if an error occurs
    */
    void _copyFromDir(Directory* dir, bool closeDir);
    FileMap files; // unlike the java Hashtable, FileMap is not synchronized, and all access must be protected by a lock

public:
#ifndef _CL_DISABLE_MULTITHREADING //do this so that the mutable keyword still works without mt enabled
    mutable DEFINE_MUTEX(files_mutex) // mutable: const methods must also be able to synchronize properly
#endif

    // Returns a null terminated array of strings, one for each file in the directory. 
    QStringList list() const;

    /** Constructs an empty {@link Directory}. */
    RAMDirectory();

    // Destructor - only call this if you are sure the directory
    // is not being used anymore. Otherwise use the ref-counting
    // facilities of dir->close
    virtual ~RAMDirectory();
    RAMDirectory(Directory* dir);

    /**
    * Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
    *
    * @param dir a <code>String</code> specifying the full index directory path
    */
    RAMDirectory(const QString& dir);

    /// Returns true iff the named file exists in this directory. 
    bool fileExists(const QString& name) const;

    /// Returns the time the named file was last modified. 
    int64_t fileModified(const QString& name) const;

    /// Returns the length in bytes of a file in the directory. 
    int64_t fileLength(const QString& name) const;

    /// Removes an existing file in the directory. 
    virtual void renameFile(const QString& from, const QString& to);

    /** Set the modified time of an existing file to now. */
    void touchFile(const QString& name);

    /// Creates a new, empty file in the directory with the given name.
    ///	Returns a stream writing this file. 
    virtual IndexOutput* createOutput(const QString& name);

    /// Construct a {@link Lock}.
    /// @param name the name of the lock file
    LuceneLock* makeLock(const QString& name);

    /// Returns a stream reading an existing file. 
    IndexInput* openInput(const QString& name);

    virtual void close();

    QString toString() const;

    static QString DirectoryType() { return QLatin1String("RAM"); }
    QString getDirectoryType() const { return DirectoryType(); }
};

CL_NS_END

#endif