/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

#include <sip.h>
#include <sipprofileregistry.h>
#include <sipprofile.h>
#include <comms-infras/es_config.h>
#include <in_sock.h>

#include "dhcppsylogging.h"
#include "dhcppsyrequesterprogressobserver.h"
#include "dhcppsypanic.h"
#include "dhcpsocketlistener.h"
#include "dhcpwlanqueryhandler.h"
#include "dhcplocationinformationparser.h"
#include "dhcpdatasender.h"
#include "dhcpdatalocationrequest.h"
#include "dhcpconstants.h"
#include "dhcpconnectionengine.h"
#include "dhcpserveripaddressresolver.h"


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CDhcpWlanQueryHandler* CDhcpWlanQueryHandler::NewL(MDhcpPsyRequesterProgressObserver *aObserver)
    {
    TRACESTRING( "CDhcpWlanQueryHandler::NewL" );
    CDhcpWlanQueryHandler* self = new(ELeave) CDhcpWlanQueryHandler (aObserver);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CDhcpWlanQueryHandler::~CDhcpWlanQueryHandler()
    {
    TRACESTRING( "CDhcpWlanQueryHandler::~CDhcpWlanQueryHandler" );

    // Close opened resources and delete reserved memory
    Cancel();

    Flush ();

    delete iLctnDataRequestor;
    delete iLctnDataListener;

    iSocket.Close ();

    iConnection.Close();
    iSocketServer.Close();

    TRACESTRING( "CDhcpWlanQueryHandler::~CDhcpWlanQueryHandler -- end" );
    }

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CDhcpWlanQueryHandler::CDhcpWlanQueryHandler (MDhcpPsyRequesterProgressObserver *aObserver)
    : CActive (CActive::EPriorityStandard), iPsyProgressObserver (aObserver)
    {
    TRACESTRING( "CDhcpWlanQueryHandler::CDhcpWlanQueryHandler" );
    CActiveScheduler::Add(this);
    }

// ---------------------------------------------------------------------------
// LocationData
// ---------------------------------------------------------------------------
//
HBufC8*  CDhcpWlanQueryHandler::LocationData ()
    {
    return iLocationBufferData;
    }

// ---------------------------------------------------------------------------
// MakeLocationQueryL
// ---------------------------------------------------------------------------
//
void CDhcpWlanQueryHandler::MakeLocationQueryL (TUint32 aIapProfileId)
    {
    TRACESTRING( "CDhcpWlanQueryHandler::MakeLocationQueryL" )
    iIapProfileId = aIapProfileId;

    // Check is the device already connected to the wlan accessoint.
    TBool connectionAttached = iConnectionEngine->IsConnectedL(iIapProfileId);
    if (connectionAttached)
        {
        TRACESTRING("CDhcpWlanQueryHandler::MakeLocationQueryL, Attached" )
        iDhcpResolver = CDhcpPsyDhcpServerIPResolver::NewL(iConnection, iStatus);
        iState = EDhcpIpAddressQuery;
        }
    else
        {
        TRACESTRING("CDhcpWlanQueryHandler::MakeLocationQueryL, Not attached" )
        iConnectionEngine->ConnectL (aIapProfileId, iStatus);
        iState = EAttachToConnection;
        }

    iPsyProgressObserver->ProgressPsyRequestNotificationL (MDhcpPsyRequesterProgressObserver::ELocationQueryStarted,
         KErrNone);

    SetActive();
    }

// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CDhcpWlanQueryHandler::ConstructL()
    {
    TRACESTRING( "CDhcpWlanQueryHandler::ConstructL" );
    User::LeaveIfError( iSocketServer.Connect() );
    User::LeaveIfError( iConnection.Open( iSocketServer ) );

    iConnectionEngine = CDhcpConnectionEngine::NewL(iConnection);
    // Add socket listener and requestor classes up. Rest parameters will be
    // provided later on.
    iLctnDataRequestor = CDhcpDataRequestor::NewL(iSocket);
    iLctnDataListener = CDhcpPsySocketListener::NewL(&iSocket);
    }

// -----------------------------------------------------------------------------
// CDhcpWlanQueryHandler::RunL
// -----------------------------------------------------------------------------
//
void CDhcpWlanQueryHandler::RunL()
    {
    TRACESTRING2( "CDhcpWlanQueryHandler::RunL, %d ", iStatus.Int());
    TRACESTRING2( "CDhcpWlanQueryHandler::RunL, state %d ", iState);
    TInt result = iStatus.Int();
    if (result != KErrNone && iState!=EDhcpIpAddressQuery)
        {
        iState=EDhpWlanIdle;
        iPsyProgressObserver->ProgressPsyRequestNotificationL (MDhcpPsyRequesterProgressObserver::ELocationQueryFinished,
             iStatus.Int());
        return;
        }
    switch (iState)
        {
        case EAttachToConnection:
            {
            TRACESTRING( "CDhcpWlanQueryHandler::RunL, AttachToConnection, start");

            iState=EDhcpIpAddressQuery;

            // Get ip address of the dhcp server.
            iDhcpResolver = CDhcpPsyDhcpServerIPResolver::NewL(iConnection, iStatus);
            SetActive ();
            }
            break;
        case EDhcpIpAddressQuery:
            {
            TRACESTRING( "CDhcpWlanQueryHandler::RunL, create and send the dhcp inform message to the wlan net, start");

            User::LeaveIfError( iSocket.Open( iSocketServer,
                    KAfInet,
                    KSockDatagram,
                    KProtocolInetUdp,
                    iConnection ) );

            TInetAddr addr( KInetAddrAny, KDhcpDefaultCliPort );
            iSocket.Bind( addr );

            // Create a dhcp inform message and send it.
            iLctnDataRequestor->SendDHCPMessageL(iDhcpResolver->DhcpServerInetAddress(),
                iIapProfileId, iStatus);

            iState = ESendDhcpLocatinQuery;
            SetActive ();
            }
            break;

        case ESendDhcpLocatinQuery:
            {
            TRACESTRING( "CDhcpWlanQueryHandler::RunL, send complete" );
            // Store transaction id to the listener object
            iLctnDataListener->SetTransActionIdToFollow (iLctnDataRequestor->TransActionIdToFollow());
            // And start to listen the dhcp ack message from the subnet.
            iLctnDataListener->RcvDHCPMessage (iStatus);
            iState = EReceiveDhcpLocationAck;
            SetActive ();
            }
            break;
        case EReceiveDhcpLocationAck:
            {
            TRACESTRING( "CDhcpWlanQueryHandler::RunL, response received." );
            TInt statusCode = iStatus.Int();

            // Make final XML buffer if possible.
            TPtrC8 geoConfigInformation (iLctnDataListener->GeoConfigDhcpInformation());
            TPtrC8 civicInformation (iLctnDataListener->LocationCivicInformation ());

            TRACESTRING2( "CDhcpWlanQueryHandler::RunL, Response, geoConfig length %d",
                    geoConfigInformation.Length()
                    );

            TRACESTRING2 ( "CDhcpWlanQueryHandler::RunL, Response, civicInformation length %d",
                    civicInformation.Length()
                    );

            if(iLocationBufferData)
                {
                delete iLocationBufferData;
                iLocationBufferData = NULL;
                }

            // We should able to calculate maximun length of target buffer
            iLocationBufferData = HBufC8::NewL(KDhcpMaxLocInfoLength);
            TDhcpLocationInformationParser informationParser;
            TPtr8 ptr (iLocationBufferData->Des());

            // Parse at next preferred order option 123 and if doesn't found then option 99 if
            // possible ...
            if (geoConfigInformation.Length())          // option 123, GeoSpatial location information
                {
                informationParser.ParseLocationInformation(
                    geoConfigInformation,
                    TDhcpLocationInformationParser::EDHCPCoordinates, ptr);
                }
            else if (civicInformation.Length())        // option 99, civic address location information
                {
                informationParser.ParseLocationInformation(
                    civicInformation,
                    TDhcpLocationInformationParser::EDHCPCivicAddress, ptr);
                }
            else
                {
                // No valid information from the dhcp server,  notify caller for that.
                statusCode = KErrNotFound;
                }

            iState=EDhpWlanIdle;
            iPsyProgressObserver->ProgressPsyRequestNotificationL (MDhcpPsyRequesterProgressObserver::ELocationQueryFinished,
                 statusCode );
            }
            break;
        default:
            {
            TRACESTRING( "CDhcpWlanQueryHandler::RunL, invalid switch-case" );
            User::Leave (KErrGeneral);
            }
            break;
        }
    }

// -----------------------------------------------------------------------------
// CDhcpWlanQueryHandler::DoCancel
// -----------------------------------------------------------------------------
//
void CDhcpWlanQueryHandler::DoCancel()
    {
    TRACESTRING( "CDhcpWlanQueryHandler::DoCancel" )
    if (iConnectionEngine)
        {
        iConnectionEngine->Cancel();
        }
    // Cancel onqoing request if needed.
    if (iDhcpResolver)
        {
        iDhcpResolver->Cancel();
        }

    if (iLctnDataRequestor)
        {
        iLctnDataRequestor->Cancel();
        }

    if (iLctnDataListener)
        {
        iLctnDataListener->Cancel();
        }

    TRAPD (err,
        iPsyProgressObserver->ProgressPsyRequestNotificationL (MDhcpPsyRequesterProgressObserver::ECancelled,
             KErrNone ) ) ;

    TRequestStatus *status = &iStatus;
    User::RequestComplete ( status, err );

    TRACESTRING( "CDhcpWlanQueryHandler::DoCancel finished" )
    }

// -----------------------------------------------------------------------------
// CDhcpWlanQueryHandler::RunError
// -----------------------------------------------------------------------------
//
TInt CDhcpWlanQueryHandler::RunError (TInt aErrorCode)
    {
    TRACESTRING2( "CDhcpWlanQueryHandler::RunError %d", aErrorCode )
    TRACESTRING2( "CDhcpWlanQueryHandler::RunError, state, %d", iState )
    iState=EDhpWlanIdle;
    TRAPD (err,
        iPsyProgressObserver->ProgressPsyRequestNotificationL (MDhcpPsyRequesterProgressObserver::ELocationQueryFinished,
            aErrorCode ) );
    return err;
    }

// -----------------------------------------------------------------------------
// CDhcpWlanQueryHandler::Flush
// -----------------------------------------------------------------------------
//
void CDhcpWlanQueryHandler::Flush ()
    {
    TRACESTRING( "CDhcpWlanQueryHandler::Flush" )
    delete iConnectionEngine;
    iConnectionEngine = NULL;
    delete iDhcpResolver;
    iDhcpResolver = NULL;
    delete iLocationBufferData;
    iLocationBufferData=NULL;
    }