/*******************************************************************************
 * unittests/libretroshare/gxs/gen_exchange/genexchangetester.h                *
 *                                                                             *
 * Copyright (C) 2018, Retroshare team <retroshare.team@gmailcom>              *
 *                                                                             *
 * This program is free software: you can redistribute it and/or modify        *
 * it under the terms of the GNU Affero General Public License as              *
 * published by the Free Software Foundation, either version 3 of the          *
 * License, or (at your option) any later version.                             *
 *                                                                             *
 * This program is distributed in the hope that it will be useful,             *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                *
 * GNU Lesser General Public License for more details.                         *
 *                                                                             *
 * You should have received a copy of the GNU Lesser General Public License    *
 * along with this program. If not, see <https://www.gnu.org/licenses/>.       *
 *                                                                             *
 ******************************************************************************/

#ifndef GENEXCHANGETESTER_H
#define GENEXCHANGETESTER_H

#include "genexchangetestservice.h"
#include "gxs/rsgds.h"
#include "gxs/rsnxs.h"

bool operator ==(const RsMsgMetaData& lMeta, const RsMsgMetaData& rMeta);
bool operator ==(const RsDummyMsg& lMsg, const RsDummyMsg& rMsg);
bool operator ==(const RsGxsGrpItem& lMsg, const RsGxsGrpItem& rMsg);

bool operator ==(const RsGroupMetaData& lMeta, const RsGroupMetaData& rMeta);
bool operator ==(const RsDummyGrp& lMsg, const RsDummyGrp& rMsg);
bool operator ==(const RsGxsMsgItem& lMsg, const RsGxsMsgItem& rMsg);

/*!
 * The idea of GenExchangeTest is to simplify test
 * of the RsGenExchange via the RsGxsDummyService
 * One can test all publish/request/meta-modify
 * capabilities of RsGenExchange
 * Simplifications comes from: \n
 *
 * - ability to store in and out data for comparison (in data are
 *   usually from requests, out data are from publications,
 *   but generally what you want to compare) \n
 * - convenience function to poll tokens \n
 *   - also allows filling in-data automatically from polls \n
 * - convenience interface for running tests
 */
class GenExchangeTest
{
public:

	/*!
	 * Constructs the GenExchangeTest with a tokenService
	 * @param tokenService This is needed. If not an instance of token service,
	 * behaviour of GenExchangeTest is undefined
	 */
	GenExchangeTest(GenExchangeTestService* const  mTestService, RsGeneralDataService* dataService, int pollingTO = 5 /* 5 secs default */);

	virtual ~GenExchangeTest();

	/*!
	 * This should be called in the main
	 * routines to execute all tests
	 * When implementing ensure units test header
	 * is in same file scope as implementation
	 * (you chould be using the CHECK functions
	 * to assert tests has passed)
	 */
	virtual void runTests() = 0;

protected:

    bool getServiceStatistic(const uint32_t &token, GxsServiceStatistic &servStatistic);
    bool getGroupStatistic(const uint32_t &token, GxsGroupStatistic &grpStatistic);

	/*!
	 * After each request and publish operation this should
	 * be called to ensure the operation has completed
	 * Requests will result in in data maps being filled
	 * @param
	 * @param opts
	 * @param fill if set to true, the received that is
	 *        routed to IN data structures
	 */
    void pollForToken(uint32_t token, const RsTokReqOptions& opts, bool fill = false);

    /*!
     * Allows to poll for token, and receive the message id
     * as acknowledgement. This function blocks for as long the
     * timeout value set on construction of tester
     * @param token
     * @param msgId
     */
    bool pollForMsgAcknowledgement(uint32_t token, RsGxsGrpMsgIdPair& msgId);

    /*!
	 * Allows to poll for token, and receive the group id
	 * as acknowledgement. This function blocks for as long the
	 * timeout value set on construction of tester
     * @param token
     * @param msgId
     */
    bool pollForGrpAcknowledgement(uint32_t token, RsGxsGroupId& msgId);

    GenExchangeTestService* getTestService();
    RsTokenService* getTokenService();
//    bool testGrpMetaModRequest();
//    bool testMsgMetaModRequest();

    // convenience functions for clearing IN and OUT data structures
    void clearMsgDataInMap();
    void clearMsgDataOutMap();
    void clearMsgMetaInMap();
    void clearMsgMetaOutMap();
    void clearMsgIdInMap();
    void clearMsgIdOutMap();
    void clearMsgRelatedIdInMap();
    void clearGrpDataInList();
    void clearGrpDataOutList();
    void clearGrpMetaInList();
    void clearGrpMetaOutList();
    void clearGrpIdInList();
    void clearGrpIdOutList();

    /*!
     * clears up all internal
     * IN and OUT data structure for
     * both msgs and groups
     * frees resources in relation to allocated data
     */
    void clearAllData();

    template <class Item>
    void deleteResVector(std::vector<Item*>& v) const
    {
    	typename std::vector<Item*>::iterator vit = v.begin();
    	for(; vit != v.end(); vit++)
    		delete *vit;
    	v.clear();
    }

    // using class to enable partial
	// function specialisation, bit of a hack in a
    // way
    template <class Cont, class Item>
    class Comparison
    {
    public:

		static bool comparison(const Cont& l, const Cont& r)
		{
			if(l.size() != r.size()) return false;

			typename Cont::const_iterator vit1 = l.begin(), vit2 = r.begin();

			while(vit1 != l.end())
			{
				const Item& item1 = (*vit1);
				const Item& item2 = (*vit2);
				if(!(item1 == item2)) return false;

				vit1++;
				vit2++;
			}
			return true;
		}
    };


    template <class Cont, class Item>
    class Comparison<Cont, Item*>
    {
    public:

		static bool comparison(const Cont& l, const Cont& r)
		{
			if(l.size() != r.size())
				return false;

			typename Cont::const_iterator vit1 = l.begin(), vit2 = r.begin();

			while(vit1 != l.end())
			{
				const Item* item1 = (*vit1);
				const Item* item2 = (*vit2);
				if(!(*item1 == *item2))
					return false;

				vit1++;
				vit2++;
			}
			return true;
		}
    };

    // convenience function for comparing IN and OUT data structures
    bool compareMsgDataMaps() ;
    bool compareMsgIdMaps() ;
    bool compareMsgMetaMaps() ;
    bool compareMsgRelateIdsMap() ;
    bool compareMsgRelatedDataMap() ;
    bool compareGrpData() ;
    bool compareGrpMeta() ;
    bool compareGrpIds() ;

    void storeToMsgDataOutMaps(const DummyMsgMap& msgDataOut);
    void storeToMsgIdsOutMaps(const GxsMsgIdResult& msgIdsOut);
    void storeToMsgMetaOutMaps(const GxsMsgMetaMap& msgMetaOut);

    void storeToMsgDataInMaps(const DummyMsgMap& msgDataOut);
	void storeToMsgIdsInMaps(const GxsMsgIdResult& msgIdsOut);
	void storeToMsgMetaInMaps(const GxsMsgMetaMap& msgMetaOut);

    void storeToGrpIdsOutList(const std::list<RsGxsGroupId>& grpIdOut);
    void storeToGrpMetaOutList(const std::list<RsGroupMetaData>& grpMetaOut);
    void storeToGrpDataOutList(const std::vector<RsDummyGrp*>& grpDataOut);

    void storeToGrpIdsInList(const std::list<RsGxsGroupId>& grpIdIn);
	void storeToGrpMetaInList(const std::list<RsGroupMetaData>& grpMetaOut);
	void storeToGrpDataInList(const std::vector<RsDummyGrp*>& grpDataOut);

    /*!
     * This sets up any resources required to operate a test
     */
    void setUp();

    /*!
     * Call at end of test to ensure resources
     * used in tests are released
     * This can invalidate other test runs if not called
     */
    void breakDown();

    /*!
     * initialises item to random data
     * @param grpItem item to initialise
     */
    void init(RsDummyGrp& grpItem) const;

    /*!
     * Initialises meta data to random data
     * @param grpMetaData
     */
    void init(RsGroupMetaData& grpMetaData) const;

    /*!
     * Initialises msg item to random data
     * @param msgItem
     */
    void init(RsDummyMsg& msgItem) const;

    /*!
     * Initialises meta data to random data
     * @param msgMetaData
     */
    void init(RsMsgMetaData& msgMetaData) const;


	void clearMsgDataMap(DummyMsgMap& msgDataMap) const;
	void clearGrpDataList(std::vector<RsDummyGrp*>& grpData) const;

    /*!
     * Helper function which sets up groups
     * data in to be used for publication
     * group data
     * @param nGrps number of groups to publish
     * @param groupId the ids for the created groups
     */
    void createGrps(uint32_t nGrps, std::list<RsGxsGroupId>& groupId);

    /*!
     * @return random number
     */
    uint32_t randNum() const;

private:

    std::vector<RsDummyGrp*> mGrpDataOut, mGrpDataIn;
    std::list<RsGroupMetaData> mGrpMetaDataOut, mGrpMetaDataIn;
    std::list<RsGxsGroupId> mGrpIdsOut, mGrpIdsIn;

    std::map<RsGxsGroupId, std::vector<RsDummyMsg*> > mMsgDataOut, mMsgDataIn;
    GxsMsgMetaMap mMsgMetaDataOut, mMsgMetaDataIn;
    GxsMsgIdResult mMsgIdsOut, mMsgIdsIn;

    MsgRelatedIdResult mMsgRelatedIdsOut, mMsgRelatedIdsIn;
    GxsMsgRelatedDataMap mMsgRelatedDataMapOut, mMsgRelatedDataMapIn;

    std::vector<RsGxsGroupId> mRandGrpIds; // ids that exist to help group testing

private:

    RsGeneralDataService* mDataService;
    GenExchangeTestService* mTestService;
    RsTokenService* mTokenService;
    int mPollingTO;
};

#endif // GENEXCHANGETESTER_H