/******************************************************************************
** 文件名:  WLScreenDataManage.c
** 描 述:   全线免筛功能据管理区
*******************************************************************************/

#include "WLScreenDataManage.h"


/** 定义静态全局变量 */
static WLSreenInfoStruct g_WLScreenStatus = {0u};    /** 全线免筛静态信息 */


/**
 * @brief 设置发送免筛序列号
 * @param[in] UINT32 seq 免筛序列号
 * @param[out] 无
 * @return 无
 * @note 无
 */
void wls_SetSendSeq(UINT32 seq)
{
	g_WLScreenStatus.sendSeq = seq;
}

/**
 * @brief 获取发送免筛序列号
 * @param[in] 无
 * @param[out] 无
 * @return UINT32 发送免筛序列号
 * @note 
 */
UINT32 wls_GetSendSeq(void)
{
	return g_WLScreenStatus.sendSeq;
}

/**
 * @brief 设置接收免筛序列号
 * @param[in] UINT32 seq 免筛序列号
 * @param[out] 无
 * @return 无
 * @note 无
 */
void wls_SetRecvSeq(UINT32 seq)
{
	g_WLScreenStatus.recvSeq = seq;
}

/**
 * @brief 获取接收免筛序列号
 * @param[in] 无
 * @param[out] 无
 * @return UINT32 接收免筛序列号
 * @note 
 */
UINT32 wls_GetRecvSeq(void)
{
	return g_WLScreenStatus.recvSeq;
}

/**
 * @brief 设置全线免筛可执行标志
 * @param[in] UINT8 全线免筛可执行标志
 * @param[out] 无
 * @return 无
 * @note 
 */
void wls_SetWLScreenProcessFlag(UINT8 flag)
{
	if ((WHOLE_LINE_SCREEN_VAILD == flag) || (WHOLE_LINE_SCREEN_UNVAILD == flag))
	{
		g_WLScreenStatus.WLScreenProcessFlag = flag;
	}
	else
	{
		g_WLScreenStatus.WLScreenProcessFlag = WHOLE_LINE_SCREEN_UNVAILD;
	}
}

/**
 * @brief 获取全线免筛可执行标志
 * @param[in] 无
 * @param[out] 无
 * @return UINT8 全线免筛可执行标志
 * @note 
 */
UINT8 wls_GetWLScreenProcessFlag(void)
{
	return g_WLScreenStatus.WLScreenProcessFlag;
}


/**
 * @brief 设置TMC全线免筛标志
 * @param[in] UINT8 TMC全线免筛标志
 * @param[out] 无
 * @return CI_SUCCESS 成功；CI_ERROR 失败
 * @note 
 */
UINT8 wls_SetWLScreenVaildFlag(UINT8 flag)
{
	UINT8 ret = CI_ERROR;
	if ((TMC_WLS_VALID == flag) || (TMC_WLS_UNVALID == flag))
	{
		g_WLScreenStatus.WLScreenVaildFlag = flag;
		ret = CI_SUCCESS;
	}
	else
	{
		g_WLScreenStatus.WLScreenVaildFlag = TMC_WLS_UNVALID;
	}
	return ret;
}

/**
 * @brief 获取TMC全线免筛标志
 * @param[in] 无
 * @param[out] 无
 * @return UINT8 TMC全线免筛标志
 * @note 
 */
UINT8 wls_GetWLScreenVaildFlag(void)
{
	return g_WLScreenStatus.WLScreenVaildFlag;
}

/**
 * @brief 设置是否存在隐藏车标志
 * @param[in] UINT8 是否存在隐藏车标志
 * @param[out] 无
 * @return CI_SUCCESS 成功；CI_ERROR 失败
 * @note 
 */
UINT8 wls_SetUTFlag(UINT8 flag)
{
	UINT8 ret = CI_ERROR;
	if ((UNKNOWN_TRAIN_UNEXIST == flag) || (UNKNOWN_TRAIN_EXIST == flag))
	{
		g_WLScreenStatus.UTFlag = flag;
		ret = CI_SUCCESS;
	}
	else
	{
		g_WLScreenStatus.UTFlag = UNKNOWN_TRAIN_EXIST;
	}
	return ret;
}

/**
 * @brief 获取是否存在隐藏车标志
 * @param[in] 无
 * @param[out] 无
 * @return UINT8 是否存在隐藏车标志
 * @note 
 */
UINT8 wls_GetUTFlag(void)
{
	return g_WLScreenStatus.UTFlag;
}

/**
 * @brief 设置入口检测标志
 * @param[in] UINT8 入口检测标志 
 * @param[out] 无
 * @return CI_SUCCESS 成功；CI_ERROR 失败
 * @note 
 */
UINT8 wls_SetEnterCheckFlag(UINT8 flag)
{
	UINT8 ret = CI_ERROR;
	if ((ENTER_OK_FLAG == flag) || (ENTER_ERROR_FLAG == flag))
	{
		g_WLScreenStatus.enterCheckFlag = flag;
		ret = CI_SUCCESS;
	}
	else
	{
		g_WLScreenStatus.enterCheckFlag = ENTER_ERROR_FLAG;
	}
	return ret;
}

/**
 * @brief 获取入口检测标志
 * @param[in] 无
 * @param[out] 无
 * @return UINT8 入口检测标志
 * @note 
 */
UINT8 wls_GetEnterCheckFlag(void)
{
	return g_WLScreenStatus.enterCheckFlag;
}

/**
* @brief 设置UT计轴信息同步
* @param[in] UINT32 dwRedunTime 冗余计时, UINT8 chUTACCnt UT计轴数目, const UINT16 *arrayUTACId 计轴Id
* @param[out] 无
* @return CI_SUCCESS 成功；CI_ERROR 失败
* @note;     
*/
UINT8 wls_SetUTACInfo(UINT32 dwRedunTime, UINT8 chUTACCnt, const UINT16 *arrayUTACId)
{
	UINT8 ret = CI_ERROR;
	UINT8 i = 0U;
	if( (MAX_UT_AC_CNT > chUTACCnt)&&(NULL != arrayUTACId))
	{
		g_WLScreenStatus.redunTime = dwRedunTime;
		g_WLScreenStatus.UTACCnt = chUTACCnt;
		(void)CommonMemSet(&g_WLScreenStatus.UTACId[0], (UINT32)sizeof(UINT16)*MAX_UT_AC_CNT, 0U, (UINT32)sizeof(UINT16)*MAX_UT_AC_CNT);
		for (i = 0U; i < MAX_UT_AC_CNT; i++)
		{
			g_WLScreenStatus.UTACId[i] = arrayUTACId[i];
		}
		ret = CI_SUCCESS;
	}
	else
	{
		g_WLScreenStatus.redunTime = 0U;
		g_WLScreenStatus.UTACCnt = 0U;
		(void)CommonMemSet(&g_WLScreenStatus.UTACId[0], (UINT32)sizeof(UINT16)*MAX_UT_AC_CNT, 0U, (UINT32)sizeof(UINT16)*MAX_UT_AC_CNT);
	}
	return ret;
}

/**
 * @brief 设置列车状态信息
 * @param[in] const WLTrainStatusInfoStruct *pInfo 列车状态信息
 * @param[out] WLTrainStatusInfoStruct *pOutInfo 列车状态
 * @return  CI_SUCCESS 成功；CI_ERROR 失败
 * @note 无
 */
static UINT8 wls_SetTrainStatusInfo(const WLTrainStatusInfoStruct *pInfo,OUT WLTrainStatusInfoStruct *pOutInfo)
{
	UINT8 ret = CI_ERROR;
	if ((NULL == pInfo) || (NULL == pOutInfo))
	{
		/** 入口参数校验失败 */
	}
	else
	{
	    ret = CI_SUCCESS;
		if ((OUT_CONTROL_STATUS == pInfo->controlStatus) || (IN_CONTROL_STATUS == pInfo->controlStatus) || (OFFLINE_CONFIRM_STATUS == pInfo->controlStatus))
		{
			; /* 成功 */
		}
		else
		{
			/** 不更新，保持失败 */
			ret = CI_ERROR;
		}

		if ((CI_SUCCESS == ret) && ((UNNEED_SCREEN == pInfo->headNeedScreen) || (NEED_SCREEN == pInfo->headNeedScreen)))
		{
			; /* 成功 */
		}
		else
		{
			/** 不更新 */
			ret = CI_ERROR;
		}

		if ((CI_SUCCESS == ret) && ((UNNEED_SCREEN == pInfo->tailNeedScreen) || (NEED_SCREEN == pInfo->tailNeedScreen)))
		{
			; /* 成功 */
		}
		else
		{
			/** 不更新 */
			ret = CI_ERROR;
		}

		if (CI_SUCCESS == ret)
		{
			pOutInfo->controlStatus = pInfo->controlStatus;
			pOutInfo->headNeedScreen = pInfo->headNeedScreen;
			pOutInfo->tailNeedScreen = pInfo->tailNeedScreen;
		}
	}
	return ret;
}


/**
 * @brief 设置上周期列车状态信息
 * @param[in] UINT16 trainID 列车ID
 * @param[in] const WLTrainStatusInfoStruct *pInfo 列车状态信息
 * @param[out] 无
 * @return  CI_SUCCESS 成功；CI_ERROR 失败
 * @note 无
 */
UINT8 wls_SetLastTrainStatusInfo(UINT16 trainID, const WLTrainStatusInfoStruct *pInfo)
{
	UINT8 ret = CI_ERROR;
	if ((0u == trainID) || (LINE_MAX_TRAIN == trainID))
	{
		/** 入口参数校验失败 */
	}
	else
	{
		ret = wls_SetTrainStatusInfo(pInfo,&g_WLScreenStatus.lastTrainStatusInfo[trainID]);
	}
	return ret;
}

/**
 * @brief 获取上周期列车状态信息
 * @param[in] UINT16 trainID 列车ID
 * @param[out] 无
 * @return const WLTrainStatusInfoStruct* 列车状态信息指针
 * @note 
 */
const WLTrainStatusInfoStruct* wls_GetLastTrainStatusInfo(UINT16 trainID)
{
	const WLTrainStatusInfoStruct* ret = NULL;
	if ((0u == trainID) || (LINE_MAX_TRAIN == trainID))
	{
		/** 入口参数校验失败 */
	}
	else
	{
		ret = &g_WLScreenStatus.lastTrainStatusInfo[trainID];
	}
	return ret;
}


/**
 * @brief 设置当前周期列车状态信息
 * @param[in] UINT16 trainID 列车ID
 * @param[in] const WLTrainStatusInfoStruct *pInfo 列车状态信息
 * @param[out] 无
 * @return  CI_SUCCESS 成功；CI_ERROR 失败
 * @note 无
 */
UINT8 wls_SetCurTrainStatusInfo(UINT16 trainID, const WLTrainStatusInfoStruct *pInfo)
{
	UINT8 ret = CI_ERROR;
	if ((0u == trainID) || (LINE_MAX_TRAIN == trainID))
	{
		/** 入口参数校验失败 */
	}
	else
	{
		ret = wls_SetTrainStatusInfo(pInfo,&g_WLScreenStatus.curTrainStatusInfo[trainID]);
	}
	return ret;
}



/**
 * @brief 获取当前周期列车状态信息
 * @param[in] UINT16 trainID 列车ID
 * @param[out] 无
 * @return const WLTrainStatusInfoStruct* 列车状态信息指针
 * @note 
 */
const WLTrainStatusInfoStruct* wls_GetCurTrainStatusInfo(UINT16 trainID)
{
	const WLTrainStatusInfoStruct* ret = NULL;
	if ((0u == trainID) || (LINE_MAX_TRAIN == trainID))
	{
		/** 入口参数校验失败 */
	}
	else
	{
		ret = &g_WLScreenStatus.curTrainStatusInfo[trainID];
	}
	return ret;
}



/**
 * @brief 设置全线免筛信息
 * @param[in] const WLSreenInfoStruct* pInfo 全线免筛信息
 * @param[out] 无
 * @return CI_SUCCESS 设置成功；CI_ERROR 设置失败
 * @note 无
 */
UINT8 wls_SetWholeLineScreeInfo(IN const WLSreenInfoStruct* pInfo)
{
	UINT8 ret = CI_ERROR;
	UINT8 processValid = CI_ERROR;
	UINT8 funRtn = CI_ERROR;
	UINT16 cycle = 0u;

	if (NULL == pInfo)
	{
		/** 入口参数错误 */
	}
	else
	{
		processValid = CI_SUCCESS;

		/** 设置发送给TMC的免筛序列号 */
		wls_SetSendSeq(pInfo->sendSeq);

		/** 设置接收TMC的免筛序列号 */
		wls_SetRecvSeq(pInfo->recvSeq);

		/** 设置全线免筛标志 */
		funRtn = wls_SetWLScreenVaildFlag(pInfo->WLScreenVaildFlag);
		if (CI_ERROR == funRtn)
		{
			processValid = CI_ERROR;
		}
		else
		{
			/** 不处理 */
		}

		/** 设置是否存在隐藏车标志 */
		if (CI_SUCCESS == processValid)
		{
			funRtn = wls_SetUTFlag(pInfo->UTFlag);
			if (CI_ERROR == funRtn)
			{
				processValid = CI_ERROR;
			}
			else
			{
				/** 不处理 */
			}
		}
		else
		{
			/** 不处理 */
		}

		/** 设置入口检测标志 */
		if (CI_SUCCESS == processValid)
		{
			funRtn = wls_SetEnterCheckFlag(pInfo->enterCheckFlag);
			if (CI_ERROR == funRtn)
			{
				processValid = CI_ERROR;
			}
			else
			{
				/** 不处理 */
			}
		}
		else
		{
			/** 不处理 */
		}

		/** 设置UT计轴信息 */
		if (CI_SUCCESS == processValid)
		{
			processValid = wls_SetUTACInfo(pInfo->redunTime, pInfo->UTACCnt, &pInfo->UTACId);
		}

		/** 设置列车状态信息 */
		if (CI_SUCCESS == processValid)
		{
			for (cycle = 1u; cycle < LINE_MAX_TRAIN; cycle++)
			{
				funRtn = wls_SetCurTrainStatusInfo(cycle,&pInfo->curTrainStatusInfo[cycle]);
				if (CI_ERROR == funRtn)
				{
					processValid = CI_ERROR;
				}
				else
				{
					/** 不处理 */
				}

				funRtn = wls_SetLastTrainStatusInfo(cycle,&pInfo->lastTrainStatusInfo[cycle]);
				if (CI_ERROR == funRtn)
				{
					processValid = CI_ERROR;
				}
				else
				{
					/** 不处理 */
				}
			}
		}
		else
		{
			/** 不处理 */
		}
	}

	if (CI_SUCCESS == processValid)
	{
		ret = CI_SUCCESS;
	}
	else
	{
		/** 处理失败 */
	}

	return ret;
}

/**
 * @brief 获取全线免筛信息
 * @param[in] 无
 * @param[out] 无
 * @return 全线免筛静态信息结构体指针
 * @note 无
 */
const WLSreenInfoStruct* wls_GetWholeLineScreeInfo(void)
{
	return &g_WLScreenStatus;
}



/**
 * @brief 设置UT计轴数量
 * @param[in] UINT8 cnt UT计轴数量
 * @param[out] 无
 * @return CI_SUCCESS 设置成功；CI_ERROR 设置失败
 * @note 无
 */
UINT8 wls_SetUTACCnt(UINT8 cnt)
{
	UINT8 ret = CI_ERROR;
	if (cnt < MAX_UT_AC_CNT)
	{
		g_WLScreenStatus.UTACCnt = cnt;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 不处理 */
	}
	return ret;
}


/**
 * @brief 获取UT计轴数量
 * @param[in] 
 * @param[out]
 * @return 0~MAX_UT_AC_CNT-1 合法值；MAX_UT_AC_CNT 非法值
 * @note 无
 */
UINT8 wls_GetUTACCnt(void)
{
	UINT8 ret = MAX_UT_AC_CNT;
	ASSERT_SETRET(g_WLScreenStatus.UTACCnt < MAX_UT_AC_CNT,ret,g_WLScreenStatus.UTACCnt,MAX_UT_AC_CNT);
	return ret;
}


/**
 * @brief 设置UT计轴ID存储
 * @param[in] UINT8 index 缓存下标
 * @param[in] UINT16 acID 计轴ID
 * @param[out] 无
 * @return CI_SUCCESS 设置成功；CI_ERROR 设置失败
 * @note 无
 */
UINT8 wls_SetUTACId(UINT8 index,UINT16 acID)
{
	UINT8 ret = CI_ERROR;
	if (index < MAX_UT_AC_CNT)
	{
		g_WLScreenStatus.UTACId[index] = acID;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 处理失败*/
	}
	return ret;
}


/**
 * @brief 获取下标对应的UT计轴
 * @param[in] UINT8 index 缓存下标
 * @param[out] 无
 * @return 计轴ID
 * @note 无
 */
UINT16 wls_GetUTACId(UINT8 index)
{
	UINT16 ret = 0u;
	if (index < MAX_UT_AC_CNT)
	{
		ret = g_WLScreenStatus.UTACId[index];
	}
	else
	{
		/** 处理失败*/
	}
	return ret;
}

/**
 * @brief 累加冗余计时
 * @param[in] UINT32 maxValue 冗余计时最大值
 * @param[out] 无
 * @return 无
 * @note 无
 */
void wls_AddRedunTime(UINT32 maxValue)
{
	if (g_WLScreenStatus.redunTime < maxValue)
	{
		g_WLScreenStatus.redunTime++;
	}
	else
	{
		/** 无需处理 */
	}
}

/**
 * @brief 设置冗余计时
 * @param[in] UINT32 mValue 冗余计时值
 * @param[in] UINT32 maxValue 冗余计时最大值
 * @param[out] 无
 * @return 无
 * @note 无
 */
void wls_SetRedunTime(UINT32 mValue,UINT32 maxValue)
{
	if (mValue < maxValue)
	{
		g_WLScreenStatus.redunTime = mValue;
	}
	else
	{
		/** 无需处理 */
	}
}