#include <player.h>
#include <playerpacket.h>
#include <player/driver.h>
#include <player/drivertable.h>

#include <stddef.h> // for NULL
#include <string.h> // for memset

#define FAIL -1

class MyDriver2 : public Driver
{
    private: MyDriver2(); // not implemented
    public: MyDriver2(ConfigFile * cf, int section);
    public: virtual ~MyDriver2();
    public: virtual int Setup();
    public: virtual int Shutdown();
    private: virtual void Main();
    public: int Subscribe(player_device_id_t id);
    public: int Unsubscribe(player_device_id_t id);

    private: player_device_id_t camera_id;
    private: int camera_subscriptions;
};

// factory function
Driver * MyDriver2_Init(ConfigFile * cf, int section)
{
    return new MyDriver2(cf, section);
}

// registration function
void MyDriver2_Register(DriverTable * table)
{
    table->AddDriver("mydriver2", MyDriver2_Init);
}

extern "C" 
{
    int player_driver_init(DriverTable * table)
    {
	MyDriver2_Register(table);
	return 0;
    }
}

// just for example:
#define SOMETHING_WRONG 0

// Multi interface example:
MyDriver2::MyDriver2(ConfigFile * cf, int section) : Driver(cf, section)
{
    this->camera_subscriptions = 0;
    memset(&(this->camera_id), 0, sizeof(player_device_id_t));
    if (!(cf->ReadDeviceId(&(this->camera_id), section, "provides", PLAYER_CAMERA_CODE, -1, NULL)))
    {
	if (this->AddInterface(this->camera_id, PLAYER_READ_MODE,
                               sizeof(player_camera_data_t),
                               0, 10, 10))
	{
	    this->SetError(FAIL);
	    return;
	}
    }    
    if (SOMETHING_WRONG)
    {
	this->SetError(FAIL);
        return;
    }
}

MyDriver2::~MyDriver2()
{ }

int MyDriver2::Setup()
{
    if (SOMETHING_WRONG) return FAIL;
    this->StartThread();
    return 0;
}

int MyDriver2::Shutdown()
{
    this->StopThread();
    return 0;
}

void MyDriver2::Main()
{
    for (;;)
    {
	pthread_testcancel();
    }
}

int MyDriver2::Subscribe(player_device_id_t id)
{
    int setupResult;

    setupResult = Driver::Subscribe(id);
    if (!setupResult)
    {
	switch(id.code)
	{
        case PLAYER_CAMERA_CODE:
	    this->camera_subscriptions++;
	    break;
	}
    }
    return setupResult;
}

int MyDriver2::Unsubscribe(player_device_id_t id)
{
    int shutdownResult;

    shutdownResult = Driver::Unsubscribe(id);
    if (!shutdownResult)
    {
	switch(id.code)
	{
	case PLAYER_CAMERA_CODE:
	    this->camera_subscriptions--;
	    break;
	}
    }
    return shutdownResult;
}