#include "DataChannel.h"
#include "CoAnalysisServer.h"
#include "AnalysisTask.h"
#include "ConfigCenter.h"
#include <QDebug>
DataChannel::DataChannel(CoAnalysisServer * powner):m_pAsvr(powner)
{
		m_taskPtr=NULL;
		memset(m_channeldesc,0,sizeof(m_channeldesc));
		m_graphPtr=NULL;
		m_setmumvale=false;
}
DataChannel::~DataChannel()
{

}
void  DataChannel::ReSetAnalysisTaskOwner(AnalysisTask *task)
{
	m_taskPtr=task;
}
void DataChannel::SetChannelDesc(const char * desc)
{
	_snprintf(m_channeldesc,NAME_LEN,"%s",desc);
}

const char * DataChannel::GetChannelDesc()
{
	return m_channeldesc;
}
void DataChannel::SetLineStyle(enum LineStyle style)
{
	m_linestyle=style;
}
enum LineStyle DataChannel::GetLineStyle()
{
	return m_linestyle;
}
void DataChannel::UpdateData(int type,void * data,size_t len)
{

	 m_datalock.lock();
	 std::map<int,std::vector<std::tuple<double,void *>> >::iterator it=m_alldata.find(type);
	 if(it==m_alldata.end())
	 {
				void *ptr=malloc(len);
				assert(ptr!=NULL);
				memcpy(ptr,data,len);
	
				std::tuple<double,void *> tu(CSingleton<ConfigCenter>::instance()->get_time_elapsed(),ptr);
				 std::vector<std::tuple<double,void *>> vec;
				 vec.push_back(tu);
				m_alldata.insert(std::pair<int, std::vector<std::tuple<double,void *>> >(type,vec));
		

	}else{
				void *ptr=malloc(len);
				assert(ptr!=NULL);
				memcpy(ptr,data,len);
			
				std::tuple<double,void *> tu(CSingleton<ConfigCenter>::instance()->get_time_elapsed(),ptr);
				it->second.push_back(tu);

	}
	m_datalock.unlock();
	//m_taskPtr->OnNewChannelDataRecvied();
	emit NewChannelDataRecvied();
}

void DataChannel::GetRealTimeDataVector(QVector<double>& tvar,QVector<double>& yvar,QString& graphname)
{
	tvar.clear();
	yvar.clear();
	m_datalock.lock();
	std::map<int,std::vector<std::tuple<double,void *>> >::iterator it=m_alldata.begin();
	for(;it!=m_alldata.end();it++)
	{
		switch(it->first)
		{
		case MSG_BITRATE_REPORT:
			{
				graphname=QString("%1 BitRate").arg(m_channeldesc);
				std::vector<std::tuple<double,void *>>::iterator it2=it->second.begin();
				for(;it2!=it->second.end();it2++)
				{
				
					BitRateReport *ptr=(BitRateReport*)(std::get<1>(*it2));
					if(!m_setmumvale)
					{
						m_maximumvale=m_minimumvale=ptr->bitrate;
						m_setmumvale=true;
					}else{
						if(m_maximumvale<ptr->bitrate)
						{
							m_maximumvale=ptr->bitrate;
						}

						if(m_minimumvale>ptr->bitrate)
						{
							m_minimumvale=ptr->bitrate;
						}

					}
					tvar.push_back(std::get<0>(*it2));
					yvar.push_back(ptr->bitrate);
				}
				break;

			}
		case MSG_SLICEINDEX_REPORT:
			{
				graphname=QString("%1 ").arg(m_channeldesc);
				std::vector<std::tuple<double,void *>>::iterator it2=it->second.begin();
				for(;it2!=it->second.end();it2++)
				{

					SliceIndexReport *ptr=(SliceIndexReport*)(std::get<1>(*it2));
					if(!m_setmumvale)
					{
						m_maximumvale=m_minimumvale=(ptr->groupindex+ptr->sliceindex+ptr->packetindex);
						m_setmumvale=true;
					}else{
						if(m_maximumvale<(ptr->groupindex+ptr->sliceindex+ptr->packetindex))
						{
							m_maximumvale=(ptr->groupindex+ptr->sliceindex+ptr->packetindex);
						}

						if(m_minimumvale>(ptr->groupindex+ptr->sliceindex+ptr->packetindex))
						{
							m_minimumvale=(ptr->groupindex+ptr->sliceindex+ptr->packetindex);
						}

					}
					tvar.push_back(std::get<0>(*it2));
					yvar.push_back(ptr->groupindex+ptr->sliceindex+ptr->packetindex);
				}
				break;

			}
		default:
			break;
		}
	}
	m_datalock.unlock();
}
double DataChannel::GetMaximumValue()
{
	if(!m_setmumvale)
		return 0;
	return m_maximumvale;
}

double DataChannel::GetMinimumValue()
{
	if(!m_setmumvale)
			return 0;
	return m_minimumvale;
}
QCPGraph *     DataChannel::GetGraph()
{
	return m_graphPtr;
}
void     DataChannel::SetGraph(QCPGraph *       graphPtr)
{
	m_graphPtr=graphPtr;
}
void DataChannel::DataChannelRecvHead(struct ClientMs *pConnect, void *pUserData) 
{
	DataChannel *pChannel = (DataChannel *) pUserData;

	struct timeval tvTmp = {0, 100000};
	uint32_t nErrorCode = 0;
	size_t nRecv = ClientMsRead(pConnect, &pChannel->m_tHead, sizeof(MessageHead));
	if (nRecv == sizeof(MessageHead)) {
		if (pChannel->m_tHead.length <= RECV_BUF_MAX_SIZE) {
			if (pChannel->m_tHead.flag == PACKET_HEAD_FLAGS) {
				if (pChannel->m_tHead.length > 0) {
					ClientMsSetCb(pChannel->m_pConnect, DataChannelRecvBody, NULL,CoAnalysisServer::DataChannelEvent, pChannel);
					// ClientMsSetWaterMark(pSes->pConnect, EV_READ, pSes->tHead.length-sizeof(MessageHead), RECV_BUF_MAX_SIZE);
					ClientMsSetWaterMark(pChannel->m_pConnect, EV_READ, pChannel->m_tHead.length, RECV_BUF_MAX_SIZE);
				} else {
					if (-1 == PtcSplitterParser(pChannel->m_pAsvr->m_pSvrSplitter, &(pChannel->m_tHead.type), NULL, 0, pChannel)) {
						derf("ClientSessionRecvHead--->PtcSplitterParser failed,head 's type:%d,id:",pChannel->m_tHead.type,pChannel->m_nGateSid);
						return;
					}
				}
				return;
			} else {
				derf("Head-Flag verify error,flag:%d,id:%u",pChannel->m_tHead.flag,pChannel->m_nGateSid);
				nErrorCode=-1;
			}
		} else {
			derf("Head-Length verify error,length:%d,id:%u",pChannel->m_tHead.length,pChannel->m_nGateSid);
			nErrorCode=-2;
		}
	} else {
		derf("Head-Size verify error,nRecv:%lu,id:",nRecv,pChannel->m_nGateSid);
		nErrorCode=-3;
	}
	CoAnalysisServer::ClientSessionErrorSend(pChannel, nErrorCode);
	event_add(pChannel->m_eventErrClose, &tvTmp);
	return;
}
void DataChannel::DataChannelRecvBody(struct ClientMs *pConnect, void *pUserData) 
{
	DataChannel *pChannel = (DataChannel *) pUserData;

	uint8_t bufTmp[RECV_BUF_MAX_SIZE];

	
	uint32_t nErrorCode = 0;
	struct timeval tvTmp = {0, 100000};
	size_t nRecv = ClientMsRead(pConnect, bufTmp, pChannel->m_tHead.length);

	do {
		if ((int32_t) nRecv == pChannel->m_tHead.length) {
			ClientMsSetCb(pChannel->m_pConnect, DataChannelRecvHead, NULL,CoAnalysisServer::DataChannelEvent, pChannel);
			ClientMsSetWaterMark(pChannel->m_pConnect, EV_READ, sizeof(MessageHead), RECV_BUF_MAX_SIZE);
			
			if (-1 == PtcSplitterParser(pChannel->m_pAsvr->m_pSvrSplitter, &(pChannel->m_tHead.type), bufTmp, nRecv, pChannel)) {
				ShowValue(&pChannel->m_tHead, sizeof(MessageHead));
				derf("ClientSessionRecvHead--->PtcSplitterParser failed,head 's type:%d,id:",pChannel->m_tHead.type,pChannel->m_nGateSid);
		
			}
			return;
		} else {
			derf("Body-Head-Length verify error,nRecv:%lu,id:%u" ,nRecv,pChannel->m_nGateSid);
			nErrorCode=-4;
			break;
		}
	} while (0);
	CoAnalysisServer::ClientSessionErrorSend(pChannel, nErrorCode);
	event_add(pChannel->m_eventErrClose, &tvTmp);
}