#ifndef _DFS_SITE_COST_CACHE_HXX__
#define _DFS_SITE_COST_CACHE_HXX__


#include <shash.h>

#include <limits.h>

class DfsSite;

//
// Minimum and maximum values for inter-site costs.
// These values were 0 and 100 once upon a tender time.
//
#define DFS_MIN_COST 0
#define DFS_MAX_COST ULONG_MAX

#define DFS_DEFAULT_SITE_COST_NUM_BUCKETS 16
#define DFS_MAX_SITE_COST_CACHES 64

//
// When we get a cost that's marked with a ValidityStatus != ERROR_SUCCESS
// this is how soon that entry will expire. If the entry is accessed again after this
// interval, we'll query DS again to see if we have better luck with it.
//
#define DFS_DEFAULT_INVALID_COST_RETRY_INTERVAL    60 * 1000

//
// This is the hash entry that maps
// a destination site to its cost.
//
typedef struct _DFS_SITE_COST_DATA {
    SHASH_HEADER  Header;
    DFSSTATUS ValidityStatus;   // to account for possible errors in Cost calculations
    ULONG AccessTime;         // For aging of individual entries. 
    ULONG Cost;                // Cost from a client site to the following destination
    DfsSite *pDestinationSite;   // The above cost only applies to this destination.
} DFS_SITE_COST_DATA, *PDFS_SITE_COST_DATA;

//
// This maps sitenames of servers to their corresponding costs.
// There is one of these tables per each unique client DfsSite.
//
class DfsSiteCostCache : public DfsGeneric
{

private:
    //
    // Hash table mapping destination sites and their corresponding costs.
    //
    PSHASH_TABLE _pSiteCostTable;  
    
public:
    
    DfsSiteCostCache( VOID ) 
    : DfsGeneric( DFS_OBJECT_TYPE_SITECOST_CACHE )
    {
        _pSiteCostTable = NULL;

    }

    ~DfsSiteCostCache( VOID )
    {
        if (_pSiteCostTable != NULL)
        {
            // we have to throw out individual entries or we'll leak.
            InvalidateCache();
            ShashTerminateHashTable( _pSiteCostTable );
            _pSiteCostTable = NULL;
        }
    }
    
    DFSSTATUS    
    Initialize( VOID );

    //
    // Retry because the entry we have doesn't have a good ValidityStatus.
    //
    inline BOOLEAN
    IsTimeToRetry( PDFS_SITE_COST_DATA pSiteData )
    {
        DWORD Interval = DFS_DEFAULT_INVALID_COST_RETRY_INTERVAL;
        
        // We should implement a staggered retry here so that we won't 
        // bombard the DS over and over. BUG: 
        
        return IsTime( pSiteData->AccessTime, Interval );
    }

    //
    // Refresh because the entry we have is just plain too old.
    //
    inline BOOLEAN
    IsTimeToRefresh( PDFS_SITE_COST_DATA pSiteData )
    {
        DWORD Interval = DfsServerGlobalData.SiteSupportRefreshInterval;

        return IsTime( pSiteData->AccessTime, Interval );
    }

    static BOOLEAN
    IsTime(
        ULONG TimeStamp,
        DWORD Interval)
    {
       DWORD TimeNow = 0;

       TimeNow = GetTickCount();

       if ((TimeNow > TimeStamp) &&
          (TimeNow - TimeStamp) > Interval)
       {
          return TRUE;
       }

       if ((TimeNow < TimeStamp) &&
          ((TimeNow - 0) + (0xFFFFFFFF - TimeStamp) > Interval))
       {
          return TRUE;
       }

       return FALSE;
    }
    
    DFSSTATUS
    GetCost ( 
        DfsSite *pDestinationSite,
        PULONG pCost);
    
    DFSSTATUS
    SetCost(
        DfsSite *pDestinationSite,
        ULONG Cost,
        DWORD ValidityStatus);
        
    DFSSTATUS
    RemoveCost(
        DfsSite *pSite);

    //
    // Given a target site and the hash structure to insert,
    // add the tuple to the table.
    //
    DFSSTATUS
    SetCostData (
        DfsSite *pDestinationSite,
        PDFS_SITE_COST_DATA pSiteCostData)
    {
        NTSTATUS NtStatus = STATUS_SUCCESS;
        DFSSTATUS Status = ERROR_SUCCESS;

        //
        // The destination site is the hash key here.
        //
        NtStatus = SHashInsertKey(_pSiteCostTable, 
                                pSiteCostData, 
                                pDestinationSite, 
                                SHASH_REPLACE_IFFOUND);

        Status = RtlNtStatusToDosError(NtStatus);
        
        return Status;
    }

    //
    // Create a DFS_SITE_COST_DATA structure that is ready to
    // get inserted in to the SiteCost Cache.
    //
    DFSSTATUS
    CreateCostData (
        DfsSite *pDestinationSite,
        ULONG Cost, 
        DFSSTATUS ValidityStatus,
        PDFS_SITE_COST_DATA *ppNewData);
        
    // Just delete the cache data entry.
    static VOID
    DfsDeallocateSiteCostData(PVOID pPointer );

    DfsSite *
    StartSiteEnumerate( SHASH_ITERATOR *pIter )
    {   
        PDFS_SITE_COST_DATA pData = NULL;
        pData = (PDFS_SITE_COST_DATA)SHashStartEnumerate( pIter, _pSiteCostTable );
        if (pData == NULL)
        {
            return NULL;
        }

        return pData->pDestinationSite;
    }

    DfsSite *
    NextSiteEnumerate( SHASH_ITERATOR *pIter )
    {
        PDFS_SITE_COST_DATA pData = NULL;
        
        pData = (PDFS_SITE_COST_DATA)SHashNextEnumerate( pIter, _pSiteCostTable );
        if (pData == NULL)
        {
            return NULL;
        }

        return pData->pDestinationSite;
    }

    VOID
    FinishSiteEnumerate(  SHASH_ITERATOR *pIter )
    {
        SHashFinishEnumerate( pIter, _pSiteCostTable);
    }
    
    // 
    VOID
    InvalidateCache( VOID );

};

//
// DfsSiteCostSupport class provides a much needed layer of indirection
// between DfsSites and the DfsSiteCostCaches the DfsSites have a one-to-one
// mapping with. Since references on DfsSites are long lived (~12hrs+), and we
// may get flooded with DfsSiteCostCaches consuming a lot of memory, we need
// to do some trimming based simply on the total number of caches sitting around.
// For that, we need this extra level of indirection. This solves races
// between trimming and lookup/inserts.
//
class DfsSiteCostSupport
{
private:
    DfsSiteCostCache    *_pCostTable;
    CRITICAL_SECTION  _SiteCostLock; 
    LONG             _InUseCount;

    // For aging of the entire cache.
    ULONG _LastAccessTime; 
    
    BOOL _CritInit;
    
    //
    // The MRU hangs off the DfsServerGlobalData, and is guarded
    // by the GlobalDataLock.
    //
    LIST_ENTRY        MruListEntry;      
    BOOLEAN          InMruList; 
    
    DfsSiteCostSupport()
    {
        _pCostTable = NULL;
        _InUseCount = 1;
        _LastAccessTime = 0;
        InitializeListHead( &MruListEntry );
        InMruList = FALSE;
        _CritInit = FALSE;
    }
    
    ULONG
    InsertInMruList(VOID);
        
    VOID
    MoveToFrontOfMruList(VOID);

    BOOLEAN
    RemoveFromMruList(VOID);

    DFSSTATUS
    PopLastTableFromMruList(
        DfsSiteCostSupport **pTableToRemove);

    ULONG
    TrimSiteCostCaches( 
        ULONG MaxCachesToTrim);
public:
    
    ~DfsSiteCostSupport()
    {
        // The in-use count is not tied to
        // the existence of this structure.
        // Rather, the references on this is implicitly the same
        // as the unique DfsSite that's pointing to this.
        // Hence, there's no need to call its Release() method here.
        // That would've happened already, and the CostTable would've already
        // gotten deleted.
        
        if(_CritInit)
        {        
           DeleteCriticalSection( &_SiteCostLock );
        }
        _LastAccessTime = ULONG_MAX; // To help debugging.
    }
    

    // Just create the critical section not the table itself.
    // Table is created upon demand because the default behavior is
    // sitecosting turned off.
    DFSSTATUS
    Initialize()
    {
        DFSSTATUS Status = ERROR_SUCCESS;
        
        _CritInit = InitializeCriticalSectionAndSpinCount( &_SiteCostLock, DFS_CRIT_SPIN_COUNT );

        if (_CritInit == FALSE)
        {
            Status = GetLastError();
            return Status;
        }
        return Status;
    }
    
    static 
    DFSSTATUS 
    DfsCreateSiteCostSupport( 
        DfsSiteCostSupport **ppSup );

    DFSSTATUS
    Acquire( 
        DfsSiteCostCache **ppCache );

    VOID
    Release( VOID );

    VOID
    MarkForDeletion( VOID );

    BOOLEAN
    IsExpired( VOID );

};



#endif