/*
 * donutsOTEB.h
 *
 *  Created on: Jan 28, 2014
 *      Author: jdaugherty
 */

#ifndef REGISTRYOTE_H_
#define REGISTRYOTB_H_

    typedef void (*caseBody)(void);

    typedef struct {
    	const char         *caseName;
    	caseBody               fBody;
    	const Json::Value     *parms;
    } testCase;

    typedef std::map<int,testCase>       testCases;
    typedef std::map<string,caseBody>    testFuncs;

namespace AC_OTE {

    static TestEnvironment props;
    static int             nCases;

    testCases         theseCases;
    testFuncs         theseFuncs;

    static std::string TEST_SE =
	"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><epp xmlns=\"urn:ietf:params:xml:ns:epp-1.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd\"><hello/></epp>";


    auto_ptr<SessionManager> manager(SessionManagerFactory::newInstance(&props));
    auto_ptr<Session> sess(SessionFactory::newInstance(&props));

    bool  acTkInitialised = false,  fatal  = false,   done = false;

	const char *thisRegistry="Donuts", *thatAccount="secura2-ote2", *thisAccount="secura1-ote";
	      char *thisName;

	int      cmd=0;
	string   op("newInstance");

    const string        claims("claims"), dpml("custom"), landrush("landrush"), sunrise("sunrise");

    const std::string                rrj("renjuan");
    const std::string             rrjPW("Ab9dW@rd");
    const std::string      rrjEmail("juan@acm.org");
    const std::string       rrjName("Ren Ren-Juan");
    const std::string      rrjCity("Niagara Falls");
    const std::vector<std::string>
                         rrjCrib(1,"2926 2nd Strt");
    const std::string                 rrjProv("NY");
    const std::string                rrjPC("14305");
    const std::string                  rrjGuo("US");
    const std::string rrjOrg("American Kybernetik");

    const std::string                pw("Ab9dW@rd");
    const std::string                RID("renjuan");

    std::vector<std::string> tech(1,std::string("renjuan") );
    std::vector<std::string> admin(1,std::string("renjuan") );
    std::vector<std::string> billing(1,std::string("renjuan") );
    std::vector<std::string> ns(1,std::string("ns1.google.com") );;

    const IntPostalInfo      rrjPO(rrjName,rrjOrg,
   		 rrjCrib,rrjCity,rrjProv,rrjPC,rrjGuo);

    LPCrtCmdExtension    crtE1( &claims ), crtE2( &dpml );
    Transaction          thisTest;

    void check() {

           theseLogs->logN(2,"(%d) Unextended  check of %s",cmd++,thisName);

           DomainCheckCommand   oteCommand_1(thisName);
           DomainCheckResponse  oteResponse_1;

           try {
           thisTest =  Transaction(&oteCommand_1, &oteResponse_1);
           manager->execute(thisTest);
           }
           catch(...)
           {
               theseLogs->logN(0,"Case %d Failed, fatal to suite.",cmd++);
               fatal = true;
           }

    }

    void checkClaims() {

           theseLogs->logN(2,"(%d) Perform Claims type Check of %s",cmd++,thisName);

           DomainCheckCommand    oteCommand_2(thisName);
           LPChkCmdExtension     chkE(&claims);
           oteCommand_2.appendExtension(chkE);
           DomainCheckResponse   oteResponse_2;
           LPChkRespExtension    chkRspE;
           oteResponse_2.registerExtension(&chkRspE);

           try {
            thisTest = Transaction(&oteCommand_2, &oteResponse_2);
            manager->execute(thisTest);
            theseLogs->logN(3,"(%d) Claims %s exist for %s.",
            		    cmd,(chkRspE.doClaimsExist() ? "do" : " do not "),thisName);
            if (chkRspE.doClaimsExist())
            	theseLogs->logN(3,"(%d) claim: %s .",cmd,chkRspE.getClaimsKey());
           }
           catch (EPPException& e)
           { const char *eMsg  = e.getMessage().c_str();
             const char *opNow = op.c_str();
             theseLogs->logN(2,"EPP Exception during OTE (%s): %s .",opNow,eMsg);
             throw e;
           }
           catch (...)
           {
             theseLogs->logN(1,"General Exception OTE B (%s).",op.c_str());
           }

    }

    void create() {

    theseLogs->logN(3," (%d) normal create %s in OTE %s.",cmd++, thisName, thisAccount);
    DomainCreateCommand
      oteCommand_3(thisName,pw,&RID, &tech, &ns, &admin, &billing);
    DomainCreateResponse  oteResponse_3;
    thisTest = Transaction(&oteCommand_3, &oteResponse_3);
    manager->execute(thisTest);

    }

    void createClaimOverride() {

        theseLogs->logN(2,"(%d) Create %s w Notice ID test data (TCN).",++cmd,thisName);

            string noticeID("d85159710000000000000008692"),
            	   notAfter("2015-01-01T12:00:00Z"), acceptedDate("2014-01-27T19:00:00Z");

            DomainCreateCommand  oteCommand_6(thisName,pw,&RID, &tech, &ns, &admin, &billing);
            crtE1.setNoticeID(noticeID, notAfter, acceptedDate);
            oteCommand_6.appendExtension(crtE1);
            DomainCreateResponse oteResponse_6;

            try {
            thisTest = Transaction(&oteCommand_6, &oteResponse_6);
            manager->execute(thisTest);
            }
            catch (EPPException& e)
            { const char *eMsg  = e.getMessage().c_str();
              const char *opNow = op.c_str();
              theseLogs->logN(2,"EPP Exception during OTE B (%s): %s .",opNow,eMsg);
              throw e;
            }
            catch (...)
            {
              theseLogs->logN(1,"General Exception OTE B (%s).",op.c_str());
            }

    }

    void createContact() {

        ContactCreateCommand oteCommand_0(rrj,rrjPW,&rrjPO,rrjEmail);
        ContactCreateResponse oteResponse_0;

        theseLogs->logN(1,"(skip) Create Contact(s).");

        try {
        thisTest =  Transaction(&oteCommand_0, &oteResponse_0);
        manager->execute(thisTest);
        }
        catch(const std::exception e)
        {
            theseLogs->logN(1,"Case %d: %s.",cmd++,e.what());
        }
        catch(...)
        {
            theseLogs->logN(1,"Case %d Failed, harness catch.",cmd++);
        }

    }

    void dpmlCreate() { std::string dpmlName("face.dpml.zone");

                        theseLogs->logN(2,"(%d) Create %s w ICANN SMD file.",++cmd,dpmlName.c_str());

                        DomainCreateCommand  oteCommand_7(dpmlName,pw,&RID, &tech, &ns, &admin, &billing);
                        crtE2.setSMD();
                        oteCommand_7.appendExtension(crtE2);
                        DomainCreateResponse oteResponse_7;

                        try {
                            thisTest = Transaction(&oteCommand_7, &oteResponse_7);
                            manager->execute(thisTest);
                            }
                            catch (EPPException& e)
                            { const char *eMsg  = e.getMessage().c_str();
                              const char *opNow = op.c_str();
                              theseLogs->logN(2,"EPP Exception during OTE B (%s): %s .",opNow,eMsg);
                              throw e;
                            }
                            catch (...)
                            {
                              theseLogs->logN(1,"General Exception OTE B (%s).",op.c_str());
                            }

                    }

    void sunriseCreate() {

        theseLogs->logN(2,"(%d) Sunrise create %s with ICANN SMD test data.",++cmd,thisName);

            DomainCreateCommand  oteCommand_5(thisName,pw,&RID, &tech, &ns, &admin, &billing);
            oteCommand_5.appendExtension(crtE1);
            DomainCreateResponse oteResponse_5;

            try {
            thisTest = Transaction(&oteCommand_5, &oteResponse_5);
            manager->execute(thisTest);
            }
            catch (EPPException& e)
            { const char *eMsg  = e.getMessage().c_str();
              const char *opNow = op.c_str();
              theseLogs->logN(2,"EPP Exception during OTE B (%s): %s .",opNow,eMsg);
              throw e;
            }
            catch (...)
            {
              theseLogs->logN(1,"General Exception OTE B (%s).",op.c_str());
            }

    }

    void transfer(bool &transferGainer) {

        DomainTransferRequestCommand
            oteCommand_4a(thisName,rrjPW);
        DomainTransferApproveCommand
             oteCommand_4b(thisName,rrjPW);
        DomainTransferResponse oteResponse_4;

        try {

        theseLogs->logN(4," %s (%d)  %s -> %s.", (transferGainer ? "Request" : "Approve") ,cmd++, thisName,thatAccount);

        thisTest =   transferGainer ?  Transaction(&oteCommand_4a, &oteResponse_4)  :
                                       Transaction(&oteCommand_4b, &oteResponse_4) ;
        manager->execute(thisTest);

        }
         catch(...)
        {
            theseLogs->logN(0,"Case %d Failed, non fatal.",cmd++);
        }

    } // transfer

    int setFuncs() {

    	 theseFuncs["case00"]   = createContact;
    	 theseFuncs["case01"]   = check;
    	 theseFuncs["case02"]   = checkClaims;
    	 theseFuncs["case03"]   = create;
    	 theseFuncs["case05"]   = createClaimOverride;


    }
} // AC_OTE

using namespace AC_OTE;

bool ausRegEPPTK::registryXOTE()
  {
	bool debug=true; int i=0;

        if (!acTkInitialised) {
         	scenario(thisConfig->tkScenario,thisConfig->cfg_path);
       	    acTkInitialised = true;
        }

        const Json::Value suite = root["testSuite00"];

        if (!suite) {
           theseLogs->logN(0,"'testSuite00' suite root not found, need it.");
           return true;
  	    }

        for ( i = 0; i < suite.size(); ++i )  { const char *thisItem = suite[i].asString().c_str();
        	if (debug)
            theseLogs->logN(1,"item %.",thisItem);
        	if (strncmp(thisItem,"case",4)) continue;
        	if (strlen(thisItem) != 6)      continue;
        	if (debug)
                theseLogs->logN(1,"case %.",thisItem);
        	if (!theseFuncs[thisItem]) {
                theseLogs->logN(0,"No logic to bind to '%s', need it.");
        		return false;
        	}
        	theseCases[AC_OTE::nCases].parms      = &suite[i];
         	theseCases[AC_OTE::nCases].fBody      =  theseFuncs[thisItem];
        	theseCases[AC_OTE::nCases++].caseName =  thisItem;
        }

       	while(!done) {
        try {

            Timer::setTime("20140101.010101");

        	op = "startup";
            manager->startup();
            op = "run (keep-alive)";
            manager->run();

    		sess->open();

            theseLogs->logN(2,"OTE %s [Hello] (%d).",thisAccount,cmd++);
      		sess->writeXML(TEST_SE);
      	    sess->read();

      	    for (i=0;i<theseCases.size();i++) {

                theseLogs->logN(2,"%d (%s) Begin ",i,theseCases[i].caseName );
      	    	theseCases[i].fBody();
                theseLogs->logN(2,"%d (%s) End ",i,theseCases[i].caseName );

      	    }

            theseLogs->logN(0,"End OTE Session.");
            theseLogs->logN(0,"Restart with toolkit scenario >= 5 for production ops.");

            sess->close();
            manager->shutdown();

        }
        catch (EPPException& e)
        {   const char *eMsg  = e.getMessage().c_str();
            const char *opNow = op.c_str();
            theseLogs->logN(2,"Outer EPP Exception during OTE (%s): %s .",opNow,eMsg);
            throw e;
        }
        catch (...)
        {
            theseLogs->logN(2,"Outer General Exception in OTE (%s).",op.c_str());
        }

     }// debug while
}

#endif /* REGISTRY_X */