#include "qappctrl.h"
#include "../../src/defines.h"

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

QGfaAppInfo::QGfaAppInfo(int nIndex, QObject *pParent) :	QObject(pParent),
															m_state(GIAS_StateNotRunning),
															m_nIndex(nIndex),
															m_cycInt(0),
															m_cycCur(0),
															m_cycMin(0),
															m_cycMax(0),
															m_wktCur(0),
															m_wktMin(0),
															m_wktMax(0),
															m_upTime(0),
															m_cpuTime(0.0),
															m_cpuPercCur(0.0),
															m_cpuPercAvg(0.0),
															m_vmPeak(0),
															m_vmSize(0),
															m_vmHWM(0),
															m_vmRSS(0),
															m_appSize(0)
{
	m_nAppID = 1ull << m_nIndex;
	setStateText(m_state);
    setObjectName("QGfaAppInfo");
}

QGfaAppInfo::~QGfaAppInfo(void)
{
	this->disconnect();
}

/////////////////////////////////////////////////////////////////////////////

appid_t QGfaAppInfo::appId(void) const
{
	return m_nAppID;
}

/////////////////////////////////////////////////////////////////////////////

int QGfaAppInfo::state(void) const
{
	return m_state;
}

bool QGfaAppInfo::setState(int val)
{
	if(m_state != val)
	{
		m_state = val;
		emit stateChanged(val);
		setStateText(val);
		return true;
	}

	return false;
}

/////////////////////////////////////////////////////////////////////////////

QString QGfaAppInfo::stateText(void) const
{
	return m_stateText;
}

void QGfaAppInfo::setStateText(int val)
{
	QString sval = ::GfaIpcAppCtrlGetStateText((GfaIpcAppStates)val);
	if(m_stateText != sval)
	{
		m_stateText = sval;
		emit stateTextChanged(sval);
	}
}

/////////////////////////////////////////////////////////////////////////////

QString QGfaAppInfo::name(void) const
{
	return m_name;
}

void QGfaAppInfo::setName(const QString &val)
{
	if(m_name != val)
	{
		m_name = val;
		emit nameChanged(val);
	}
}

/////////////////////////////////////////////////////////////////////////////

quint64 QGfaAppInfo::cycInt(void) const
{
	return m_cycInt;
}

quint64 QGfaAppInfo::cycCur(void) const
{
	return m_cycCur;
}

quint64 QGfaAppInfo::cycMin(void) const
{
	return m_cycMin;
}

quint64 QGfaAppInfo::cycMax(void) const
{
	return m_cycMax;
}


quint64 QGfaAppInfo::wktCur(void) const
{
	return m_wktCur;
}

quint64 QGfaAppInfo::wktMin(void) const
{
	return m_wktMin;
}

quint64 QGfaAppInfo::wktMax(void) const
{
	return m_wktMax;
}


quint64 QGfaAppInfo::upTime(void) const
{
	return m_upTime;
}

double QGfaAppInfo::cpuTime(void) const
{
	return m_cpuTime;
}

double QGfaAppInfo::cpuCur(void) const
{
	return m_cpuPercCur;
}

double QGfaAppInfo::cpuAvg(void) const
{
	return m_cpuPercAvg;
}

quint32 QGfaAppInfo::vmPeak(void) const
{
	return m_vmPeak;
}

quint32 QGfaAppInfo::vmSize(void) const
{
	return m_vmSize;
}

quint32 QGfaAppInfo::vmHWM(void) const
{
	return m_vmHWM;
}

quint32 QGfaAppInfo::vmRSS(void) const
{
	return m_vmRSS;
}

quint32 QGfaAppInfo::appSize(void) const
{
	return m_appSize;
}

void QGfaAppInfo::setAppSize(quint32 size, GfaIpcAppStates state)
{
	if((state > GIAS_StateNotRunning) && (state < GIAS_Invalid))
	{
		if(m_appSize != size)
		{
			m_appSize = size;
			emit appSizeChanged(m_appSize);
		}
	}
	else
	{
		if(m_appSize != 0)
		{
			m_appSize = 0;
			emit appSizeChanged(m_appSize);
		}
	}
}

void QGfaAppInfo::setAppMemInfo(LPCGFA_APPCTRL_APPMEM pam, GfaIpcAppStates state, bool bDoHeavyLoadUpdate)
{
	UNUSED(state);
	
	if(pam)
	{
		if(bDoHeavyLoadUpdate)
		{
			if(m_vmPeak != pam->vmPeak)
			{
				m_vmPeak = pam->vmPeak;
				emit vmPeakChanged(m_vmPeak);
			}

			if(m_vmSize != pam->vmSize)
			{
				m_vmSize = pam->vmSize;
				emit vmSizeChanged(m_vmSize);
			}

			if(m_vmHWM != pam->vmHWM)
			{
				m_vmHWM = pam->vmHWM;
				emit vmHWMChanged(m_vmHWM);
			}

			if(m_vmRSS != pam->vmRSS)
			{
				m_vmRSS = pam->vmRSS;
				emit vmRSSChanged(m_vmRSS);
			}
		}
	}
	else if(state != GIAS_Hanging)
	{
		if(m_vmPeak != 0)
		{
			m_vmPeak = 0;
			emit vmPeakChanged(m_vmPeak);
		}

		if(m_vmSize != 0)
		{
			m_vmSize = 0;
			emit vmSizeChanged(m_vmSize);
		}

		if(m_vmHWM != 0)
		{
			m_vmHWM = 0;
			emit vmHWMChanged(m_vmHWM);
		}

		if(m_vmRSS != 0)
		{
			m_vmRSS = 0;
			emit vmRSSChanged(m_vmRSS);
		}
	}
}

void QGfaAppInfo::setAppTimes(LPCGFA_APPCTRL_APPTIMES pat, GfaIpcAppStates state, bool bDoHeavyLoadUpdate)
{
	if(pat)
	{
		if(m_cycInt != (quint64)pat->nCyclePresetUs)
		{
			m_cycInt = (quint64)pat->nCyclePresetUs;
			emit cycIntChanged(m_cycInt);
		}

		if(state == GIAS_Running)
		{
			if(m_cycMin != (quint64)pat->nCycleMinUs)
			{
				m_cycMin = (quint64)pat->nCycleMinUs;
				emit cycMinChanged(m_cycMin);
			}

			if(m_cycMax != (quint64)pat->nCycleMaxUs)
			{
				m_cycMax = (quint64)pat->nCycleMaxUs;
				emit cycMaxChanged(m_cycMax);
			}

			if(m_wktMin != (quint64)pat->nWorkMinUs)
			{
				m_wktMin = (quint64)pat->nWorkMinUs;
				emit wktMinChanged(m_wktMin);
			}

			if(m_wktMax != (quint64)pat->nWorkMaxUs)
			{
				m_wktMax = (quint64)pat->nWorkMaxUs;
				emit wktMaxChanged(m_wktMax);
			}
		}
		else
		{
			if(m_cycCur != 0)
			{
				m_cycCur = 0;
				emit cycCurChanged(m_cycCur);
			}

			if(m_wktCur != 0)
			{
				m_wktCur = 0;
				emit wktCurChanged(m_wktCur);
			}
		}

		if(bDoHeavyLoadUpdate)
		{
			quint64 upTime = time(NULL) - pat->nTsStart;
			
			if(m_upTime != upTime)
			{
				m_upTime = upTime;
				emit upTimeChanged(m_upTime);
			}

			if(state == GIAS_Running)
			{
				if(m_cycCur != (quint64)pat->nCycleLastUs)
				{
					m_cycCur = (quint64)pat->nCycleLastUs;
					emit cycCurChanged(m_cycCur);
				}

				if(m_wktCur != (quint64)pat->nWorkLastUs)
				{
					m_wktCur = (quint64)pat->nWorkLastUs;
					emit wktCurChanged(m_wktCur);
				}
			}
			
			if(state != GIAS_Hanging)
			{
				if(m_cpuTime != pat->fCpuTime)
				{
					m_cpuTime = pat->fCpuTime;
					emit cpuTimeChanged(m_cpuTime);
				}
				
				if(m_cpuPercCur != pat->fCpuCur)
				{
					m_cpuPercCur = pat->fCpuCur;
					emit cpuCurChanged(m_cpuPercCur);
				}
				
				if(m_cpuPercAvg != pat->fCpuAvg)
				{
					m_cpuPercAvg = pat->fCpuAvg;
					emit cpuAvgChanged(m_cpuPercAvg);
				}
			}
		}
	}
	else
	{
		if(m_cycInt != 0)
		{
			m_cycInt = 0;
			emit cycIntChanged(m_cycInt);
		}

		if(m_cycCur != 0)
		{
			m_cycCur = 0;
			emit cycCurChanged(m_cycCur);
		}

		if(m_wktCur != 0)
		{
			m_wktCur = 0;
			emit wktCurChanged(m_wktCur);
		}

		if(state == GIAS_Hanging)
		{
			if(m_cpuTime != -1)
			{
				m_cpuTime = -1;
				emit cpuTimeChanged(m_cpuTime);
			}
			
			if(m_cpuPercCur != -1)
			{
				m_cpuPercCur = -1;
				emit cpuCurChanged(m_cpuPercCur);
			}
			
			if(m_cpuPercAvg != -1)
			{
				m_cpuPercAvg = -1;
				emit cpuAvgChanged(m_cpuPercAvg);
			}
		}
		else
		{
			if(m_cycMin != 0)
			{
				m_cycMin = 0;
				emit cycMinChanged(m_cycMin);
			}

			if(m_cycMax != 0)
			{
				m_cycMax = 0;
				emit cycMaxChanged(m_cycMax);
			}

			if(m_wktMin != 0)
			{
				m_wktMin = 0;
				emit wktMinChanged(m_wktMin);
			}

			if(m_wktMax != 0)
			{
				m_wktMax = 0;
				emit wktMaxChanged(m_wktMax);
			}

			if(m_upTime != 0)
			{
				m_upTime = 0;
				emit upTimeChanged(m_upTime);
			}
				
			if(m_cpuTime != 0)
			{
				m_cpuTime = 0;
				emit cpuTimeChanged(m_cpuTime);
			}
			
			if(m_cpuPercCur != 0)
			{
				m_cpuPercCur = 0;
				emit cpuCurChanged(m_cpuPercCur);
			}
			
			if(m_cpuPercAvg != 0)
			{
				m_cpuPercAvg = 0;
				emit cpuAvgChanged(m_cpuPercAvg);
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////

bool QGfaAppInfo::pause(void)
{
	emit sendControlMessage(m_nAppID, GFA_APPCTRL_CTRLMSG_PAUSE);
	return true;
}

bool QGfaAppInfo::resume(void)
{
	emit sendControlMessage(m_nAppID, GFA_APPCTRL_CTRLMSG_RESUME);
	return true;
}

bool QGfaAppInfo::stop(void)
{
	emit sendControlMessage(m_nAppID, GFA_APPCTRL_CTRLMSG_STOP);
	return true;
}