/********************************************************
*                                                                                                            
* 文 件 名： VirtualDeviceDataManage.c   
* 版权说明： 北京交控科技有限公司 
* 创建时间： 2016-12-16
* 作    者： 联锁组
* 功能描述： 虚拟设备动态数据管理
* 修改记录：   
*
********************************************************/ 
#include "VirtualDevDefine.h"
#include "VirtualDevDataManage.h"

VirtualZDZFAJDataStruct VirtualZDZFAJData;

VirtualCIStruct g_VirtualCIStructData = {0u};/*仅存储本机联锁包含虚拟联锁*/
/*对外接口*/

/*
* 功能描述： 获取虚拟折返按键的设备类型
* 参数说明： 无   
* 返回值  ： 无人折返按键的设备类型
*/
UINT8 GetVirtualZDZFDevType(void)
{
	return VirtualZDZFAJData.virtualDevType;
}

#if 0
/*
* 功能描述： 获取虚拟折返按键对应折返灯的闪灯状态
* 参数说明： 无   
* 返回值  ： 无人折返灯的闪灯状态
*/
UINT8 GetVirtualZDZFFlashState(void)
{
	return VirtualZDZFAJData.flashState;
}

/*
* 功能描述： 获取虚拟折返按键对应折返灯的稳灯状态
* 参数说明： 无   
* 返回值  ： 无人折返灯的稳灯状态
*/
UINT8 GetVirtualZDZFSteadyState(void)
{
	return VirtualZDZFAJData.steadyState;
}

#endif
/*
* 功能描述： 获取虚拟折返按键对应折返灯的所属联锁ID
* 参数说明： 无   
* 返回值  ：虚拟折返按键的所属联锁ID
*/
UINT8 GetVirtualZDZFBelongCiId(void)
{
	return VirtualZDZFAJData.belongCiId;
}

/*
* 功能描述： 获取虚拟折返按键的设置状态
* 参数说明： 无   
* 返回值  ： 无人折返按键的设置状态
*/
UINT8 GetVirtualZDZFButtonState(void)
{
	return VirtualZDZFAJData.btnState;
}

/*
* 功能描述： 设置指定ID 虚拟无人折返按钮的设置状态
* 参数说明： const UINT8 state, 按钮设置状态
* 返回值  ： 无     
*/
void SetVirtualZDZFButtonState(const UINT8 state)
{
	if ((VIRTUAL_ZDZFAJ_BUTTON_YES == state) || (VIRTUAL_ZDZFAJ_BUTTON_NO == state))
	{
		VirtualZDZFAJData.btnState = state;/*设置按钮状态*/
	}
}

/*
* 功能描述： 初始化虚拟无人折返按钮设备状态
* 参数说明： 无   
* 返回值  ： 无
*/
void InitVirtualZDZFData(void)
{
	VirtualZDZFAJData.belongCiId = 0u;
	VirtualZDZFAJData.virtualDevType = 0u;
	VirtualZDZFAJData.btnState = VIRTUAL_ZDZFAJ_BUTTON_NO;/*自动折返按钮未按下*/
}

/*
* 功能描述： 获取指定虚拟联锁全站点灯状态
* 参数说明： 虚拟联锁ID    
* 返回值  ： 全站点灯状态
*
*/
UINT8 GetVirCIAllSignalBrightState(UINT8 VirCIid)
{
	UINT8 i=0u;
	UINT8 reVal = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].chAllSignalBrightFlag;
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁全站点灯状态
* 参数说明： 虚拟联锁ID,全站点灯状态   
* 返回值  ： 无
*
*/
void SetVirCIAllSignalBrightState(UINT8 VirCIid,UINT8 state)
{
	UINT8 i = 0u;
	UINT16 j = 0u;
	UINT16 signalNum = GetTotalSignalCurNum(); /*本联锁和相邻联锁的信号机数目*/
	UINT16 signalId = 0u;
	UINT8 belongCIid = 0u;
	UINT8 belongVirCIid = 0u;
	UINT8 localCIid = GetSystemParaLocalCiId();
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			if ((CI_ALL_SIGNAL_BRIGHT_YES == state)||(CI_ALL_SIGNAL_BRIGHT_NO == state))
			{
				g_VirtualCIStructData.virtualCi[i].chAllSignalBrightFlag = state;
				break;
			}
		}
	}
	/*设置全站维修点灯时，将单个信号机维修点灯状态同时更新*/
	for(j =0u;j <signalNum;j++)
	{
		signalId = GetSignalId(j);
		belongCIid = GetSignalBelongCiId(signalId);
		belongVirCIid = GetSignalBelongVirCiId(signalId);
		if((localCIid == belongCIid)&&(belongVirCIid == VirCIid))
		{
			if(CI_ALL_SIGNAL_BRIGHT_YES == state)
			{
				SetSignalMaintainState(signalId,MAINTAIN_STATE_YES);
			}
			else
			{
				SetSignalMaintainState(signalId,MAINTAIN_STATE_NO);
			}
			
		}
	}
}
/*
* 功能描述： 获取本联锁包含虚拟联锁数量
* 参数说明： 无    
* 返回值  ： 虚拟联锁数量
*
*/
UINT8 GetVirtualCINum(void)
{
	return g_VirtualCIStructData.virtualCiNum;
}
/*
* 功能描述： 获取指定索引虚拟联锁ID
* 参数说明： 无    
* 返回值  ： 指定虚拟联锁ID
*
*/
UINT8 GetVirtualCIid(UINT8 index)
{
	UINT8 reVal = 0u;
	if(VIRTUAL_CI_MAX > index)
	{
		reVal = g_VirtualCIStructData.virtualCi[index].virtualCiId;
	}
	return reVal;
}
/*
* 功能描述： 获取指定虚拟联锁引导总锁状态
* 参数说明： 虚拟联锁ID    
* 返回值  ： 全站点灯状态
*
*/
UINT8 GetVirCIAllSwitchYLockState(UINT8 VirCIid)
{
	UINT8 i=0u;
	UINT8 reVal = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].chAllSwitchYLockFlag;
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁引导总锁状态
* 参数说明： 虚拟联锁ID,引导总锁状态   
* 返回值  ： 无
*
*/
void SetVirCIAllSwitchYLockState(UINT8 VirCIid,UINT8 state)
{
	UINT8 i = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			if ((CI_ALL_SWITCH_YLOCK_YES == state)||(CI_ALL_SWITCH_YLOCK_NO == state))
			{
				g_VirtualCIStructData.virtualCi[i].chAllSwitchYLockFlag = state;
				break;
			}
		}
	}
}
/*
* 功能描述： 获取指定虚拟联锁临时限速状态
* 参数说明： 虚拟联锁ID    
* 返回值  ： 临时限速状态
*
*/
UINT8 GetVirCILabourCancelLSXianSta(UINT8 VirCIid)
{
	UINT8 i=0u;
	UINT8 reVal = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].chLabourCancelLinShiXianState;
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁临时限速状态
* 参数说明： 虚拟联锁ID,临时限速状态    
* 返回值  ： 无
*
*/
void SetVirCILabourCancelLSXianSta(UINT8 VirCIid,UINT8 state)
{
	UINT8 i = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(VirCIid == g_VirtualCIStructData.virtualCi[i].virtualCiId)
		{
			if ((LINSHIXIANSU_COMM_BAD_STATE == state)
				||(LINSHIXIANSU_COMM_GOOD_STATE == state)
				||(LINSHIXIANSU_LABOURCANCLE_YES_STATE == state))
			{
				g_VirtualCIStructData.virtualCi[i].chLabourCancelLinShiXianState = state;
				break;
			}
		}
	}
}

/*
* 功能描述： 获取指定OC所属虚拟联锁
* 参数说明： ocid  oc的ID    
* 返回值  ： 虚拟联锁ID
*
*/
UINT8 GetOCBelongVirCIid(const UINT8 ocid)
{
	UINT8 i = 0u;
	UINT8 reVal = 0u;
	UINT8 j= 0u;
	UINT8 ocNum = 0u;
	for(i=0u;(i<g_VirtualCIStructData.virtualCiNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		ocNum = g_VirtualCIStructData.virtualCi[i].IncludeOCNum;
		for(j=0u;j < ocNum;j++)
		{
			if(g_VirtualCIStructData.virtualCi[i].IncludeOCid[j] == ocid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].virtualCiId;
				break;
			}
		}
	}
	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁ID指示器状态
* 参数说明：  const UINT8 virCIid     虚拟联锁ID
*            const UINT8 indicatorId, 指示器ID  
*			 const UINT8 indicatorState, 指示器状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
void SetVirCIIndicatorState(const UINT8 virCIid, UINT8 indicatorId, const UINT8 indicatorState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	if (VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				g_VirtualCIStructData.virtualCi[i].IndicatorData[indicatorId].IndicatorState = indicatorState;
				break;
			}
		}
	}

}
/*
* 功能描述： 获取指定虚拟联锁ID指示器状态
* 参数说明：  const UINT8 virCIid     虚拟联锁ID
*            const UINT8 indicatorId, 指示器ID  
* 返回值  ： 大于0 : 虚拟联锁ID指示器状态  
*            等于0 : 失败             
*/
UINT8 GetVirCIIndicatorState(const UINT8 virCIid, UINT8 indicatorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 reVal = CI_ERROR;
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	if (VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].IndicatorData[indicatorId].IndicatorState;
				break;
			}
		}
	}
	return reVal;
}
/*
* 功能描述： 获取指定虚拟联锁指示灯配置数组
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			
* 返回值  ： 指定虚拟联锁指示灯数组     
*/
IndicatorConfigDataStruct* GetVirCIIndicatorConfigDataBuff(const UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	IndicatorConfigDataStruct *pIndicatorConfigDataBuf = NULL;
	
	virNum = GetVirtualCINum();
	for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			pIndicatorConfigDataBuf = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData;	
			break;
		}
	}	
	return pIndicatorConfigDataBuf;
}
/*
* 功能描述： 设置指定虚拟联锁指示灯配置数量
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			const UINT8 indicatorNum 虚拟联锁指示灯配置数量
* 返回值  ： void    
*/
void SetVirCIIndicatorConfigDataNum(const UINT8 virCIid,const UINT8 indicatorNum)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	

	virNum = GetVirtualCINum();
	for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			g_VirtualCIStructData.virtualCi[i].IndicatorConfigDataNum = indicatorNum;	
			break;
		}
	}	
}
/*
* 功能描述： 获取指定虚拟联锁指示灯配置数量
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			
* 返回值  ： 虚拟联锁指示灯配置数量    
*/
UINT8 GetVirCIIndicatorConfigDataNum(const UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].IndicatorConfigDataNum;	
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 获取指定虚拟联锁指示灯配置继电器数量
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			
* 返回值  ： 配置继电器数量    
*/
UINT8 GetVirCIIndicConfDataRelaySum(const UINT8 virCIid,const UINT8 indicatorId)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	if(VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		virNum = GetVirtualCINum();
		for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData[indicatorId].IdSum;	
				break;
			}
		}
	}
	
	return reVal;
}
/*
* 功能描述： 获取指定虚拟联锁指示灯配置继电器数组
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			 const UINT8 indicatorId 指示灯ID
* 返回值  ： 配置继电器数组    
*/
UINT16* GetVirCIIndicConfDataRelayBuf(const UINT8 virCIid,const UINT8 indicatorId)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT16* pIndicatorRelayBuf = NULL;

	if(VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		virNum = GetVirtualCINum();
		for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				pIndicatorRelayBuf = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData[indicatorId].IdBuf;	
				break;
			}
		}
	}

	return pIndicatorRelayBuf;
}

/*
* 功能描述： 获取指定虚拟联锁指示灯配置开关
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*            const UINT8 indicatorId  指示灯ID
*			
* 返回值  ： 指示灯配置开关状态    
*/
UINT8 GetVirCIIndicConfDataAvalFlag(const UINT8 virCIid,const UINT8 indicatorId)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	if(VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		virNum = GetVirtualCINum();
		for(i=0u;(i<virNum)&&(i<VIRTUAL_CI_MAX);i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData[indicatorId].AvalibleFlag;	
				break;
			}
		}
	}

	return reVal;
}

/*
* 功能描述： 获取指定虚拟联锁指示灯ID映射数组
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*			
* 返回值  ： 指示灯ID映射数组    
*/
UINT8* GetVirCIlocalCiIndicatorIdBuf(const UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;
	UINT8 *plocalCiIndicatorIdBuf = NULL;
	
	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			plocalCiIndicatorIdBuf = g_VirtualCIStructData.virtualCi[i].localCiIndicatorIdBuf;	
			break;
		}
	}
	return plocalCiIndicatorIdBuf;
}

/*
* 功能描述：	整理读入的指示灯ID映射数组
* 参数说明：	无
* 返回值  ：	CI_SUCCESS,整理成功
*				CI_ERROR,整理失败
*/
UINT8 InitVirCIlocalCiIndicatorIdBuf(void)
{
	UINT8 ii = 0u;      /*游标*/
	UINT8 jj = 0u;      /*游标*/
	UINT8 indicatorConfigDataSum = 0u;      /*指示灯设备配置数据总数*/
	UINT8 reVal = CI_ERROR;
	UINT8 i = 0u;
	UINT8 virCINum = 0u;
	UINT8 virCIid = 0u;
	UINT8 *plocalCiIndicatorIdBuf = NULL;
	IndicatorConfigDataStruct* pIndicatorConfigData = NULL;

	virCINum = GetVirtualCINum();
	for(i = 0u;i < virCINum;i++)
	{
		jj = 0u;
		virCIid = GetVirtualCIid(i);
		indicatorConfigDataSum = GetVirCIIndicatorConfigDataNum(virCIid);
		plocalCiIndicatorIdBuf = GetVirCIlocalCiIndicatorIdBuf(virCIid);
		pIndicatorConfigData = GetVirCIIndicatorConfigDataBuff(virCIid);
		if ((indicatorConfigDataSum >= VIRTUAL_CI_INDICATOR_SUM_MAX)||(NULL == plocalCiIndicatorIdBuf)||(NULL == pIndicatorConfigData))
		{/*配置数据总数错误*/

			reVal = CI_ERROR;
			break;
		}
		else
		{
			reVal = CI_SUCCESS;
			for (ii = 0u; ii < VIRTUAL_CI_INDICATOR_SUM_MAX; ii++)
			{
				if (jj == indicatorConfigDataSum)
				{/*遍历有效数据完毕*/

					break;
				}

				if (0u != pIndicatorConfigData[ii].IndicatorId)
				{/*该部分为有效数据*/

					plocalCiIndicatorIdBuf[jj] = (UINT8)pIndicatorConfigData[ii].IndicatorId;
					jj++; 
				}
			}
		}
	}
	
	return reVal;
}

/*
* 功能描述： 获取指定虚拟联锁指示灯ID
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*            UINT8 index  索引
*			
* 返回值  ： 指示灯ID   
*/
UINT8 GetVirCIlocalCiIndicatorId(const UINT8 virCIid,UINT8 index)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	if(VIRTUAL_CI_INDICATOR_SUM_MAX >index)
	{
		virNum = GetVirtualCINum();
		for(i=0u;i<virNum;i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].localCiIndicatorIdBuf[index];	
				break;
			}
		}
	}
	
	return reVal;
}

/*
* 功能描述： 获取指定虚拟联锁指示灯类型
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*            const UINT8 indicatorId  指示灯ID 
*			
* 返回值  ： 配置继电器类型    
*/
UINT8 GetVirCIIndicatorType(const UINT8 virCIid,const UINT8 indicatorId)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	if(VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		virNum = GetVirtualCINum();
		for(i=0u;i<virNum;i++)
		{
			if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData[indicatorId].IndicatorType;	
				break;
			}
		}
	}

	return reVal;
}

/*
* 功能描述： 设置指定虚拟联锁工作模式
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             UINT8 mode  设置模式 
*			
* 返回值  ： void   
*/
void SetVirCImode(UINT8 virCIid, UINT8 mode)
{
	UINT8 i = 0U;
	UINT8 virNum = 0U;

	virNum = GetVirtualCINum();

	for(i=0U;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			if ((CI_MODE_ATS == mode) || (CI_MODE_CONSOLE == mode)
				||(CI_MODE_CI_LOCAL == mode) ||(CI_MODE_CONSTRA_LOCAL == mode) || ((CI_MODE_APPLAY_LOCAL == mode)))
			{
				if ((CI_MODE_ATS == g_VirtualCIStructData.virtualCi[i].cimode) && (CI_MODE_ATS != mode))
				{
					/*之前为中控，当前要设置非中控*/
					ReleaseCtrlPower(virCIid, CONTRAL_POWER_NO, 0U, 0U);
				}
				else
				{
					; 
				}
			
				g_VirtualCIStructData.virtualCi[i].cimode  = mode;
			}
			else
			{
				/*不处理*/
			}
			break;
		}
	}
	if (CI_MODE_ATS == mode)
	{
		DefaultCtrlPowerDeal(virCIid);
	}
	else
	{
		;
	}
}

/*
* 功能描述： 获取指定虚拟联锁工作模式
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             
*			
* 返回值  ： 工作模式   
*/
UINT8 GetVirCImode(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	
	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].cimode;
			break;
		}
	}
	

	return reVal;
}

/*
* 功能描述： 设置指定虚拟联锁自动触发标志
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             UINT8 setFlag   自动触发标志
*			
* 返回值  ： void   
*/
void SetVirCIautoTriggerFlag(UINT8 virCIid, UINT8 setFlag)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			if ((AUTO_TRIGGER_SET_YES == setFlag) || (AUTO_TRIGGER_SET_NO == setFlag))
			{
				g_VirtualCIStructData.virtualCi[i].autoTriggerflag = setFlag;   /*设置自动触发标志*/
			} 
			break;
		}
	}
}
/*
* 功能描述： 获取指定虚拟联锁自动触发标志
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             
*			
* 返回值  ： 自动触发标志  
*/
UINT8 GetVirCIautoTriggerFlag(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;


	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			reVal = g_VirtualCIStructData.virtualCi[i].autoTriggerflag;
			break;
		}
	}


	return reVal;
}

/*
* 功能描述： 设置指定虚拟联锁总复位标志
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             UINT8 setFlag 总复位标志
*			
* 返回值  ： void  
*/
void SetVirCIZfwFlag(UINT8 virCIid,UINT8 setFlag)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			if ((CI_PHYSEC_GENERAL_RESET_YES == setFlag)||(CI_PHYSEC_GENERAL_RESET_NO == setFlag))
			{
				g_VirtualCIStructData.virtualCi[i].ZfwFlag = setFlag;	
			}
			break;
		}
	}
}

/*
* 功能描述： 设置指定虚拟联锁总复位标志
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             
*			
* 返回值  ： 总复位标志  
*/
UINT8 GetVirCIZfwFlag(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{		
			reVal = g_VirtualCIStructData.virtualCi[i].ZfwFlag;		
			break;
		}
	}
	return reVal;
}


/*
* 功能描述： 设置指定虚拟联锁总复位开始周期
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             UINT32 cyc 设置周期
*			
* 返回值  ： void  
*/
void SetVirCIZfwStartCycNum(UINT8 virCIid,UINT32 cyc)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{
			
			g_VirtualCIStructData.virtualCi[i].ZfwStartCycNum = cyc;		
			break;
		}
	}
}

/*
* 功能描述： 获取指定虚拟联锁总复位开始周期
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             
*			
* 返回值  ： 总复位开始周期 
*/
UINT32 GetVirCIZfwStartCycNum(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT32 reVal = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{		
			reVal = g_VirtualCIStructData.virtualCi[i].ZfwStartCycNum;		
			break;
		}
	}
	return reVal;
}

/*
* 功能描述： 设置指定虚拟联锁总复位继电器有效周期
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             UINT32 cyc 设置周期
*			
* 返回值  ： void  
*/
void SetVirCIZfwValidCycNum(UINT8 virCIid,UINT32 cyc)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{

			g_VirtualCIStructData.virtualCi[i].ZfwValidCycNum = cyc;		
			break;
		}
	}
}

/*
* 功能描述： 获取指定虚拟联锁总复位继电器有效周期
* 参数说明：   
*            const UINT8 virCIid  虚拟联锁ID
*             
*			
* 返回值  ： 总复位开始周期 
*/
UINT32 GetVirCIZfwValidCycNum(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT32 reVal = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{		
			reVal = g_VirtualCIStructData.virtualCi[i].ZfwValidCycNum;		
			break;
		}
	}
	return reVal;
}

/*
* 功能描述： 设置计轴总复位标志
* 参数说明： UINT8 setFlag设置标志
* 返回值  ：void    
*/
void SetPhySecZfwManage(UINT8 virCIid,UINT8 setFlag)
{
	UINT32 curCycNum = 0u;
	curCycNum = Get2oo2CurCycleNum();
	if (CI_PHYSEC_GENERAL_RESET_YES == setFlag)
	{
		SetVirCIZfwFlag(virCIid,setFlag);
		SetVirCIZfwStartCycNum(virCIid,curCycNum);
	}
	else if (CI_PHYSEC_GENERAL_RESET_NO == setFlag)
	{
		SetVirCIZfwFlag(virCIid,setFlag);
		SetVirCIZfwStartCycNum(virCIid,0u);
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取本联锁包含指示灯数目
* 参数说明： UINT8 setFlag设置标志
* 返回值  ：void    
*/
UINT16 GetLocalCIBaojingdengNum(void)
{
	UINT16 localCIBaojingdengNum = 0u;
	localCIBaojingdengNum = g_VirtualCIStructData.LocalCIBaojingdengNum;
	if(LOCAL_CI_INDICATOR_SUM_MAX > g_VirtualCIStructData.LocalCIBaojingdengNum)
	{
	}
	else
	{
		localCIBaojingdengNum = 0u;
	}
	return localCIBaojingdengNum;
}

/*
* 功能描述： 获取本联锁包含指示灯行ID
* 参数说明： UINT16 index 索引
* 返回值  ：void    
*/
UINT16 GetLocalCIBaojingdengWId(UINT16 index)
{
	UINT16 reVal = 0u;
	
	if(LOCAL_CI_INDICATOR_SUM_MAX > index)
	{
		reVal = g_VirtualCIStructData.LocalCIBaojingdeng[index].wId;
	}

	return reVal;
}

/*
* 功能描述： 获取本联锁包含指示灯ID或类型
* 参数说明： UINT16 index 索引
* 返回值  指示灯ID或类型   
*/
UINT8 GetLocalCIIndicatorIDOrType(UINT16 index)
{
	UINT8 reVal = 0u;

	if(LOCAL_CI_INDICATOR_SUM_MAX > index)
	{
		reVal = (UINT8)g_VirtualCIStructData.LocalCIBaojingdeng[index].wBjdID;/*既是ID，也是类型*/
	}

	return reVal;
}

/*
* 功能描述： 获取本联锁包含指示灯所属虚拟联锁
* 参数说明： UINT16 index 索引
* 返回值  ：虚拟联锁id    
*/
UINT16 GetLocalCIBaojingdengBelongVir(UINT16 index)
{
	UINT16 reVal = 0u;

	if(LOCAL_CI_INDICATOR_SUM_MAX > index)
	{
		reVal = g_VirtualCIStructData.LocalCIBaojingdeng[index].wBelongVirCIid;
	}

	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁无人折返闪灯状态
* 参数说明： UINT8 devId 指示灯设备ID，UINT8 virCIid 虚拟联锁ID,UINT8 state设置标志
* 返回值  ：void
*/
void SetVirCIautoRtnIndictFlashState(UINT8 devId, UINT8 virCIid, UINT8 state)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 jj = 0U;
	UINT8 breakfalg = 0U;

	if ((0U < devId) && (UINT8_MAX > devId))
	{
		virNum = GetVirtualCINum();
		for (i = 0u; i < virNum; i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
				{
					if (devId == g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId)
					{
						if ((VOBCTOCIAUTORTN_INDICT_MASK_VALID == state) || (VOBCTOCIAUTORTN_INDICT_MASK_INVALID == state))
						{
							g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiFlashState = state;
							breakfalg = 1U;
							break;
						}
						else
						{
							;
						}
					}
					else
					{
						; 
					}
				}
			}
			else
			{
				;
			}
			if (1U == breakfalg)
			{
				break;
			}
			else
			{
				;
			}
		}
	}
	else
	{
		;
	}
}
/*
* 功能描述： 获取指定虚拟联锁无人折返闪灯状态
* 参数说明：UINT8 devId 指示灯设备ID
*           UINT8 virCIid 虚拟联锁ID
* 返回值  ：虚拟联锁无人折返闪灯状态
*/
UINT8 GetVirCIautoRtnIndictFlashState(UINT8 devId, UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = VOBCTOCIAUTORTN_INDICT_MASK_INVALID;
	UINT8 jj = 0U;
	UINT8 breakfalg = 0U;

	if ((0U < devId) && (UINT8_MAX > devId))
	{
		virNum = GetVirtualCINum();
		for (i = 0u; i < virNum; i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
				{
					if (devId == g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId)
					{
						reVal = g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiFlashState;
						breakfalg = 1U;
						break;
					}
					else
					{
						;
					}
				}
			}
			else
			{
				;
			}
			if (1U == breakfalg)
			{
				break;
			}
			else
			{
				;
			}
		}
	}
	else
	{
		; 
	}

	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁无人折返稳灯状态
* 参数说明： UINT8 devId 指示灯设备ID，UINT8 virCIid 虚拟联锁ID,UINT8 state设置标志
* 返回值  ：void
*/
void SetVirCIautoRtnIndictSteadyState(UINT8 devId, UINT8 virCIid, UINT8 state)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 jj = 0U;
	UINT8 breakfalg = 0U;

	if ((0U < devId) && (UINT8_MAX > devId))
	{
		virNum = GetVirtualCINum();
		for (i = 0u; i < virNum; i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
				{
					if (devId == g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId)
					{
						if ((VOBCTOCIAUTORTN_INDICT_MASK_VALID == state) || (VOBCTOCIAUTORTN_INDICT_MASK_INVALID == state))
						{
							g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiSteadyState = state;
							breakfalg = 1U;
							break;
						}
						else
						{
							;
						}
					}
					else
					{
						;
					}
				}
			}
			else
			{
				;
			}
			if (1U == breakfalg)
			{
				break;
			}
			else
			{
				;
			}
		}
	}
	else
	{
		;
	}
}
/*
* 功能描述： 获取指定虚拟联锁无人折返稳灯状态
* 参数说明： UINT8 devId 指示灯设备ID
*            UINT8 virCIid 虚拟联锁ID
* 返回值  ： 联锁无人折返稳灯状态
*/
UINT8 GetVirCIautoRtnIndictSteadyState(UINT8 devId, UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = VOBCTOCIAUTORTN_INDICT_MASK_INVALID;
	UINT8 jj = 0U;
	UINT8 breakfalg = 0U;

	if ((0U < devId) && (UINT8_MAX > devId))
	{
		virNum = GetVirtualCINum();
		for (i = 0u; i < virNum; i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
				{
					if (devId == g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId)
					{
						reVal = g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[jj].VirCiSteadyState;
						breakfalg = 1U;
						break;
					}
				}
			}
			if (1U == breakfalg)
			{
				break;
			}
		}
	}
	return reVal;
}
/*
* 功能描述： 设置指定虚拟联锁混线标志
* 参数说明：UINT8 virCIid 虚拟联锁ID,UINT8 setFlag 设置标志
* 返回值  ：void    
*/
void SetVirCIZfwHunxianFlag(UINT8 virCIid,UINT8 setFlag)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{		
			g_VirtualCIStructData.virtualCi[i].ZfwjHunXianFLag = setFlag;		
			break;
		}
	}
}
/*
* 功能描述： 获取指定虚拟联锁混线标志
* 参数说明：UINT8 virCIid 虚拟联锁ID
* 返回值  ：混线标志    
*/
UINT8 GetVirCIZfwHunxianFlag(UINT8 virCIid)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 reVal = 0u;

	virNum = GetVirtualCINum();
	for(i=0u;i<virNum;i++)
	{
		if(g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
		{		
			reVal = g_VirtualCIStructData.virtualCi[i].ZfwjHunXianFLag;		
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 获取指定虚拟联锁ID的报警灯设备ID
* 参数说明：  const UINT8 virCIid     虚拟联锁ID
*            const UINT8 indicatorId  报警灯ID
* 返回值  ： 大于0 : 虚拟联锁ID的报警灯设备ID
*            等于0 : 失败
*/
UINT8 GetVirCIIndicatorDevId(const UINT8 virCIid, UINT8 indicatorId)
{
	UINT8 reVal = CI_ERROR;
	UINT8 i = 0u;
	UINT8 virNum = 0u;

	virNum = GetVirtualCINum();
	if (VIRTUAL_CI_INDICATOR_SUM_MAX > indicatorId)
	{
		for (i = 0u; (i < virNum) && (i < VIRTUAL_CI_MAX); i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				reVal = g_VirtualCIStructData.virtualCi[i].IndicatorConfigData[indicatorId].BjdDeviceId;
				break;
			}
		}
	}
	return reVal;
}

/*
* 功能描述： 获取指定虚拟联锁是否属于本真实联锁管辖
* 参数说明： const UINT8 chVirCiId  虚拟的ID
* 返回值  ： CI_ERROR   虚拟联锁不属于本真实联锁管辖
*            CI_SUCCESS 虚拟联锁属于本真实联锁管辖
*cgh-20230529-修复YF0083-808
*/
UINT8 GetVirCIBelongLocalCI(const UINT8 chVirCiId)
{
	UINT8 i = 0u;
	UINT8 reVal = CI_ERROR;
	UINT8 chVirCiIdTemp = 0U;/*本机联锁包含的虚拟联锁ID临时变量*/

	for (i = 0u; (i < g_VirtualCIStructData.virtualCiNum) && (i < VIRTUAL_CI_MAX); i++)
	{
		chVirCiIdTemp = g_VirtualCIStructData.virtualCi[i].virtualCiId;
		if (chVirCiId == chVirCiIdTemp)
		{
			reVal = CI_SUCCESS;
			break;
		}
	}
	return reVal;
}
/*
* 功能描述： 获取本虚拟联锁无人折返指示灯设备ID
* 参数说明： UINT8 virCIid 虚拟联锁ID
*            UINT8 index 索引
* 返回值  ：>0 本虚拟联锁指示灯设备ID
*			0 本虚拟联锁只有一个无人折返时索引为1返回零或者没有无人折返返回零
*/
UINT8 GetVirCiRtnIndictDeviceId(UINT8 virCIid, UINT8 index)
{
	UINT8 i = 0u;
	UINT8 virNum = 0u;
	UINT8 jj = 0U;
	UINT8 breakfalg = 0U;
	UINT8 retValue = 0U;

	if (RTNINDICATOR_SUM_MAX > index)
	{
		virNum = GetVirtualCINum();
		for (i = 0u; i < virNum; i++)
		{
			if (g_VirtualCIStructData.virtualCi[i].virtualCiId == virCIid)
			{
				/*根据索引返回本虚拟联锁的无人折返指示灯设备ID*/
				retValue = g_VirtualCIStructData.virtualCi[i].VirCIRtnIndicatorStaData[index].VirCiIndicatorDevId;
				break;
			}
		}
	}
	return retValue;
}
