/*
 * testServerContext.cpp
 */

#include <pv/serverContext.h>
#include <epicsExit.h>

using namespace epics::pvAccess;
using namespace epics::pvData;
using namespace std;

class TestChannelProvider : public ChannelProvider
{
public:
       
    std::string getProviderName() { return "local"; };
    

    ChannelFind::shared_pointer channelFind(std::string const & /*channelName*/,
                                            ChannelFindRequester::shared_pointer const & channelFindRequester)
    {
        ChannelFind::shared_pointer nullCF;
        channelFindRequester->channelFindResult(Status::Ok, nullCF, false); 
        return nullCF;  
    }

    ChannelFind::shared_pointer channelList(ChannelListRequester::shared_pointer const & channelListRequester)
    {
        ChannelFind::shared_pointer nullCF;
        PVStringArray::const_svector none;
        channelListRequester->channelListResult(Status::Ok, nullCF, none, false);
        return nullCF;
    }

    Channel::shared_pointer createChannel(
                std::string const & channelName,
                ChannelRequester::shared_pointer const & channelRequester,
                short priority = PRIORITY_DEFAULT)  
    {
        return createChannel(channelName, channelRequester, priority, "");
    }

    Channel::shared_pointer createChannel(
                std::string const & /*channelName*/,
                ChannelRequester::shared_pointer const & channelRequester,
                short /*priority*/, std::string const & /*address*/)
    {
        Channel::shared_pointer nullC;
        channelRequester->channelCreated(Status::Ok, nullC);
        return nullC;    
    }
    
    void destroy()
    {
    }
};


class TestChannelProviderRegistry : public ChannelProviderRegistry {
public:
                
    virtual ~TestChannelProviderRegistry() {};
            
    ChannelProvider::shared_pointer getProvider(std::string const & providerName)
    {
        if (providerName == "local")
        {
            return ChannelProvider::shared_pointer(new TestChannelProvider()); 
        }
        else
            return ChannelProvider::shared_pointer(); 
    }
            
    ChannelProvider::shared_pointer createProvider(std::string const & providerName)
    {
        return getProvider(providerName);
    }

    std::auto_ptr<stringVector_t> getProviderNames()
    {
        std::auto_ptr<stringVector_t> pn(new stringVector_t());
        pn->push_back("local");
        return pn;
    }
};

void testServerContext()
{

	ServerContextImpl::shared_pointer ctx = ServerContextImpl::create();

	ChannelProviderRegistry::shared_pointer ca(new TestChannelProviderRegistry());
	ctx->initialize(ca);

	ctx->printInfo();

	ctx->run(1);

	ctx->destroy();
}

int main()
{
	testServerContext();

	cout << "Done" << endl;

	//epicsExitCallAtExits();
    return (0);
}