/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <fstream>

#include <map>

#include <vector>

#include <list>

#include <string>

#include "CLucene.h"

#include "CLucene/queryParser/MultiFieldQueryParser.h"

#include "cpixtools.h"

#include "cpixexc.h"

#include "cpixidxdb.h"

#include "idxdb.h"

#include "iidxdb.h"

#include "multiidxdb.h"

#include "indevicecfg.h"

#include "idxdbmgr.h"

#include "idxdbdelta.h"

#include "common/cpixlog.h"

namespace

{

    const char VOLID_PREFIX     = '@';

    const char VOLID_DELIMITER  = ':';

    const char DOMSEL_DELIMITER = ',';

    const char APPHIERARCHY_DELIMITER = ' ';

    // TODO this is a very suspicious candidate to move to cpixtool lib,

    // like "cpixbittools.h" or something

    /**

     * Produces a bitmask for an integer type that has the highest bit

     * set. Compile time thingy, does not involve runtime cost.

     */

    template<typename INTEGER>

    struct HighestBit

    {

        enum { Value = (1 << (8*sizeof(INTEGER) - 1)) };

    };

}

namespace Cpix

{

    /*********************************************

     *

     *          IIdxDbInfo implementation

     *

     */

    void IIdxDbInfo::incRefCount()

    {

        ++refCount_;

    }

    void IIdxDbInfo::decRefCount()

    {

        if (refCount_ == 0)

            {

                THROW_CPIXEXC(PL_ERROR "Decreasing zero refcount");

            }

        --refCount_;

        if (refCount_ == 0)

            {

                if (ptr_ != NULL)

                    {

                        Impl::cl_auto_ptr<IIdxDb>

                            tmp(ptr_);

                        ptr_ = NULL;

                        // close()-ing and destroying former ptr_ is

                        // implied by cl_auto_ptr dtor

                    }

            }

    }

    int IIdxDbInfo::refCount() const

    {

        return refCount_;

    }

    IIdxDb * IIdxDbInfo::ptr() const

    {

        return ptr_;

    }

    IIdxDb * IIdxDbInfo::getPtrForUse() const

    {

        accessed();

        return ptr_;

    }

    void IIdxDbInfo::setPtr(IIdxDb * ptr)

    {

        if (ptr_ != NULL)

            {

                // at this point the current index is thrown away, any

                // rambuffers and stuff need not be properly put to

                // disk - hence brutal close

                //

                // NOTE: void brutalClose() throw(); - no-throw

                ptr_->brutalClose(); 

                delete ptr_;

                ptr_ = NULL;

            }

        ptr_ = ptr;

        accessed();

    }

    IIdxDb * IIdxDbInfo::release()

    {

        IIdxDb

            * rv = ptr_;

        ptr_ = NULL;

        return rv;

    }

    /* OBS

    void IIdxDbInfo::destroy(bool resetRefCount)

    {

        setPtr(NULL);

        if (resetRefCount)

            {

                refCount_ = 0;

            }

    }

    */

    void IIdxDbInfo::restIfIdle(long   nowSec,

                                size_t maxIdleSec)

    {

        if (ptr_ != NULL)

            {

                if ((nowSec - lastAccessedSecs_) > maxIdleSec)

                    {

                        Impl::CallCloseLogging(*ptr_);

                    }

                else

                    {

                        ptr_->doHousekeeping();

                    }

            }

    }

    IIdxDbInfo::IIdxDbInfo()

        : refCount_(0),

          ptr_(NULL),

          lastAccessedSecs_(0)

    {

        ;

    }

    long IIdxDbInfo::lastAccessedSecs() const

    {

        return lastAccessedSecs_;

    }

    void IIdxDbInfo::dbgDumpState(size_t idx) const

    {

        logTestMsg(CPIX_LL_TRACE,

                   "    o entry [%d] -> (%s, %d)",

                   idx,

                   ptr() == NULL ? "NULL" : "@?",

                   refCount());

        logTestMsg(CPIX_LL_TRACE,

                   "            (last accessed: %ld)",

                   lastAccessedSecs());

        if (ptr() != NULL)

            {

                ptr()->dbgDumpState();

            }

    }

    void IIdxDbInfo::accessed() const

    {

        lastAccessedSecs_ = Cpt::GetTimeOfDay();

    }

    /*********************************************

     *

     *          IdxDbMgr implementation

     *

     */

    // IdxDbMgr::IIdxDbToDestroy constructor

    IdxDbMgr::IIdxDbToDestroy::IIdxDbToDestroy(IIdxDb           * ptr,

                                               HousekeepCounter   housekeepCounter)

        : ptr_(ptr),

          housekeepCounter_(housekeepCounter)

    {

        ;

    }

    // IdxDbMgr proper

    void IdxDbMgr::init(InitParams & ip)    {

        if (instance_ == NULL)

            {

                instance_ = new IdxDbMgr(ip);

            }

        else

            {

                THROW_CPIXEXC(PL_ERROR "Re-initing (IdxDbMgr singleton)");

            }

    }

    IdxDbMgr * IdxDbMgr::instance()

    {

        return instance_;

    }

    bool isEmpty(std::vector<IIdxDbInfo> & idxDbs)

    {

        using namespace std;

        vector<IIdxDbInfo>::iterator

            found = find_if(idxDbs.begin(),

                            idxDbs.end(),

                            compose1(bind2nd(not_equal_to<int>(),

                                             0),

                                     mem_fun_ref(&IIdxDbInfo::refCount)));

        return found == idxDbs.end();

    }

    void IdxDbMgr::scrapAll()

    {

        using namespace Cpix;

        IdxDbMgr

            * mgr = instance();

        mgr->deleteAllScheduledIdxDbs();

        Cpt::SyncRegion

            sr(mgr->mutex_);

        // checking if IIdxDb instances are still in use (they should not be)

        if (!isEmpty(mgr->idxDbs_))

            {

                THROW_CPIXEXC("Indexes are still in use");

            }

        else if (!isEmpty(mgr->multiIdxDbs_))

            {

                THROW_CPIXEXC("(Multi) indexes are still in use");

            }

        int

            result = unlink(mgr->regFilePath_.c_str());

        if (result != 0)

            {

                THROW_CPIXEXC("Could not delete CPix reg file %s",

                              mgr->regFilePath_.c_str());

            }

        mgr->idxDbs_.clear();

        mgr->multiIdxDbs_.clear();

        mgr->qbacs_.clear();

    }

    void IdxDbMgr::shutdownAll()

    {

        delete instance_;

        instance_ = NULL;

    }

    IdxDbHndl IdxDbMgr::create(const char   * qualBaseAppClass)

    {

        using namespace std;

        using namespace Cpix;

        IdxDbHndl

            rv = 0;

        string

            qbac(qualBaseAppClass);

        Cpt::SyncRegion

            sr(mutex_);

        map<QualBaseAppClass, PathAndHndl>::iterator

            qbacIt = qbacs_.find(qbac);

        if (qbacIt == qbacs_.end())

            {

                // qbacIt should point to a meaningful entry, as a

                // previously called defineVolume should either throw

                // or make sure that the association exists

                THROW_CPIXEXC(PL_ERROR "unknown qbac '%s'",

                              qualBaseAppClass);

            }

        PathAndHndl

            pathAndHndl = qbacIt->second;

        // Any previous instance is to be thrown away

        rv = pathAndHndl.second;

        // we are re-creating the index without its refCount_ reset ...

        createIdxDbInstance(rv,

                            pathAndHndl.first.c_str(),

                            true, // re-create

                            qbac.c_str());

        idxDbs_[rv].incRefCount(); // ... we just increment it

        return rv;

    }

    bool IdxDbMgr::isQualBaseAppClass(const char * domainSelector)

    {

        if (domainSelector == NULL

            || strlen(domainSelector) == 0)

            {

                THROW_CPIXEXC("NULL or empty domain selector '%s'",

                              domainSelector);

            }

        bool

            rv = false;

        if (domainSelector[0] == VOLID_PREFIX)

            {

                const char

                    * delimiter = strchr(domainSelector,

                                         VOLID_DELIMITER);

                if (delimiter == NULL

                    || (delimiter - domainSelector) == strlen(domainSelector))

                    {

                        THROW_CPIXEXC("Garbled domain selector '%s'",

                                      domainSelector);

                    }

                rv = strchr(domainSelector, DOMSEL_DELIMITER) == NULL;

            }

        return rv;

    }

    // see comments for match().

    bool IdxDbMgr::matchAppClass(const char * appClass,

                                 const char * baseAppClass)

    {

        bool

            rv = false;

        if (strlen(appClass) == 0)

            {

                THROW_CPIXEXC("Emptry string for app class");

            }

        if (appClass[0] != VOLID_PREFIX 

            && baseAppClass[0] == VOLID_PREFIX)

            {

                // base app class is qualified, we will find the unq part

                baseAppClass = getBaseAppClassPart(baseAppClass);

            }

        rv = Cpt::issubstroforequal(appClass,

                                    baseAppClass);

        return rv;

    }

    //

    //  Things that should match

    //

    //  DOMAIN SELECTOR                   | BASE APP CLASS

    //  (what a searcher asks for)        | (what you have as physical index)

    //  ----------------------------------+----------------------------------

    //

    //

    //    (multiple volumes use case)

    //

    //  "root file"                         "@c:root file"

    //  "root file"                         "@d:root file"

    //  "@c:root file"                      "@c:root file"

    //  "@d:root file"                      "@d:root file"

    //

    //

    //    (generic/widening search use case)

    //

    //  "root"                              "@c:root file"

    //  "root"                              "@d:root file"

    //  "root"                              "@0:root msg phone sms"

    //  "root msg"                          "@0:root msg phone sms"

    //  "@c:root"                           "@c:root file"

    //  "@d:root"                           "@d:root file"

    //

    //

    //    (selecting arbitrary indexes use case)

    //

    //  "@FIN:root maps,@GBR:root maps"     "@FIN:root maps"

    //  "@FIN:root maps,@GBR:root maps"     "@GBR:root maps"

    //  "root file,root msg phone sms"      "@c:root file"

    //  "root file,root msg phone sms"      "@d:root file"

    //  "root file,root msg phone sms"      "@0:root msg phone sms"

    //  "@c:root file,root msg phone sms"   "@c:root file"

    //  "@c:root file,root msg phone sms"   "@0:root msg phone sms"

    //

    //

    //  Things that should NEVER match

    //

    //  "root file"                         "@0:root msg phone sms"

    //  "@c:root file"                      "@0:root msg phone sms"

    //  "root file"                         "@FIN:root maps"

    //  "@c:root file"                      "@FIN:root maps"

    //

    //

    //  TODO ??? UNIMPLEMENTED USE CASE: narrowing searches

    //

    //  "root file media"                   "@c:root file"  (TODO)

    //  "root file media"                   "@d:root file"  (TODO)

    //  "@c:root file media"                "@c:root file"  (TODO)

    //  "@d:root file media"                "@d:root file"  (TODO)

    //

    //    ... and in these cases search/suggest needs to implement the

    //  extra clause of " AND _appclass:"root file media".

    //

    bool IdxDbMgr::match(const char * domainSelector,

                         const char * baseAppClass)

    {

        bool

            rv = false;

        if (domainSelector == NULL)

            {

                THROW_CPIXEXC("NULL string for domain selector");

            }

        else if (strlen(domainSelector) == 0)

            {

                THROW_CPIXEXC(L"Emptry string for domain selector");

            }

        using namespace std;

        list<string>

            appClasses;

        static const char domainSelectorDelimiter[] = { DOMSEL_DELIMITER, 0};

        Cpt::splitstring(domainSelector,

                         domainSelectorDelimiter,

                         appClasses);

        list<string>::const_iterator

            i = appClasses.begin(),

            end = appClasses.end();

        for (; i != end && !rv; ++i)

            {

                rv = matchAppClass(i->c_str(),

                                   baseAppClass);

            }

        return rv;

    }