/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <activemq/commands/WireFormatInfo.h>

#include <activemq/state/CommandVisitor.h>
#include <activemq/wireformat/openwire/marshal/PrimitiveTypesMarshaller.h>
#include <decaf/lang/exceptions/NullPointerException.h>

using namespace std;
using namespace decaf;
using namespace decaf::lang;
using namespace decaf::lang::exceptions;
using namespace activemq;
using namespace activemq::exceptions;
using namespace activemq::wireformat;
using namespace activemq::wireformat::openwire;
using namespace activemq::wireformat::openwire::marshal;
using namespace activemq::commands;

////////////////////////////////////////////////////////////////////////////////
WireFormatInfo::WireFormatInfo() : BaseCommand(), magic(), marshalledProperties(), properties(), version(5) {

    // Initialize the MAGIC buffer.
    magic.push_back( 'A' );
    magic.push_back( 'c' );
    magic.push_back( 't' );
    magic.push_back( 'i' );
    magic.push_back( 'v' );
    magic.push_back( 'e' );
    magic.push_back( 'M' );
    magic.push_back( 'Q' );
}

////////////////////////////////////////////////////////////////////////////////
WireFormatInfo::~WireFormatInfo() {
}

////////////////////////////////////////////////////////////////////////////////
DataStructure* WireFormatInfo::cloneDataStructure() const {
    WireFormatInfo* wireFormatInfo = new WireFormatInfo();

    // Copy the data from the base class or classes
    wireFormatInfo->copyDataStructure( this );

    return wireFormatInfo;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::copyDataStructure( const DataStructure* src ) {

    // Copy the data of the base class or classes
    BaseCommand::copyDataStructure( src );

    const WireFormatInfo* srcPtr = dynamic_cast<const WireFormatInfo*>( src );

    if( srcPtr == NULL || src == NULL ) {
        throw NullPointerException(
            __FILE__, __LINE__,
            "WireFormatInfo::copyDataStructure - src is NULL or invalid" );
    }

    this->properties.copy( srcPtr->getProperties() );
    this->version = srcPtr->getVersion();
}

////////////////////////////////////////////////////////////////////////////////
unsigned char WireFormatInfo::getDataStructureType() const {
    return WireFormatInfo::ID_WIREFORMATINFO;
}

////////////////////////////////////////////////////////////////////////////////
std::string WireFormatInfo::toString() const {

    std::ostringstream stream;

    stream << "WireFormatInfo { "
           << "commandId = " << this->getCommandId() << ", "
           << "responseRequired = " << boolalpha << this->isResponseRequired() << ", ";

    std::vector<unsigned char> magic;
    std::vector<unsigned char> marshalledProperties;

    stream << "Magic = [ ";
    for( size_t imagic = 0; imagic < magic.size(); ++imagic ) {
        stream << magic[imagic];
        if( imagic < magic.size() - 1 ) {
            stream << ", ";
        }
    }

    stream << "Version = " << version << ", ";
    stream << "StackTraceEnabled = " << isStackTraceEnabled() << ", ";
    stream << "TcpNoDelayEnabled = " << isTcpNoDelayEnabled() << ", ";
    stream << "CacheEnabled = " << isCacheEnabled() << ", ";
    stream << "CacheSize = " << getCacheSize() << ", ";
    stream << "TightEncodingEnabled = " << isTightEncodingEnabled() << ", ";
    stream << "SizePrefixDisabled = " << isSizePrefixDisabled() << ", ";
    stream << "MaxInactivityDuration = " << getMaxInactivityDuration() << ", ";
    stream << "MaxInactivityDuration = " << getMaxInactivityDurationInitalDelay();

    stream << " }";

    return stream.str();
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::equals( const DataStructure* value ) const {

    const WireFormatInfo* wireFormatInfo =
        dynamic_cast<const WireFormatInfo*>( value );

    if( value == NULL || wireFormatInfo == NULL ) {
        return false;
    }

    if( magic != wireFormatInfo->getMagic() ) {
        return false;
    }
    if( marshalledProperties != wireFormatInfo->getMarshalledProperties() ) {
        return false;
    }
    if( !properties.equals( wireFormatInfo->properties ) ) {
        return false;
    }
    if( version != wireFormatInfo->getVersion() ) {
        return false;
    }
    if( isStackTraceEnabled() != wireFormatInfo->isStackTraceEnabled() ) {
        return false;
    }
    if( isTcpNoDelayEnabled() != wireFormatInfo->isTcpNoDelayEnabled() ) {
        return false;
    }
    if( isCacheEnabled() != wireFormatInfo->isCacheEnabled() ) {
        return false;
    }
    if( getCacheSize() != wireFormatInfo->getCacheSize() ) {
        return false;
    }
    if( isTightEncodingEnabled() != wireFormatInfo->isTightEncodingEnabled() ) {
        return false;
    }
    if( isSizePrefixDisabled() != wireFormatInfo->isSizePrefixDisabled() ) {
        return false;
    }
    if( !BaseCommand::equals( value ) ) {
        return false;
    }
    if( getMaxInactivityDuration() != wireFormatInfo->getMaxInactivityDuration() ) {
        return false;
    }
    if( getMaxInactivityDurationInitalDelay() != wireFormatInfo->getMaxInactivityDurationInitalDelay() ) {
        return false;
    }

    return true;
}

////////////////////////////////////////////////////////////////////////////////
decaf::lang::Pointer<commands::Command> WireFormatInfo::visit( activemq::state::CommandVisitor* visitor )
    throw( activemq::exceptions::ActiveMQException ) {

    return visitor->processWireFormat( this );
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isValid() const {

    if( magic.size() != std::string( "ActiveMQ" ).size() ) {
        return false;
    }

    if( magic[0] != 'A' ||
        magic[1] != 'c' ||
        magic[2] != 't' ||
        magic[3] != 'i' ||
        magic[4] != 'v' ||
        magic[5] != 'e' ||
        magic[6] != 'M' ||
        magic[7] != 'Q' ) {

        return false;
    }

    return true;
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isStackTraceEnabled() const {

    try {
        return properties.getBool( "StackTraceEnabled" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return false;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setStackTraceEnabled( bool stackTraceEnabled ) {

    try {
        properties.setBool( "StackTraceEnabled", stackTraceEnabled );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isTcpNoDelayEnabled() const {

    try {
        return properties.getBool( "TcpNoDelayEnabled" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return false;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setTcpNoDelayEnabled( bool tcpNoDelayEnabled ) {

    try {
        properties.setBool( "TcpNoDelayEnabled", tcpNoDelayEnabled );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isCacheEnabled() const {

    try {
        return false;
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return false;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setCacheEnabled( bool cacheEnabled AMQCPP_UNUSED ) {

    try {
        // Turning this on is not supported as it causes the client to not work.
        properties.setBool( "CacheEnabled", false );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isTightEncodingEnabled() const {

    try {
        return properties.getBool( "TightEncodingEnabled" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return false;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setTightEncodingEnabled( bool tightEncodingEnabled ) {

    try {
        properties.setBool( "TightEncodingEnabled", tightEncodingEnabled );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
bool WireFormatInfo::isSizePrefixDisabled() const {

    try {
        return properties.getBool( "SizePrefixDisabled" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return false;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setSizePrefixDisabled( bool sizePrefixDisabled ) {

    try {
        properties.setBool( "SizePrefixDisabled", sizePrefixDisabled );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::beforeMarshal( WireFormat* wireFormat AMQCPP_UNUSED ) {

    try{

        marshalledProperties.clear();
        if( !properties.isEmpty() ) {
            marshal::PrimitiveTypesMarshaller::marshal(
                &properties, marshalledProperties );
        }
    }
    AMQ_CATCH_RETHROW( decaf::io::IOException )
    AMQ_CATCH_EXCEPTION_CONVERT( exceptions::ActiveMQException, decaf::io::IOException )
    AMQ_CATCHALL_THROW( decaf::io::IOException )
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::afterUnmarshal( WireFormat* wireFormat AMQCPP_UNUSED ) {

    try{

        marshal::PrimitiveTypesMarshaller::unmarshal(
            &properties, marshalledProperties );
    }
    AMQ_CATCH_RETHROW( decaf::io::IOException )
    AMQ_CATCH_EXCEPTION_CONVERT( exceptions::ActiveMQException, decaf::io::IOException )
    AMQ_CATCHALL_THROW( decaf::io::IOException )
}

////////////////////////////////////////////////////////////////////////////////
long long WireFormatInfo::getMaxInactivityDuration() const {
    try {
        return properties.getLong( "MaxInactivityDuration" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return 0LL;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setMaxInactivityDuration( long long maxInactivityDuration ) {
    try {
        properties.setLong( "MaxInactivityDuration", maxInactivityDuration );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
long long WireFormatInfo::getMaxInactivityDurationInitalDelay() const {
    try {
        return properties.getLong( "MaxInactivityDurationInitalDelay" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return 0LL;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setMaxInactivityDurationInitalDelay( long long maxInactivityDurationInitalDelay ) {
    try {
        properties.setLong( "MaxInactivityDurationInitalDelay", maxInactivityDurationInitalDelay );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}

////////////////////////////////////////////////////////////////////////////////
int WireFormatInfo::getCacheSize() const {
    try {
        return properties.getInt( "CacheSize" );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()

    return 0;
}

////////////////////////////////////////////////////////////////////////////////
void WireFormatInfo::setCacheSize( int value ) {
    try {
        properties.setInt( "CacheSize", value );
    }
    AMQ_CATCH_NOTHROW( exceptions::ActiveMQException )
    AMQ_CATCHALL_NOTHROW()
}