///
/// \file   channelRegalia.h
///
/// Classes are:
/// ChannelRegalia
/// ChannelRequestMetaData
/// ChannelRequestMetaDataClient
/// ChannelRequestMetaDataRepository
/// ChannelRequestStatus
///
/// \author Jan Chrin, PSI
/// \date   Release: February 2015
/// \version CAFE 1.0.0
///

#ifndef CHANNELINFO_H
#define CHANNELINFO_H

#include <cstring>
#include <statusCodes.h>
#include <defines.h>
#include <cafeEnum.h>

//required for channelDataStore
#include <PVDataHolder.h>
#include <PVCtrlHolder.h>





/**
 *  Struct defining channel properties and connection status for use in Conduit container
 *
 */
class ChannelRegalia
{
private:
    CAFEStatus cafeStatus;
public:
    friend struct change_accessRightsHandlerArgs;
    friend struct change_accessRead;
    friend struct change_accessWrite;
    friend struct change_channelID;
    friend struct change_connectionHandlerArgs;
    friend struct change_eventHandlerArgs;
    //friend struct change_channelRegalia;
    friend class  Connect;
    friend class  HandleHelper;
    friend class  Conduit;
    friend class  ConduitGroup;
protected:
    chid                channelID;              //
    bool                connectFlag;
    const char *              hostName;
    unsigned int        nelem;                  //native
    chtype              dataType;               //native
    unsigned short      accessRead;             //0 or 1
    unsigned short      accessWrite;            //0 or 1
    dbr_class_name_t    className;              //dbr_string_t
    //connectionState as given by connection_handler args: CA_OP_CONN_UP or CA_OP_CONN_DOWN
    int                 connectionState;       //as given by CA_OP_
    int                 cafeConnectionState;   //as given by cafe_cs_state in statusCodes

    //void                setChannelID    (chid id)       {channelID=id;};
    void                setConnectFlag  (bool c)
    {
        connectFlag=c;
    };
    void                setHostName     (const char * h)
    {
        hostName=h;
    };
    void                setDataType     (chtype d)
    {
        dataType=d;
    };
    void                setAccessRead (unsigned short r)
    {
        accessRead=r;
    };
    void                setAccessWrite(unsigned short w)
    {
        accessWrite=w;
    };
    void                setReadAccess (unsigned short r)
    {
        accessRead=r;
    };
    void                setWriteAccess(unsigned short w)
    {
        accessWrite=w;
    };
    void                setNelem      (unsigned int  n)
    {
        nelem=n;
    };
    void                setConnectionState     (int cs)
    {
        connectionState=cs;
    };
    void                setCafeConnectionState (int ccs)
    {
        cafeConnectionState=ccs;
    };

public:
    chid                getChannelID()  const
    {
        return channelID;
    };
    bool                getConnectFlag()const
    {
        return connectFlag;
    };
    const char *        getHostName()   const
    {
        return hostName;
    };
    std::string         getHostNameAsString()
    {
        std::string h= hostName;
        return h;
    };
    chtype              getDataType()   const
    {
        return dataType;
    };
    const char *        getClassName()  const
    {
        return className;
    };
    std::string         getClassNameAsString()
    {
        std::string c=className;
        return c;
    };
    unsigned short      getAccessRead() const
    {
        return accessRead;
    };
    unsigned short      getAccessWrite()const
    {
        return accessWrite;
    };
    unsigned short      getReadAccess() const
    {
        return accessRead;
    };
    unsigned short      getWriteAccess()const
    {
        return accessWrite;
    };
    unsigned int        getNelem()      const
    {
        return nelem;
    };
    int                 getConnectionState()       const
    {
        return connectionState;
    };
    int                 getCafeConnectionState()   const
    {
        return cafeConnectionState;
    };
    std::string         getConnectionStateAsString()
    {
        if(connectionState==CA_OP_CONN_UP)
        {
            return "CA_OP_CONN_UP";
        }
        else if(connectionState==CA_OP_CONN_DOWN)
        {
            return "CA_OP_CONN_DOWN";
        }
        else
        {
            return "CA_OP_CONN is UNKNOWN: THIS SHOULD NEVER APPEAR!";
        }
    };

    std::string getCafeConnectionStateAsString()
    {
        return cafeStatus.csc.message(cafeConnectionState);
    };

    ChannelRegalia():channelID((chid) NULL), connectFlag(false), nelem((unsigned int) 1),
        dataType(chtype((int)CAFE_TYPENOTCONN)),
        accessRead((unsigned short) 0), accessWrite((unsigned short) 0),
        connectionState((int) CA_OP_CONN_DOWN), cafeConnectionState((int) ICAFE_CS_NEVER_CONN)
    {
        strcpy(className, "");
        hostName="";
    };

    ~ChannelRegalia() {};
};









/**
 *  Struct defining channel properties and connection status for use in displays
 *
 */
class ChannelDataStore
{
public:

    std::string         description;
    ChannelRegalia      info;
    PVDataHolder        pvd;
    PVCtrlHolder        pvc;

    ChannelDataStore()
    {


    };

    ~ChannelDataStore() {};

};




/**
 *  Stores strings for Enum datatypes
 *
 */
class ChannelEnumStrings
{
public:
    friend struct change_eventHandlerArgs;
private:
    char  options [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
    short noOptions;
public:
    ChannelEnumStrings():noOptions( (short) 0) {};
    short getNoOptions() const
    {
        return noOptions;
    };
    std::vector<std::string> getOptions() const
    {
        std::vector<std::string> optionsV;
        optionsV.reserve(noOptions);
        for ( short i=0; i<noOptions; ++i)
        {
            optionsV.push_back(options[i]);
        }
        return optionsV;
    };
};


/**
 *  Stores device/attribute pairing
 *
 */
class ChannelDeviceAttribute
{
private:
    std::string pv;
    std::string device;
    std::string attribute;
    std::string deliminator;
public:
    ChannelDeviceAttribute() {};
    ~ChannelDeviceAttribute() {};

    int  init(std::string _pv, std::string _deliminator)
    {
        pv=_pv;
        deliminator=_deliminator;
        short posOfSeparator=pv.find_first_of(deliminator);
        if (posOfSeparator<0)
        {
            device="";
            attribute="";
            return ECAFE_DEVICE_ATTRIB_NOT_FOUND;
        }
        else
        {
            device= pv.substr(0,posOfSeparator);
            attribute=pv.substr(posOfSeparator+1,pv.size());
            //Check for .VAL and remove
            std::size_t found = attribute.find(".");
            if (found != std::string::npos)
            {
                attribute=attribute.substr(0, found);
            }
        }
        return ICAFE_NORMAL;
    };

    const char * getDeliminator() const
    {
        return deliminator.c_str();
    };
    const char * getDevice()      const
    {
        return device.c_str();
    };
    const char * getAttribute()   const
    {
        return attribute.c_str();
    };
    const char * getAttrib()      const
    {
        return attribute.c_str();
    };
    std::string getDeliminatorAsString() const
    {
        return deliminator;
    };
    std::string getDeviceAsString()      const
    {
        return device;
    };
    std::string getAttributeAsString()   const
    {
        return attribute;
    };
};


/**
 *   0. Struct defining channel datatype/nelem executed by CAFE for use in Conduit container
 *
 */
class ChannelRequestMetaData
{
public:
    friend struct change_connectionHandlerArgs;
    friend struct change_dataBufferSize_CTRL;
    friend struct change_dataBufferSize_TIME;
    friend struct change_dataBufferSize_PRIMITIVE;
    friend struct change_dataBufferSize_STSACK;
    friend struct change_eventHandlerArgs;

    friend struct copy_channelRequestMetaDataToChannelRequestMetaDataRepository;

    friend class  Conduit;
    friend class  ConduitGroup;

protected:
    chid                channelID;              //of requested item
    unsigned int        nelem;                  //depends on Policy
    unsigned int        nelemCache;             //nelem To Retrieve From Cache
    chtype              dataType;               //depends on Policy
    chtype              dbrDataType;            //depends on Policy
    CAFENUM::DBR_TYPE   cafeDbrType;
    void *              usrArg;                 //from Conduit.usrArg
    unsigned int        byteSize;               //data buffer (bytes) must be large enough to store data
    unsigned int        offset;

public:
    void setNelem(unsigned int  n)
    {
        nelem= n > 0 ? n : 1;
        //nelemCache= nelem > nelemCache ? nelemCache : nelem;
    }; // byteSize=dbr_size_n(dbrDataType,nelem); };
    void setNelemCache(unsigned int  n)
    {
        nelemCache= n > 0 ? n : 1;
    }
    void setUsrArg(void * u)
    {
        usrArg=u;
    };
    void setDataType(chtype d)
    {
        dataType=d;
    };
    void setDbrDataType(chtype dbr)
    {
        dbrDataType=dbr;
    }; //byteSize=dbr_size_n(dbrDataType,nelem);};
    void setCafeDbrType(CAFENUM::DBR_TYPE cd)
    {
        cafeDbrType=cd;
    };
    void setDbrTypesFromCafeDbrType(CAFENUM::DBR_TYPE cd)
    {
        cafeDbrType=cd;
        switch(cafeDbrType)
        {
        case CAFENUM::DBR_TIME:
            dbrDataType = dbf_type_to_DBR_TIME(dataType);
            break;
        case CAFENUM::DBR_STS:
            dbrDataType = dbf_type_to_DBR_STS(dataType);
            break;
        case CAFENUM::DBR_PRIMITIVE:
            dbrDataType = dbf_type_to_DBR(dataType);
            break;
        default:
            //Print Warning Message?
            dbrDataType = dbf_type_to_DBR_TIME(dataType);
            cafeDbrType = CAFENUM::DBR_TIME;
            break;
        }
    };


    void setByteSize(unsigned int  b)
    {
        byteSize=b;
    };

    unsigned int  getNelem() const
    {
        return nelem;
    };
    unsigned int  getNelemCache() const
    {
        return nelemCache;
    };
    void * getUsrArg() const
    {
        return usrArg;
    };
    chtype getDataType() const
    {
        return dataType;
    };
    chtype getDbrDataType() const
    {
        return dbrDataType;
    };
    CAFENUM::DBR_TYPE getCafeDbrType() const
    {
        return cafeDbrType;
    };

    unsigned int  getByteSize() const
    {
        return byteSize;
    };

    void setOffset(unsigned int o)
    {
        offset=o;
    };
    unsigned int getOffset() const
    {
        return offset;
    };

    //Constructors
    ChannelRequestMetaData():channelID((chid) NULL), nelem((unsigned int) 1), nelemCache((unsigned int) 1),
        dataType((chtype) DBF_NO_ACCESS), dbrDataType((chtype) TYPENOTCONN), //
        cafeDbrType( (CAFENUM::DBR_TYPE) NULL),
        usrArg((void *) NULL), byteSize((unsigned int) 0), offset((unsigned int) 0)
    {

    }; //CAStatus((long) ECA_NORMAL){};

    ~ChannelRequestMetaData() {};
};


/**
 *  -1. Struct defining channel datatype/nelem requested by client for use in Conduit container
 *
 */
class ChannelRequestMetaDataClient: public ChannelRequestMetaData
{
public:

//protected:
    //unsigned int        offset;
public:
    //void setOffset(unsigned int o) {offset=o;};
    //unsigned int getOffset() const {return offset;};

    //Constructors
    ChannelRequestMetaDataClient() {}; //:offset((unsigned int) 0){};
    ~ChannelRequestMetaDataClient() {};
};


/**
 *  Gives status of the Request message \n
 *  messageStatus = requestStatus if requestStatus != ECA_NORMAL else \n
 *  messageStatus = requestStatus or messageStatus=callbackStatus (if policy WITH_CALLBACK)
 *
 */
class ChannelRequestStatus
{

private:
    int  preRequestStatus;  // current status of channel
    int  requestStatus;     // from get/put operation
    int  pendStatus;        // from pend_io operation
    int  callbackStatus;    // used by CAFE::waitForEvent() to record status of callback
    int  messageStatus;     // overall status
    CAFENUM::StatusMessageKind messageKind;  // statusMessageKind indicating method status occuping overall messageStatus

    bool hasCallbackInitiated;
    bool hasCallbackTriggered;
    CAFENUM::CallbackProgressKind callbackProgressKind;

public:
    int  getPreRequestStatus()  const
    {
        return preRequestStatus;
    };
    int  getRequestStatus()     const
    {
        return requestStatus;
    };
    int  getPendStatus()        const
    {
        return pendStatus;
    };
    int  getCallbackStatus()    const
    {
        return callbackStatus;
    };
    int  getMessageStatus()     const
    {
        return messageStatus;
    };
    CAFENUM::StatusMessageKind    getMessageKind()           const
    {
        return messageKind;
    };
    CAFENUM::CallbackProgressKind getCallbackProgressKind()  const
    {
        return callbackProgressKind;
    };

    void setPreRequestStatus (int s)
    {
        preRequestStatus=s;
        messageStatus=s;
        messageKind=(CAFENUM::StatusMessageKind) CAFENUM::PRE_REQUEST;
    };
    void setRequestStatus    (int r)
    {
        requestStatus = r;
        messageStatus=r;
        messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_REQUEST;
    };
    void setPendStatus       (int p)
    {
        pendStatus    = p;
        messageStatus=p;
        messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_PEND;
    };
    void setCallbackStatus   (int c)
    {
        callbackStatus= c;
        messageStatus=c;
        messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_CALLBACK;
    };
    void setCallbackKind     (bool hasInit, bool hasTrig)
    {
        hasCallbackInitiated=hasInit;
        hasCallbackTriggered=hasTrig;
        if      ( hasInit && !hasTrig)
        {
            callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::PENDING;
        }
        else if (!hasInit &&  hasTrig)
        {
            callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::COMPLETE;
        }
        else if (!hasInit && !hasTrig)
        {
            callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::NOT_INITIATED;
        }
        else
        {
            std::cout << "CAFE INTERNAL POLICY ERROR" << std::endl;
            std::cout << "ChannelRequestStatus::setCallbackKind gives an INVALID callbackProgressKind" << std::endl;
        }
    };
    //void setMessageStatus    (long mstatus) {messageStatus = mstatus;};
    // void setMessageKind      (StatusMessageKind mkind) { if (mkind<=CAFENUM::FROM_CALLBACK && mkind >= CAFENUM::PRE_REQUEST)
    //   {messageKind = mkind;} else {cout<< mkind << " is an invalid statusMessageKind!" << endl;}};

    ChannelRequestStatus():preRequestStatus(ICAFE_CS_NEVER_CONN),requestStatus(ICAFE_CS_NEVER_CONN),pendStatus(ICAFE_CS_NEVER_CONN),
        callbackStatus(ICAFE_CS_NEVER_CONN),messageStatus(ICAFE_CS_NEVER_CONN),messageKind((CAFENUM::StatusMessageKind) CAFENUM::NO_MESSAGE),
        hasCallbackInitiated(false),hasCallbackTriggered(false),callbackProgressKind((CAFENUM::CallbackProgressKind) CAFENUM::NOT_INITIATED) {};
};

#endif // CHANNELINFO_H