//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project
//
//File: testing/testadapter/uni/unicodingstate.cpp
//
//Version: $Revision: 1.8 $
//
//State: $State: Exp $
//
//Date: $Date: 1999/01/21 13:06:50 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Jussi Turunen
//
//Description:
//      See corresponding header file.
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//
//Licence:
//
//
//History: 

#include <typeinfo>
#include <string>

#include "pf/protocol.h"
#include "pf/frame.h"
#include "pf/debug.h"
#include "pf/error.h"
#include "iface/uaalif/uaaldownprimitives.h"
#include "testing/testadapter/adapter/taprimitives.h"

#include "unicoderstrings.h"
#include "unipducoder.h"
#include "unicodingprotocol.h"
#include "unicodingstate.h"


uniCodingState *uniCodingState :: _only = 0;

uniCodingState *uniCodingState :: instance(void)
{
    if (_only == 0)
    {
        _only = new uniCodingState();
    }
    
    return _only;
}

uniCodingState :: uniCodingState(void)
    : pfState(),
      taInputs(),
      uaalUpInputs()
{
    return;
}

uniCodingState :: ~uniCodingState(void)
{
    return;
}

void uniCodingState :: taMessengerAct(taMessenger *messenger_,
                                      pfProtocol *protocol_)
{
    // taMessenger is encoded according to it's identifier.
    uniCodingProtocol *protocol = dynamic_cast<uniCodingProtocol*>(protocol_);
    
    string identifier = messenger_->getIdentifier();

    // pseudokoodia
    //if (identifier == xPDU)
    // encodedFrame = coder.encode(messenger_.getData());
    // uaalDATAreq *message = new uaalDATAreq;
    // message->setMessageUnit(encodedFrame);
    // sendUNITdatareq();
    //else if (identifier == AALyprim)
    // Yprim = new Yprim()
    // sendYprim()

    if (identifier.compare("$OES_START_OF_CASE") == 0)
    {
        pfFrame nameFrame;
        string nameString = messenger_->getStringFieldValue("$OES_NAME_OF_CASE");
        debugString("TCN sent", nameString);
        for (int i = nameString.length() - 1; i >= 0; --i)
        {
            nameFrame.putFirst(nameString.at(i));
        }
        debugFrame("TCN sent", nameFrame);
        uaalUNITDATAreq *message = new uaalUNITDATAreq();
        message->setMessageUnit(nameFrame);
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_EST_CONFStr) == 0)
    {
        uaalESTABLISHconf *message = new uaalESTABLISHconf();
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_EST_REQStr) == 0)
    {
        uaalESTABLISHreq *message = new uaalESTABLISHreq();
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_EST_INDStr) == 0)
    {
        uaalESTABLISHind *message = new uaalESTABLISHind();
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_REL_CONFStr) == 0)
    {
        uaalRELEASEconf *message = new uaalRELEASEconf();
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_REL_REQStr) == 0)
    {
        uaalRELEASEreq *message = new uaalRELEASEreq();
        protocol->toA(message);
    }
    else if (identifier.compare(AAL_REL_INDStr) == 0)
    {
        uaalRELEASEind *message = new uaalRELEASEind();
        protocol->toA(message);
    }
    else if (protocol->isValidPDUname(identifier) == 1)
    {
        pfFrame encodedFrame;
        uniPDUcoder coder;

        debugString("Encoding PDU", identifier);

        uaalDATAreq *message = new uaalDATAreq();
        encodedFrame = coder.encode(messenger_->getData());
        message->setMessageUnit(encodedFrame);
        protocol->toA(message);
    }
    else
    {
        debugString("unknown PDU", identifier);
    }
    
    return;
}

void uniCodingState :: uaalESTABLISHindAct(uaalESTABLISHind *,
                                          pfProtocol *protocol_)
{
    uniCodingProtocol *protocol = 
	dynamic_cast<uniCodingProtocol*>(protocol_);   
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);

    otMessage::SerializedMessage decodedMessage;
    decodedMessage.length(1);
    decodedMessage[0].kind = otMessage::OctetString;
    decodedMessage[0].identifier = CORBA_string_dup("MSG");
    decodedMessage[0].value = CORBA_string_dup("00");
    decodedMessage[0].number = 0;

    taMessenger *message = new taMessenger(AAL_EST_INDStr, decodedMessage);
    protocol->toB(message);
    return;
}

void uniCodingState :: uaalESTABLISHconfAct(uaalESTABLISHconf *,
                                            pfProtocol *protocol_)
{
    uniCodingProtocol *protocol = dynamic_cast<uniCodingProtocol*>(protocol_);
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);

    otMessage::SerializedMessage decodedMessage;
    decodedMessage.length(1);
    decodedMessage[0].kind = otMessage::OctetString;
    decodedMessage[0].identifier = CORBA_string_dup("MSG");
    decodedMessage[0].value = CORBA_string_dup("00");
    decodedMessage[0].number = 0;

    taMessenger *message = new taMessenger(AAL_EST_CONFStr, decodedMessage);
    protocol->toB(message);
    return;
}

void uniCodingState :: uaalRELEASEindAct(uaalRELEASEind *,
                                         pfProtocol *protocol_)
{
    uniCodingProtocol *protocol = dynamic_cast<uniCodingProtocol*>(protocol_);
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);

    otMessage::SerializedMessage decodedMessage;
    decodedMessage.length(1);
    decodedMessage[0].kind = otMessage::OctetString;
    decodedMessage[0].identifier = CORBA_string_dup("MSG");
    decodedMessage[0].value = CORBA_string_dup("00");
    decodedMessage[0].number = 0;

    taMessenger *message = new taMessenger(AAL_REL_INDStr, decodedMessage);
    protocol->toB(message);
    return;
}

void uniCodingState :: uaalRELEASEconfAct(uaalRELEASEconf *,
                                          pfProtocol *protocol_)
{
    uniCodingProtocol *protocol = dynamic_cast<uniCodingProtocol*>(protocol_);
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);

    otMessage::SerializedMessage decodedMessage;
    decodedMessage.length(1);
    decodedMessage[0].kind = otMessage::OctetString;
    decodedMessage[0].identifier = CORBA_string_dup("MSG");
    decodedMessage[0].value = CORBA_string_dup("00");
    decodedMessage[0].number = 0;

    taMessenger *message = new taMessenger(AAL_REL_CONFStr, decodedMessage);
    protocol->toB(message);
    return;
}

void uniCodingState :: uaalDATAindAct(uaalDATAind *messenger_,
                                      pfProtocol *protocol_)
{
    uniCodingProtocol *protocol = dynamic_cast<uniCodingProtocol*>(protocol_);
    THROW_IF_DYNAMIC_CAST_FAILED(protocol);
    uniPDUcoder coder;
    otMessage::SerializedMessage decodedMessage;
    decodedMessage = coder.decode(messenger_->getMessageUnit());
    taMessenger *message = new taMessenger(coder.getPDUname(),
                                           decodedMessage);
    protocol->toB(message);
    return;
}

void uniCodingState :: uaalUNITDATAindAct(uaalUNITDATAind *,
                                          pfProtocol *)
{
    return;
}