//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / UNI
//
//File: unimode.cpp
//
//Version: $Revision: 1.12 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/12/22 14:36:58 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Jari Katajavuori
//      Sami Raatikainen (based on Revision: 1.17)
//
//Description:
//      See corresponding header file.
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//
//Licence:
//
//
//History: 

#include "unimode.h"
#include "protocol/sig/sigprotocol.h"
#include "ie/callstate.h"
#include "unistate_u0.h"
#include "unistate_u1.h"
#include "unistate_u3.h"
#include "unistate_u4.h"
#include "unistate_u6.h"
#include "unistate_u7.h"
#include "unistate_u8.h"
#include "unistate_n8.h"
#include "unistate_u9.h"
#include "unistate_u10.h"
#include "unistate_u11.h"
#include "unistate_u12.h"

//-------------------------------------------------------------------

uniUserMode *uniUserMode :: _only = 0;

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

uniUserMode :: uniUserMode(void)
    : sigMode()
{
    return;
}

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


bool uniUserMode :: isNetworkMode(void)
{
    return false;
}

void uniUserMode :: setZeroEndpointReference(
    pfMessenger *message_, 
    sigProtocol *protocol_)
{
    protocol_->setZeroEndpointReferenceAtOSide(message_);
    return;    
}

   
pfState *uniUserMode :: createNullState(void)
{
    pfState *state = uniUserNull::instance();
    setCallState(ieCallState::callState_Null);
    return state;
}

pfState *uniUserMode :: createCallInitiatedState(void)
{
    pfState *state = uniUserCallInitiated::instance();
    setCallState(ieCallState::callState_CallInitiated);
    return state;
}

pfState *uniUserMode :: createOutgoingCallProceedingState(void)
{
    pfState *state = uniUserOutgoingCallProceeding::instance();
    setCallState(ieCallState::callState_OutgoingCallProceeding);
    return state;
}

pfState *uniUserMode :: createCallDeliveredState(void)
{
    pfState *state = uniUserCallDelivered::instance();
    setCallState(ieCallState::callState_CallDelivered);
    return state;
}

pfState *uniUserMode :: createCallPresentState(void)
{
    pfState *state = uniUserCallPresent::instance();
    setCallState(ieCallState::callState_CallPresent);
    return state;
}

pfState *uniUserMode :: createCallReceivedState(void)
{
    pfState *state = uniUserCallReceived::instance();
    setCallState(ieCallState::callState_CallReceived);
    return state;
}

pfState *uniUserMode :: createUserConnectRequestState(void)
{
    pfState *state = uniUserConnectRequest::instance();
    setCallState(ieCallState::callState_ConnectRequest);
    return state;
}

pfState *uniUserMode :: createNetworkConnectRequestState(void)
{
    pfState *state = uniUserActive::instance();
    setCallState(ieCallState::callState_Active);
    return state;
}

pfState *uniUserMode :: createIncomingCallProceedingState(void)
{
    pfState *state = uniUserIncomingCallProceeding::instance();
    setCallState(ieCallState::callState_IncomingCallProceeding);
    return state;
}

pfState *uniUserMode :: createActiveState(void)
{
    pfState *state = uniUserActive::instance();
    setCallState(ieCallState::callState_Active);
    return state;
}

pfState *uniUserMode :: createReleaseRequestState(void)
{
    pfState *state = uniUserReleaseRequest::instance(); 
    setCallState(ieCallState::callState_ReleaseRequest);
    return state;
}

pfState *uniUserMode :: createReleaseIndicationState(void)
{
    pfState *state = uniUserReleaseIndication::instance();
    setCallState(ieCallState::callState_ReleaseIndication);
    return state;
}

//-------------------------------------------------------------------

uniNetworkMode *uniNetworkMode :: _only = 0;

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

uniNetworkMode :: uniNetworkMode(void)
    : sigMode()
{
    return;
}

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

bool uniNetworkMode :: isNetworkMode(void)
{
    return true;
}

void uniNetworkMode :: setZeroEndpointReference(
    pfMessenger *message_, 
    sigProtocol *protocol_)
{
    protocol_->setZeroEndpointReferenceAtTSide(message_);
    return;    
}

pfState *uniNetworkMode :: createNullState(void)
{
    pfState *state = uniUserNull::instance();
    setCallState(ieCallState::callState_Null);
    return state;
}

pfState *uniNetworkMode :: createCallInitiatedState(void)
{
    pfState *state = uniUserCallPresent::instance();
    setCallState(ieCallState::callState_CallPresent);
    return state;
}

pfState *uniNetworkMode :: createOutgoingCallProceedingState(void)
{
    pfState *state = uniUserIncomingCallProceeding::instance();
    setCallState(ieCallState::callState_IncomingCallProceeding);
    return state;
}

pfState *uniNetworkMode :: createCallDeliveredState(void)
{
    pfState *state = uniUserCallReceived::instance();
    setCallState(ieCallState::callState_CallReceived);
    return state;
}

pfState *uniNetworkMode :: createCallPresentState(void)
{
    pfState *state = uniUserCallInitiated::instance();
    setCallState(ieCallState::callState_CallInitiated);
    return state;
}

pfState *uniNetworkMode :: createCallReceivedState(void)
{
    pfState *state = uniUserCallDelivered::instance();
    setCallState(ieCallState::callState_CallDelivered);
    return state;
}

pfState *uniNetworkMode :: createUserConnectRequestState(void)
{
    pfState *state = uniUserActive::instance();
    setCallState(ieCallState::callState_Active);
    return state;
}

pfState *uniNetworkMode :: createNetworkConnectRequestState(void)
{
    pfState *state = uniNetworkConnectRequest::instance();
    setCallState(ieCallState::callState_ConnectRequest);
    return state;
}

pfState *uniNetworkMode :: createIncomingCallProceedingState(void)
{
    pfState *state = uniUserOutgoingCallProceeding::instance();
    setCallState(ieCallState::callState_OutgoingCallProceeding);
    return state;
}

pfState *uniNetworkMode :: createActiveState(void)
{
    pfState *state = uniUserActive::instance();
    setCallState(ieCallState::callState_Active);
    return state;
}

pfState *uniNetworkMode :: createReleaseRequestState(void)
{
    pfState *state = uniUserReleaseIndication::instance();
    setCallState(ieCallState::callState_ReleaseIndication);
    return state;
}

pfState *uniNetworkMode :: createReleaseIndicationState(void)
{
    pfState *state = uniUserReleaseRequest::instance(); 
    setCallState(ieCallState::callState_ReleaseRequest);
    return state;
}