/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "hsStream.h"
#include "hsStlUtils.h"
#include "plNetCommonHelpers.h"
#include "pnNetCommon/plGenericVar.h"
#include "plCompression/plZlibCompress.h"
#include <algorithm>
#include <iterator>


////////////////////////////////////////////////////////////////////
#ifndef SERVER
const UInt8 plNetCoreStatsSummary::StreamVersion = 1;

plNetCoreStatsSummary::plNetCoreStatsSummary()
:fULBitsPS(0),
fDLBitsPS(0),
fULPeakBitsPS(0),
fDLPeakBitsPS(0),
fULPeakPktsPS(0),
fDLPeakPktsPS(0),
fDLDroppedPackets(0)
{
}

void plNetCoreStatsSummary::Read(hsStream* s, hsResMgr*)
{
    UInt8 streamVer;
    s->ReadSwap(&streamVer);
    hsAssert(streamVer==StreamVersion,"plNetCoreStatsSummary invalid stream version.");
    s->ReadSwap(&fULBitsPS);
    s->ReadSwap(&fDLBitsPS);
    s->ReadSwap(&fULPeakBitsPS);
    s->ReadSwap(&fDLPeakBitsPS);
    s->ReadSwap(&fULPeakPktsPS);
    s->ReadSwap(&fDLPeakPktsPS);
    s->ReadSwap(&fDLDroppedPackets);
}

void plNetCoreStatsSummary::Write(hsStream* s, hsResMgr*)
{
    s->WriteSwap(StreamVersion);
    s->WriteSwap(fULBitsPS);
    s->WriteSwap(fDLBitsPS);
    s->WriteSwap(fULPeakBitsPS);
    s->WriteSwap(fDLPeakBitsPS);
    s->WriteSwap(fULPeakPktsPS);
    s->WriteSwap(fDLPeakPktsPS);
    s->WriteSwap(fDLDroppedPackets);
}
#endif // SERVER

////////////////////////////////////////////////////////////////////

plCreatableListHelper::plCreatableListHelper()
: fCompressionThreshold( kDefaultCompressionThreshold )
, fFlags( kWantCompression )
{
}

void plCreatableListHelper::IClearItems()
{
    std::for_each( fManagedItems.begin(), fManagedItems.end(), xtl::delete_ptr() );
    fManagedItems.clear();
    fItems.clear();
}

void plCreatableListHelper::CopyFrom( const plCreatableListHelper * other, bool manageItems )
{
    IClearItems();
    fFlags = other->fFlags;
    std::copy( other->fItems.begin(), other->fItems.end(), std::inserter(fItems, fItems.begin() ) );
    fCompressionThreshold = other->fCompressionThreshold;
    fWritten = other->fWritten;
    if ( manageItems )
    {
        std::copy( other->fManagedItems.begin(), other->fManagedItems.end(), std::back_inserter( fManagedItems ) );
        other->fManagedItems.clear();   // we'll take responsibility for these.
    }
}


void plCreatableListHelper::AddItem( UInt16 id, plCreatable * item, bool manageItem )
{
    RemoveItem( id );
    fItems[id] = item;
    if ( manageItem )
        fManagedItems.push_back( item );
}

void plCreatableListHelper::AddItem( UInt16 id, const plCreatable * item, bool manageItem )
{
    AddItem( id, const_cast<plCreatable*>( item ), manageItem );
}

void plCreatableListHelper::RemoveItem( UInt16 id, bool unManageItem )
{
    plCreatable * item = GetItem( id );
    if ( !item )
        return;
    std::vector<plCreatable*>::iterator ii = std::find( fManagedItems.begin(),fManagedItems.end(), item );
    if ( ii!=fManagedItems.end() )
    {
        if ( !unManageItem )
            delete ( *ii );
        fManagedItems.erase( ii );
    }
    fItems.erase( id );
}

plCreatable * plCreatableListHelper::GetItem( UInt16 id, bool unManageItem/*=false */) const
{
    std::map<UInt16,plCreatable*>::const_iterator it=fItems.find( id );
    if ( it!=fItems.end() )
    {
        if ( unManageItem )
        {
            std::vector<plCreatable*>::iterator ii = std::find( fManagedItems.begin(),fManagedItems.end(), it->second );
            if ( ii!=fManagedItems.end() )
                fManagedItems.erase( ii );
        }
        return it->second;
    }
    return nil;
}

bool plCreatableListHelper::ItemExists( UInt16 id ) const
{
    return ( fItems.find( id )!=fItems.end() );
}

void plCreatableListHelper::AddString(UInt16 id, const char * value)
{
    plCreatableGenericValue * V = TRACKED_NEW plCreatableGenericValue();
    V->Value().SetString( (char*)value );
    AddItem( id, V, true );
}

void plCreatableListHelper::AddString( UInt16 id, std::string & value )
{
    AddString( id, value.c_str() );
}

void plCreatableListHelper::AddInt( UInt16 id, Int32 value )
{
    plCreatableGenericValue * V = TRACKED_NEW plCreatableGenericValue();
    V->Value().SetInt(value);
    AddItem( id, V, true );
}

void plCreatableListHelper::AddDouble( UInt16 id, double value )
{
    plCreatableGenericValue * V = TRACKED_NEW plCreatableGenericValue();
    V->Value().SetDouble(value);
    AddItem( id, V, true );
}

const char * plCreatableListHelper::GetString( UInt16 id )
{
    plCreatableGenericValue * V = plCreatableGenericValue::ConvertNoRef( GetItem( id ) );
    if ( !V ) return nil;
    return (const char *)V->Value();
}

Int32 plCreatableListHelper::GetInt( UInt16 id )
{
    plCreatableGenericValue * V = plCreatableGenericValue::ConvertNoRef( GetItem( id ) );
    if ( !V ) return 0;
    return (Int32)V->Value();
}

double plCreatableListHelper::GetDouble( UInt16 id )
{
    plCreatableGenericValue * V = plCreatableGenericValue::ConvertNoRef( GetItem( id ) );
    if ( !V ) return 0;
    return (double)V->Value();
}

void plCreatableListHelper::Read( hsStream* s, hsResMgr* mgr )
{
    IClearItems();

    s->LogSubStreamStart("CreatableListHelper");

    s->LogReadSwap( &fFlags, "Flags" );

    fFlags &= ~kWritten;

    UInt32 bufSz;
    s->LogReadSwap( &bufSz, "BufSz" );
    std::string buf;
    buf.resize( bufSz );

    if ( fFlags&kCompressed )
    {
        UInt32 zBufSz;
        s->LogReadSwap( &zBufSz, "Compressed BufSz" );
        std::string zBuf;
        zBuf.resize( zBufSz );
        s->LogSubStreamPushDesc("Compressed Data");
        s->Read( zBufSz, (void*)zBuf.data() );
        plZlibCompress compressor;
        UInt32 tmp;
        hsBool ans = compressor.Uncompress( (UInt8*)buf.data(), &tmp, (UInt8*)zBuf.data(), zBufSz );
        hsAssert( ans!=0, "plCreatableListHelper: Failed to uncompress buffer." );
        hsAssert( tmp==bufSz, "compression size mismatch" );
        fFlags&=~kCompressed;
        hsLogEntry( plNetApp::StaticDebugMsg( "plCreatableListHelper: uncompressed from %lu to %lu", zBufSz, bufSz ) );
    }
    else
    {
        s->LogSubStreamPushDesc("Uncompressed Data");
        s->Read( bufSz, (void*)buf.data() );
    }

    hsReadOnlyStream ram( bufSz, (void*)buf.data() );

    UInt16 nItems;
    ram.ReadSwap( &nItems );
    for ( int i=0; i<nItems; i++ )
    {
        UInt16 id;
        UInt16 classIdx;
        ram.ReadSwap( &id );
        ram.ReadSwap( &classIdx );
        plCreatable * object = plFactory::Create( classIdx );
        hsAssert( object,"plCreatableListHelper: Failed to create plCreatable object (invalid class index?)" );
        if ( object )
        {
            fManagedItems.push_back( object );
            object->Read( &ram, mgr );
            fItems[id] = object;
        }
    }
}

void plCreatableListHelper::Write( hsStream* s, hsResMgr* mgr )
{
    if ( !( fFlags&kWritten ) )
    {
        // write items to ram stream
        hsRAMStream ram;
        UInt16 nItems = fItems.size();
        ram.WriteSwap( nItems );
        for ( std::map<UInt16,plCreatable*>::iterator ii=fItems.begin(); ii!=fItems.end(); ++ii )
        {
            UInt16 id = ii->first;
            plCreatable * item = ii->second;
            UInt16 classIdx = item->ClassIndex();
            ram.WriteSwap( id );
            ram.WriteSwap( classIdx );
            item->Write( &ram, mgr );
        }

        // read ram stream into a buffer
        UInt32 bufSz = ram.GetPosition();
        ram.Rewind();
        std::string buf;
        buf.resize( bufSz );
        ram.Read( bufSz, (void*)buf.data() );

        // maybe compress the buffer
        if ( fFlags&kWantCompression && bufSz>fCompressionThreshold )
        {
            plZlibCompress compressor;
            UInt32 zBufSz;
            std::string zBuf;
            zBuf.resize( bufSz );
            hsBool ans = compressor.Compress( (UInt8*)zBuf.data(), &zBufSz, (const UInt8*)buf.data(), bufSz );
            bool compressed = ( ans && zBufSz );
            hsAssert( compressed, "plCreatableListHelper: Failed to compress buffer." );
            if ( compressed )
            {
                zBuf.resize( zBufSz );
                buf = zBuf;
                fFlags |= kCompressed;
                hsLogEntry( plNetApp::StaticDebugMsg( "plCreatableListHelper: compressed from %lu to %lu", bufSz, zBufSz ) );
            }
        }

        ram.Truncate();

        ram.WriteSwap( fFlags );
        ram.WriteSwap( bufSz );

        if ( fFlags&kCompressed )
        {
            UInt32 zBufSz = buf.size();
            ram.WriteSwap( zBufSz );
        }

        ram.Write( buf.size(), buf.data() );
        UInt32 sz = ram.GetPosition();
        ram.Rewind();

        fWritten.resize( sz );
        ram.Read( sz, (void*)fWritten.data() );

        fFlags |= kWritten;
    }

    s->Write( fWritten.size(), fWritten.data() );
}

void plCreatableListHelper::GetItemsAsVec( std::vector<plCreatable*>& out )
{
    for ( std::map<UInt16,plCreatable*>::iterator ii=fItems.begin(); ii!=fItems.end(); ++ii )
    {
        out.push_back( ii->second );
    }
}

void plCreatableListHelper::GetItems( std::map<UInt16,plCreatable*>& out )
{
    for ( std::map<UInt16,plCreatable*>::iterator ii=fItems.begin(); ii!=fItems.end(); ++ii )
    {
        out[ii->first] = ii->second;
    }
}