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

#include <vcl.h>
#pragma hdrstop

#include "DeviceSimulatorThread.h"
#include "IDeviceFactory.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------

//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall DeviceSimulatorThread::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------

using namespace std;

__fastcall DeviceSimulatorThread::DeviceSimulatorThread( IDevice * device,
                                                         IDeviceFactory * factory,
                                                         const AnsiString & hostname ) :
    TThread( false ),
    m_device( device ),
    m_factory( factory ),
    m_address( hostname ),
    m_running( false ),
    m_error( "" )
{
    m_device->registerListener( this );

    SECURITY_ATTRIBUTES attribs = { 0 };
    attribs.nLength = sizeof( attribs );
    attribs.bInheritHandle = false;

    m_semaphore = CreateSemaphore( &attribs, 0, 10000, "DeviceSimulatorSemaphore" );
}
//---------------------------------------------------------------------------

void DeviceSimulatorThread::SetName()
{
    THREADNAME_INFO info;
    info.dwType = 0x1000;
    info.szName = "DeviceSimulatorThread";
    info.dwThreadID = -1;
    info.dwFlags = 0;

    __try
    {
         RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(DWORD),(DWORD*)&info );
    }
    __except (EXCEPTION_CONTINUE_EXECUTION)
    {
    }
}

//---------------------------------------------------------------------------
void __fastcall DeviceSimulatorThread::Execute()
{
    SetName();
    m_running = true;

    try
    {
        // Connect the device

        if( !m_device->connect( m_address.c_str() ) )
        {
            m_error = "Device failed to connect to Site Computer at " + m_address + ":5003";
        }

        // Loop until exit, or an error has occured

        while( m_running && m_error.IsEmpty() )
        {
            // Wait for:
            //  1. A disconnection/connection event to reconnect or update our status
            //  2. A request to upload a UD file from our manager
            //  3. A termination request

            if( WaitForSingleObject( m_semaphore, INFINITE ) == WAIT_OBJECT_0 )
            {
                // Check connection state

                if( !m_device->isConnected() )
                {
                    Reconnect();
                }

                // Perform any transfers required

                TransferUdFiles();
                ReleaseSemaphore( m_semaphore, 1, NULL );
            }
        }
    }
    __finally
    {
        // Terminate and cleanup. Destroy the device using the factory or
        // exceptions will be raised.

        m_device->detachListener( this );
        m_device->disconnect();
        m_running = false;

        m_factory->destroyDevice( *m_device );
        m_device = 0;

        CloseHandle( m_semaphore );
    }
}
//---------------------------------------------------------------------------

void DeviceSimulatorThread::Reconnect()
{
    //TODO: configurable?
    const int retries = 5;

    if( !m_device->isConnected() )
    {
        bool connected = false;
        int connectCount = retries;

        while( (connectCount >= 0) && !connected )
        {
            m_device->connect( m_address.c_str() );
            connectCount--;

            int checkCount = retries;
            while( (checkCount >= 0) && !(connected = m_device->isConnected()) )
            {
                checkCount--;
                Sleep( 500 );
            }
        }

        // Terminate if we couldn't get a connection

        if( !connected )
        {
            m_error.sprintf( "Failed to connect to site computer %s", m_address );
        }
    }
}
//---------------------------------------------------------------------------

bool DeviceSimulatorThread::TransferUdFiles()
{
    bool success = true;

    // TODO: configurable?
    const int retries = 5;

    vector<AnsiString>::iterator file = m_udFiles.begin();
    if( file != m_udFiles.end() )
    {
        // Retry a transfer if we fail.. check connection in between
        // incase it has dropped

        success = m_device->sendUdFile( (*file).c_str(), 0, true, false );

        if( success )
        {
            m_udFiles.erase( file );
        }
        else if( m_running )
        {
            m_error.sprintf( "Failed to transfer UD file %s", (*file) );
        }
    }

    return success;
}
//---------------------------------------------------------------------------

void __fastcall DeviceSimulatorThread::UploadUDFile( const AnsiString & filename )
{
    if( m_running )
    {
        m_udFiles.push_back( filename );
        ReleaseSemaphore( m_semaphore, 1, NULL );
    }
}
//---------------------------------------------------------------------------

void __fastcall DeviceSimulatorThread::Stop()
{
    // Will stop the thread after the UD queue has finished transferring
    
    m_running = false;
    ReleaseSemaphore( m_semaphore, 1, NULL );
}
//---------------------------------------------------------------------------

void DS_STDCALL DeviceSimulatorThread::onEvent( const unsigned short type,
                                                const char * msg,
                                                const unsigned char status )
{
    switch( type )
    {
    case EVENT_UDXFER:
        break;

    case EVENT_DISCON:
        // Simply wake the main thread; it will handle a reconnection
        ReleaseSemaphore( m_semaphore, 1, NULL );
        break;
    }
}
//---------------------------------------------------------------------------

void DS_STDCALL DeviceSimulatorThread::detach()
{
    // TODO: This is fatal as we rely on event callbacks for processing
    m_device->detachListener( this );
}