#include <iostream>
#include <fstream>
#include "benchC.h"
#include "orbsvcs/CosNamingC.h"
#include <tao/RTCORBA/RTCORBA.h>
#include <unistd.h>

#include "cpx.h"

benchmark::Put_var put;
CPX cpx;
std::string strData;

void sigproc(int signo)
{ 		signal(SIGRTMIN+29, sigproc);
		benchmark::dataStruct_var data = new benchmark::dataStruct;
		data->data = CORBA::string_alloc(sizeof(strData));
		data->data = CORBA::string_dup((const char*)strData.c_str());
		data->valPort1 = cpx.get(1);
		data->valPort2 = cpx.get(2);
		data->valPort3 = cpx.get(3);
		put->dataAndPorts(data);
}


int main(int argc, char* argv[]){

	if (argc < 2){
		std::cout<<"enter filename as param1\n";
		return 0;
	}

	std::string line;
	std::ifstream infile (argv[1], std::ios_base::in);
  	while (getline(infile, line, '\n'))
  	{
    		strData += line;
  	}

	try{
                // initialize ORB
                CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "ClientORB");
                std::cout<<"ORB ok"<<std::endl;

                // get RTORB
                CORBA::Object_var rtorb = orb->resolve_initial_references("RTORB");
                RTCORBA::RTORB_var rtORB = RTCORBA::RTORB::_narrow(rtorb.in());
                std::cout<<"RTORB ok"<<std::endl;

                // NamingService
                CORBA::Object_var namingObject = orb->resolve_initial_references("NameService");
                CosNaming::NamingContext_var namingContext = CosNaming::NamingContext::_narrow(namingObject.in());
                std::cout<<"NamingService ok"<<std::endl;

                CosNaming::Name name(1);
                name.length(1);
                name[0].id = CORBA::string_dup("Receiver");

                // receive Object
                CORBA::Object_var benchObj = namingContext->resolve(name);
                put = benchmark::Put::_narrow(benchObj.in());
                std::cout<<"TransferOjekt ok"<<std::endl;

                // Private Connection Policy
                CORBA::PolicyList pcPolicy(1);
                pcPolicy.length(1);
                pcPolicy[0] = rtORB->create_private_connection_policy();
                CORBA::Object_var newTran = put->_set_policy_overrides(pcPolicy, CORBA::SET_OVERRIDE);
                put = benchmark::Put::_narrow(newTran.in());
                std::cout<<"PrivateConnection ok"<<std::endl;

                // rtCurrent set priority
                CORBA::Object_var rtCurrentObj = orb->resolve_initial_references("RTCurrent");
                RTCORBA::Current_var rtCurrent = RTCORBA::Current::_narrow(rtCurrentObj.in());
                rtCurrent->the_priority(0);
                std::cout<<"PriorityChange ok"<<std::endl;

                // explicitly bind connection to server
                //CORBA::PolicyList_var inconsistentPolicies;
                //CORBA::Boolean status = transfer->_validate_connection(inconsistentPolicies.out());
                //std::cout<<"explicit bind ok"<<std::endl;

                // Input auf Interface schreiben
		// ...
		// put->connect();
		// put->allPorts(0, 0, 0);
		// sleep(1);
	        // put->onePort(1, 255);
		// sleep(1);
		// put->allPorts(0, 0, 0);

	        // signal handling
	        signal(SIGRTMIN+29, sigproc);

		while(true){
			pause();
		}

        // destroy ORB
        orb->destroy();

        }catch(CORBA::Exception &any){
                std::cout<<"Exception occured: "<<any<<std::endl;
        }
        return 0;
}