/**
 * Copyright - See the COPYRIGHT that is included with this distribution.
 * pvAccessCPP is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution.
 */

#define epicsExportSharedSymbols
#include <pv/baseChannelRequester.h>

using namespace epics::pvData;
using std::string;

namespace epics {
namespace pvAccess {

const Status BaseChannelRequester::okStatus = Status();
const Status BaseChannelRequester::badCIDStatus(Status::STATUSTYPE_ERROR, "bad channel id");
const Status BaseChannelRequester::badIOIDStatus(Status::STATUSTYPE_ERROR, "bad request id");
const Status BaseChannelRequester::noReadACLStatus(Status::STATUSTYPE_ERROR, "no read access");
const Status BaseChannelRequester::noWriteACLStatus(Status::STATUSTYPE_ERROR, "no write access");
const Status BaseChannelRequester::noProcessACLStatus(Status::STATUSTYPE_ERROR, "no process access");
const Status BaseChannelRequester::otherRequestPendingStatus(Status::STATUSTYPE_ERROR, "other request pending");
const Status BaseChannelRequester::notAChannelRequestStatus(Status::STATUSTYPE_ERROR, "not a channel request");

const int32 BaseChannelRequester::NULL_REQUEST = -1;

BaseChannelRequester::BaseChannelRequester(
    ServerContextImpl::shared_pointer const & context,
    ServerChannelImpl::shared_pointer const & channel,
    const pvAccessID ioid,
    Transport::shared_pointer const & transport) :
    _ioid(ioid),
    _transport(transport),
    _channel(channel),
    _context(context),
    _pendingRequest(BaseChannelRequester::NULL_REQUEST)
{

}

bool BaseChannelRequester::startRequest(int32 qos)
{
    Lock guard(_mutex);
    if (_pendingRequest != NULL_REQUEST)
    {
        return false;
    }
    _pendingRequest = qos;
    return true;
}

void BaseChannelRequester::stopRequest()
{
    Lock guard(_mutex);
    _pendingRequest = NULL_REQUEST;
}

int32 BaseChannelRequester::getPendingRequest()
{
    Lock guard(_mutex);
    return _pendingRequest;
}

string BaseChannelRequester::getRequesterName()
{
    std::stringstream name;
    name << typeid(*_transport).name() << "/" << _ioid;
    return name.str();
}

void BaseChannelRequester::message(std::string const & message, epics::pvData::MessageType messageType)
{
    BaseChannelRequester::message(_transport, _ioid, message, messageType);
}

void BaseChannelRequester::message(Transport::shared_pointer const & transport, const pvAccessID ioid, const string message, const MessageType messageType)
{
    TransportSender::shared_pointer sender(new BaseChannelRequesterMessageTransportSender(ioid, message, messageType));
    transport->enqueueSendRequest(sender);
}

void BaseChannelRequester::sendFailureMessage(const int8 command, Transport::shared_pointer const & transport, const pvAccessID ioid, const int8 qos, const Status status)
{
    TransportSender::shared_pointer sender(new BaseChannelRequesterFailureMessageTransportSender(command, transport, ioid, qos, status));
    transport->enqueueSendRequest(sender);
}

BaseChannelRequesterMessageTransportSender::BaseChannelRequesterMessageTransportSender(const pvAccessID ioid, const string message,const epics::pvData::MessageType messageType):
    _ioid(ioid),
    _message(message),
    _messageType(messageType)
{
}

void BaseChannelRequesterMessageTransportSender::send(ByteBuffer* buffer, TransportSendControl* control)
{
    control->startMessage((int8)18, sizeof(int32)/sizeof(int8) + 1);
    buffer->putInt(_ioid);
    buffer->putByte((int8)_messageType);
    epics::pvData::SerializeHelper::serializeString(_message, buffer, control);
}

void BaseChannelRequesterMessageTransportSender::lock()
{
    // noop
}

void BaseChannelRequesterMessageTransportSender::unlock()
{
    // noop
}

BaseChannelRequesterFailureMessageTransportSender::BaseChannelRequesterFailureMessageTransportSender(const int8 command,
        Transport::shared_pointer const & transport, const pvAccessID ioid, const int8 qos, const Status& status) :
    _command(command),
    _ioid(ioid),
    _qos(qos),
    _status(status),
    _transport(transport)
{
}

void BaseChannelRequesterFailureMessageTransportSender::send(ByteBuffer* buffer, TransportSendControl* control)
{
    control->startMessage(_command, sizeof(int32)/sizeof(int8) + 1);
    buffer->putInt(_ioid);
    buffer->put(_qos);
    _status.serialize(buffer, control);
}

void BaseChannelRequesterFailureMessageTransportSender::lock()
{
    // noop
}

void BaseChannelRequesterFailureMessageTransportSender::unlock()
{
    // noop
}


}
}