/********************************************************
*                                                                                                            
* 文 件 名： AxisSectionConfigDataManage.c   
* 版权说明： 北京交控科技有限公司 
* 创建时间： 2012-03-20
* 作    者： 联锁组
* 功能描述： 计轴区段配置数据管理  
* 修改记录：   
*
********************************************************/ 

#include "AxisSectionConfigDataManage.h"
#include "ELMDataPrepare.h"




AxisSectionConfigDataStruct AxisSectionConfigDataStru[AXIS_SECTION_SUM_MAX];   /*定义计轴区段配置数据结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
UINT16 LocalCiAxisSectionIdBuf[AXIS_SECTION_SUM_MAX] = {0u};                   /*定义本地联锁计轴区段ID映射数组*/
INT16 AxisSectionCurSum = 0;   /*逻辑区段当前总数*/
UINT16 totalAxisNum = 0u;       /*本联锁+相邻联锁的计轴区段ID数量*/

/*
* 功能描述： 获取计轴区段当前总数
* 参数说明： void    
* 返回值  ： 0: 获取数据失败
*			>0: 计轴当前总数
*/
UINT16 GetAxisSecCurSum(void)
{
	UINT16 retVal = 0u;
    if ((INT16)AXIS_SECTION_SUM_MAX <= AxisSectionCurSum)
    {
        retVal = AXIS_SECTION_SUM_MAX;
    }
	else if (0 > AxisSectionCurSum)
	{
		retVal = 0u;
	}
    else
    {
        retVal = (UINT16)AxisSectionCurSum;
    }
	return retVal;
}

/*
* 功能描述： 获取计轴区段配置数据
* 参数说明： void    
* 返回值  ： 计轴区段配置数据结构体指针
*/
AxisSectionConfigDataStruct* GetAxisSecConfigData(void)
{
	return AxisSectionConfigDataStru;
}

/*
* 功能描述： 获取指定数组下标对应的计轴区段ID
* 参数说明： const UINT16 bufIndex, 数组下标    
* 返回值  ： 0: 获取数据失败
*			>0: 计轴区段ID      
*/
UINT16 GetAxisSecId(const UINT16 bufIndex)
{
	UINT16 retVal = CI_ERROR;
	UINT16 dwTotalAxiscNum = GetTotalAxisCurNum();
	if (bufIndex < dwTotalAxiscNum)
	{
		retVal = LocalCiAxisSectionIdBuf[bufIndex];
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段索引号
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： AXIS_SECTION_SUM_MAX: 获取数据失败
*			<AXIS_SECTION_SUM_MAX: 查找成功
*/
UINT16 GetAxisSecConfigBufIndex(const UINT16 axisSectionId)
{
	UINT16 retVal = AXIS_SECTION_SUM_MAX;
	if ((axisSectionId >= 1u) && (axisSectionId < AXIS_SECTION_SUM_MAX))
	{
        retVal = axisSectionId;
	}
	else
	{
		retVal = AXIS_SECTION_SUM_MAX;
	}
	
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段相关物理区段ID
* 参数说明： const UINT16 axisSectionId, 计轴区段ID    
* 返回值  ： 0: 获取数据失败
*			>0: 相关物理区段ID      
*/
UINT16 GetAxisSecRelativePhySecId(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].RelativePhySecId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID计轴区段逻辑区段数目
* 参数说明： const UINT16 axisSectionId, 计轴区段ID    
* 返回值  ： 0: 获取数据失败
*			>0: 逻辑区段数目      
*/
UINT8 GetAxisSecLogSectionSum(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].LogSectionSum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID计轴区段逻辑区段ID数组
* 参数说明： const UINT16 axisSectionId, 计轴区段ID    
* 返回值  ： 0: 获取数据失败
*			>0: 逻辑区段ID数组指针      
*/
UINT16* GetAxisSecLogSectionIdBuf(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 * retVal = NULL;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].LogSectionIdBuf;
	}
	else
	{
		retVal = NULL;
	}
	return retVal;
}

/*
* 功能描述：	整理读入的计轴区段配置数据
* 参数说明：	无
* 返回值  ：	CI_SUCCESS,整理成功
*				CI_ERROR,整理失败
*/
UINT8 AxisSectionConfigDataManage(void)
{
    UINT16 ii = 0u;      /*游标*/
    UINT16 jj = 0u;      /*游标*/
    UINT16 axisSectionConfigDataSum = 0u;      /*计轴区段设备配置数据总数*/
	UINT8 retVal = CI_SUCCESS;

    /*保存计轴区段ID索引数组*/
    axisSectionConfigDataSum = GetAxisSecCurSum();
	totalAxisNum = axisSectionConfigDataSum;
    if (axisSectionConfigDataSum >= AXIS_SECTION_SUM_MAX)
    {/*配置数据总数错误*/
        
        retVal = CI_ERROR;
	}
	else
	{
		for (ii = 0u; ii < AXIS_SECTION_SUM_MAX; ii++)
		{
			if (jj == axisSectionConfigDataSum)
			{/*遍历有效数据完毕*/

				break;
			}

			if (AxisSectionConfigDataStru[ii].AxisSectionId != 0u)
			{/*该部分为无效数据*/
				LocalCiAxisSectionIdBuf[jj] = AxisSectionConfigDataStru[ii].AxisSectionId;
				jj++;
			}

 
		}
	}
	
    return retVal;
}


	/*
	* 功能描述： 获取指定ID计轴区段道岔数目
	* 参数说明： const UINT16 axisSectionId, 计轴区段ID    
	* 返回值  ： 0: 获取数据失败
	*			>0: 道岔数目      
	*/
UINT8 GetAxisSwitchSum(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].AxisSwitchSum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID计轴区段道岔ID数组
* 参数说明： const UINT16 axisSectionId, 计轴区段ID    
* 返回值  ： 0: 获取数据失败
*			>0: 道岔ID数组指针      
*/
AxisSwitchStruct* GetAxisSwitchIdStru(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	AxisSwitchStruct* retVal = NULL;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].AxisSwitchIdStru;
	}
	else
	{
		retVal = NULL;
	}
	return retVal;
}



/*
* 功能描述： 获取相邻联锁发送给本联锁以及本联锁逻辑区段当前总数
* 参数说明： void    
* 返回值  ： 0: 获取数据失败
*			>0: 逻辑区段当前总数
*/
UINT16 GetTotalAxisCurNum(void)
{
	UINT16 retVal  = 0u;
	if (totalAxisNum >= AXIS_SECTION_SUM_MAX)
	{
		retVal = 0u;
	}
	else
	{
		retVal = totalAxisNum;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID计轴区段link数量
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： 0: 获取数据失败
*			>0: link数量
*/
UINT8 GetAxisLinkSum(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].chLinkNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段linkID数组
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： NULL: 获取数据失败
*			 >0: linkID数组
* 修复bug YF0083-119
*/
UINT16* GetAxisLinkIdBuf(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16* retVal = NULL;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].szLinkIdBuff;
	}
	else
	{

	}

	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段起点计轴器编号
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： 0: 获取数据失败
*			>0: 起点计轴器编号
*/
UINT16 GetAxisOrgnAxisId(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].wOrgnAxisId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段终点计轴器编号
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： 0: 获取数据失败
*			>0: 起点计轴器编号
*/
UINT16 GetAxisTmnlAxisId(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].wTmnlAxisId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/**
* @brief 获取计轴区段ID映射数组地址以及计轴区段当前总数
* @param 无
* @return 计轴区段当前总数
*/
UINT16 GetLocalCiAxisSectionIdBuf(const UINT16 **pIdBuff)
{
	UINT16 wAcSum = 0u;

	if (NULL == pIdBuff)
	{
		;
	}
	else
	{
		(*pIdBuff) = LocalCiAxisSectionIdBuf;
		wAcSum = totalAxisNum;
	}

	return wAcSum;
}

/**
* @brief 获取计轴区段ID在LocalCiAxisSectionIdBuf中的索引值
* @param 无
* @return 计轴在LocalCiAxisSectionIdBuf中的索引值
* @note 1、集成 bug 20220420 wqm 增加全局变量有效性检查
*       2、修复bug YF0083-119
*/
UINT16 GetLocalCiAxisSectionIndex(UINT16 axisID)
{
	UINT16 wACIndex = UINT16_MAX;
	UINT16 cycle = 0;

	/** 集成 bug 20220420 wqm 增加全局变量有效性检查 */
	if (AXIS_SECTION_SUM_MAX > totalAxisNum)
	{
		for (cycle = 0; cycle < totalAxisNum; cycle++)
		{
			if (LocalCiAxisSectionIdBuf[cycle] == axisID)
			{
				wACIndex = cycle + 1U;
				break;
			}
			else
			{

			}
		}
	}
	else
	{
		/** 返回无效值 */
	}

	return wACIndex;
}

/*
* 功能描述： 获取指定ID计轴区段所属TIOC编号
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： 0: 获取数据失败
*			>0: 计轴区段所属TIOC编号
*/
UINT16 GetAxisBelongTioc(const UINT16 wAcId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;
	UINT16 wLinkId = 0u;

	bufIndex = GetAxisSecConfigBufIndex(wAcId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		wLinkId = AxisSectionConfigDataStru[bufIndex].szLinkIdBuff[0];
		retVal = GetLinkManageTiocById(wLinkId);
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区是否为联络线计轴区段
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： AXIS_SEC_LINK_LINE_YES: 联络线计轴区段
*			 AXIS_SEC_LINK_LINE_NO: 非联络线计轴区段
*/
UINT8 GetAxisSecLinkLineFlag(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = AXIS_SEC_LINK_LINE_NO;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].chLinkLine;
	}
	else
	{
		retVal = AXIS_SEC_LINK_LINE_NO;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID计轴区是否为入口计轴区段
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： AXIS_SEC_ENTRANCE_YES: 入口计轴区段
*			 AXIS_SEC_ENTRANCE_NO: 非入口计轴区段
*/
UINT8 GetAxisSecEntranceFlag(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = AXIS_SEC_ENTRANCE_NO;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].chEntrance;
	}
	else
	{
		retVal = AXIS_SEC_ENTRANCE_NO;
	}
	return retVal;
}


/*
* 功能描述： 获取计轴序列连通后的计轴区段序列
* 参数说明： const UINT16 wAxisSecASum 计轴序列A数量
*			 UINT16* pAxisSecABuf 计轴序列AID存放地址
*			 const UINT16 wAxisSecBSum 计轴序列B数量
*			 UINT16* pAxisSecBBuf 计轴序列BID存放地址
* 返回值  ： 0 失败；其他成功
* @note 创建 lxc 20220617
*/
UINT8 GetAxisSecListByStartingAndEnd(const UINT8 cAxisSecASum, UINT16* pAxisSecAIdBuf, const UINT8 cAxisSecBSum, UINT16* pAxisSecBIdBuf,UINT8 cDir, UINT16* pOutputIdBuf)
{
	UINT8 cRetSum = 0u;
	UINT8 cFunRetVal = CI_ERROR;
	UINT16 cLinkAHeadId = 0u;
	UINT16 cLinkATainId = 0u;
	UINT16 cLinkBHeadId = 0u;
	UINT16 cLinkBTainId = 0u;
	UINT32 dwDis = UINT32_MAX;
	LOD_STRU pointA = { 0u };
	LOD_STRU pointB = { 0u };
	UINT8 cEmapDir = 0u;
	UINT16 wDevSum = 0u;
	UINT16 szDevIdBuf[100] = { 0u };

	UINT8 cTmpASAHeadNum = 0u;
	UINT16* pTmpASAHeadLinkIdBuf = NULL;
	UINT8 cTmpASHeadBNum = 0u;
	UINT16* pTmpASBHeadLinkIdBuf = NULL;

	UINT8 cTmpASATailNum = 0u;
	UINT16* pTmpASATailLinkIdBuf = NULL;
	UINT8 cTmpASTailBNum = 0u;
	UINT16* pTmpASBTailLinkIdBuf = NULL;

	if ((NULL == pAxisSecAIdBuf) || (NULL == pAxisSecBIdBuf) || (NULL == pOutputIdBuf)
		|| (0u == cAxisSecASum) || (0u == cAxisSecBSum))
	{
		; /* 返回失败 */
	}
	else
	{
		/* 判断方向 */
		if ((DIR_SAME == cDir) || (DIR_CONVERT == cDir))
		{
			cFunRetVal = CI_SUCCESS;
		}

		if (CI_SUCCESS == cFunRetVal)
		{
			/* 获取A计轴序列的link头 */
			cTmpASAHeadNum = GetAxisLinkSum(pAxisSecAIdBuf[cAxisSecASum - 1u]);
			pTmpASAHeadLinkIdBuf = GetAxisLinkIdBuf(pAxisSecAIdBuf[cAxisSecASum - 1u]);
			/* 获取B计轴序列的link头 */
			cTmpASHeadBNum = GetAxisLinkSum(pAxisSecBIdBuf[cAxisSecBSum - 1u]);
			pTmpASBHeadLinkIdBuf = GetAxisLinkIdBuf(pAxisSecBIdBuf[cAxisSecBSum - 1u]);

			/* 获取A计轴序列的link尾 */
			cTmpASATailNum = GetAxisLinkSum(pAxisSecAIdBuf[0u]);
			pTmpASATailLinkIdBuf = GetAxisLinkIdBuf(pAxisSecAIdBuf[0u]);
			/* 获取B计轴序列的link尾 */
			cTmpASTailBNum = GetAxisLinkSum(pAxisSecBIdBuf[0u]);
			pTmpASBTailLinkIdBuf = GetAxisLinkIdBuf(pAxisSecBIdBuf[0u]);

			if ((0u != cTmpASAHeadNum) && (NULL != pTmpASAHeadLinkIdBuf)
				&& (0u != cTmpASHeadBNum) && (NULL != pTmpASBHeadLinkIdBuf)
				&& (0u != cTmpASATailNum) && (NULL != pTmpASATailLinkIdBuf)
				&& (0u != cTmpASTailBNum) && (NULL != pTmpASBTailLinkIdBuf))
			{
				/* 根据方向获取头尾link */
				if (DIR_SAME == cDir)
				{
					cLinkAHeadId = pTmpASAHeadLinkIdBuf[0];
					cLinkBHeadId = pTmpASBHeadLinkIdBuf[0];

					cLinkATainId = pTmpASATailLinkIdBuf[cTmpASATailNum - 1u];
					cLinkBTainId = pTmpASBTailLinkIdBuf[cTmpASTailBNum - 1u];
				}
				else
				{
					cLinkAHeadId = pTmpASAHeadLinkIdBuf[cTmpASAHeadNum - 1u];
					cLinkBHeadId = pTmpASBHeadLinkIdBuf[cTmpASHeadBNum - 1u];

					cLinkATainId = pTmpASATailLinkIdBuf[0];
					cLinkBTainId = pTmpASBTailLinkIdBuf[0];
				}
			}
			else
			{
				cFunRetVal = CI_ERROR;
			}
		}

		if (CI_SUCCESS == cFunRetVal)
		{
			pointA.Lnk = cLinkAHeadId;
			pointB.Lnk = cLinkBHeadId;
			pointA.Off = 0u;
			pointB.Off = 0u;
			dwDis = dsuLenByPoint(&pointA,&pointB,&wDevSum,szDevIdBuf,&cEmapDir);

			if ((UINT32_MAX != dwDis) && ((EMAP_SAME_DIR == cEmapDir) || (EMAP_CONVER_DIR == cEmapDir)))
			{
				/* 获取查询方向 */
				if (((EMAP_SAME_DIR == cEmapDir) && (DIR_SAME == cDir))
					|| ((EMAP_CONVER_DIR == cEmapDir) && (DIR_CONVERT == cDir)))
				{
					/* A是车尾，B是车头 */
					pointA.Lnk = cLinkBHeadId;
					pointB.Lnk = cLinkATainId;
				}
				else
				{
					/* A是车头，B是车尾*/
					pointA.Lnk = cLinkAHeadId;
					pointB.Lnk = cLinkBTainId;
				}
				pointA.Off = 0u;
				pointB.Off = 0u;
			}
			else
			{
				cFunRetVal = CI_ERROR;
			}
		}

		if (CI_SUCCESS == cFunRetVal)
		{
			/* 传入整车头尾，获取计轴区段 */
			cRetSum = elm_PrepACBtwPointsBySwitchSta(pointB,pointA,pOutputIdBuf);
		}
	}


	return cRetSum;
}

/**
* @brief 查询计轴前/后方计轴
* @param[in] UINT16 ACID 基准计轴ID
* @param[in] UINT8 dir 查询方向
* @param[out] UINT16 arACID[5] 相邻计轴ID
* param[out] UINT8* DirectionPointFlag 是否经过方向变化点 DIRECTIONPOINT_FLAG_VALID
* @return UINT8_MAX 查询失败
0~AC_MAXCNT_IN_SWITCH  查询成功
* @note 无
*/
UINT8 FindAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[5],UINT8* DirectionPointFlag)
{
	UINT8 cDirectionPointFlag = 0U;			/*是否具有方向变化点标志*/
	UINT8 retVal = 0U;
	retVal = elm_PrepareAdjacentAC(ACID, dir, arACID, &cDirectionPointFlag);
	*DirectionPointFlag = cDirectionPointFlag;
	return retVal;

}

/**
 * @brief 获取计轴区段相邻逻辑区段
 * @param[in] UINT16 wAcId 计轴区段ID
 * @param[in] UINT8 chDir 方向
 * @param[out] UINT16 * pLgcIdBuf 逻辑区段ID缓冲区
 * @return 逻辑区段数量，UINT8_MAX失败，0线路终端
 * @note 无
 */
UINT8 FindACAdjacentLogSec(UINT16 wAcId, UINT8 chDir, UINT16 * pLgcIdBuf)
{
	UINT16 wAxleId = 0u;
	UINT8 chRtn = UINT8_MAX;
	UINT16 wSwitchId = 0u;
	struct_PathPoint strTmp = { 0u };
	UINT8 cDirectionPointFlag = 0U;			/*是否具有方向变化点标志*/
	UINT8 chLinkNum = 0u;			/*计轴区段包含LINK数量*/
	UINT16 * pLinkIdBuf = NULL;		/*计轴区段包含linkID*/
	if ((EMAP_SAME_DIR != chDir) && (EMAP_CONVER_DIR != chDir) && (NULL != pLgcIdBuf))
	{
		; /* 入参检查失败，返回0 */
	}
	else
	{

		chLinkNum = GetAxisLinkSum(wAcId);
		pLinkIdBuf = GetAxisLinkIdBuf(wAcId);

		if (EMAP_SAME_DIR == chDir)
		{/* 与link逻辑方向相同 */
			wAxleId = GetAxisTmnlAxisId(wAcId);	/* 取计轴区段终端计轴器 */
			strTmp.wLinkId = GetAxisLinkId(wAxleId);
			strTmp.dwOffset = GetAxisOffsetById(wAxleId);
			if (strTmp.wLinkId != pLinkIdBuf[chLinkNum - 1u])
			{/* 计轴区段终端计轴器所处link不是计轴内终端的link则说明已经是下一link*/
				if (0U == strTmp.dwOffset)
				{
					strTmp.dwOffset++;
				}
				else
				{
					strTmp.dwOffset--;
				}
			}
			else
			{
				strTmp.wLinkId = FindAdjacentLinkIDSafe(strTmp.wLinkId, EMAP_SAME_DIR, &wSwitchId, &cDirectionPointFlag);
				if (DIRECTIONPOINT_FLAG_VALID == cDirectionPointFlag)
				{
					strTmp.dwOffset = GetLinkLengthById(strTmp.wLinkId) - 1u;
				}
				else
				{
					strTmp.dwOffset = 1u;
				}
			}
		}
		else
		{/* 与link逻辑区段相反 */
			wAxleId = GetAxisOrgnAxisId(wAcId);	/* 取计轴区段始端计轴器 */
			strTmp.wLinkId = GetAxisLinkId(wAxleId);
			strTmp.dwOffset = GetAxisOffsetById(wAxleId);
			if (strTmp.wLinkId != pLinkIdBuf[0u])
			{/* 计轴区段始端计轴器所处link不是计轴内始端的link则说明已经是下一link */
				if (0U != strTmp.dwOffset)
				{
					strTmp.dwOffset--;
				}
				else
				{
					strTmp.dwOffset++;
				}
			}
			else
			{
				strTmp.wLinkId = FindAdjacentLinkIDSafe(strTmp.wLinkId, EMAP_CONVER_DIR, &wSwitchId, &cDirectionPointFlag);
				
				if (DIRECTIONPOINT_FLAG_VALID == cDirectionPointFlag)
				{
					strTmp.dwOffset = 1u;
				}
				else
				{
					strTmp.dwOffset = GetLinkLengthById(strTmp.wLinkId) - 1u;
				}
			}
		}

		/* 获取逻辑区段 */
		if (0u == strTmp.wLinkId)
		{/* 线路终端返回0 */
			chRtn = 0u;
		}
		else if (UINT16_MAX == strTmp.wLinkId)
		{/* 查询出错，返回UINT8_MAX */
			chRtn = UINT8_MAX;
		}
		else
		{
			chRtn = GetPointBelongLogSecEx(strTmp, pLgcIdBuf);
			if (0u == chRtn)
			{/* 查询失败 */
				chRtn = UINT8_MAX;
			}
			else
			{
				;
			}
		}
	}

	return chRtn;
}

/*
* 功能描述： 获取计轴相邻逻辑区段状态
* 参数说明： UINT8 dir 方向
            UINT16 ACId 计轴区段ID
* 返回值  ： LOGICSECTION_OCCUPY_UT	非通信车占用
            LOGICSECTION_OCCUPY_NO 无车占用和通信车占用
*/
UINT8 GetACAdjoinLogSecStatus(UINT8 dir,UINT16 ACId)
{
	UINT8 ret = LOGICSECTION_OCCUPY_UT;
	UINT8 logSecStatus = LOGICSECTION_OCCUPY_UT;
	UINT8 cycle = 0u;
	UINT8 logSecCnt = 0;
	UINT16 logSecBuff[AC_MAXCNT_IN_SWITCH] = {0u};

	/** 入口参数校验 */
	ASSERT_RET_VALUE((EMAP_CONVER_DIR != dir) && (EMAP_SAME_DIR != dir),ret,0x80000000u);

	/** 获取道岔相邻逻辑区段 */
	logSecCnt = FindACAdjacentLogSec(ACId,dir,logSecBuff);

	if (0u == logSecCnt)
	{
		ret = LOGICSECTION_OCCUPY_NO;
	}
	else if(UINT8_MAX == logSecCnt)
	{
		ret = LOGICSECTION_OCCUPY_UT;
	}
	else
	{
		for (cycle = 0u; cycle < logSecCnt; cycle++)
		{
			logSecStatus = GetLogSecCurCtOrUtOccupyState(logSecBuff[cycle]);

			if (LOGICSECTION_OCCUPY_UT == logSecStatus)
			{
				break;
			}
		}

		if (cycle == logSecCnt)
		{
			ret = LOGICSECTION_OCCUPY_NO;
		}
		else
		{
			ret = LOGICSECTION_OCCUPY_UT;
		}
	}

	return ret;
}

/**
 * @brief 获取计轴关联的可提前驱动道岔岔区资源是否被征用
 * @param[in] UINT16 ACID 计轴区段id
 * @param[out] 无
 * @return CI_ERROR 计轴未征用
		   CI_SUCCESS 计轴征用
		   UINT8_MAX 查询错误
 * @note 
 */
UINT8 GetACRelSwLogSecLock(UINT16 ACID)
{
	UINT8 ret = UINT8_MAX;
	UINT8 cycleac = 0u;
	UINT8 cycleLogSec = 0u;
	UINT8 cycleSec = 0u;
	UINT8 chLogSecCnt = 0u;
	const UINT16* pLogSecCntBuff = NULL;
	UINT16 wPhyId = 0u;
	UINT8 ACCnt = 0u;
	UINT16* pACBuff = NULL;
	UINT8 TrainLockCnt = 0u;
	UINT8 logSecInPhy = 0u;
	UINT16* pLogSecInphyBuff = NULL;
	UINT8 LogSecLkInphyCnt = 0u;
	UINT16 LogSecLkInphy[AXIS_INCLUDE_LOG_SUM_MAX] = {0u};

	/** 无坏车接近，判断岔区资源是否进行分配，未分配则根据道岔拓扑关系落占用，否则空闲*/
	wPhyId = GetAxisSecRelativePhySecId(ACID);
	ACCnt = GetPAxisSectionSum(wPhyId);
	pACBuff = GetPAxisSectionIdBuf(wPhyId);

	if ((0u == ACCnt) || (NULL == pACBuff))
	{
		/** 注：不要删除if判断条件 */
		ret = UINT8_MAX;
	}
	else
	{
		/** 获取物理区段包含的逻辑区段未释放的逻辑区段 */
		logSecInPhy = GetPhySecIncLogSecSum(wPhyId);
		pLogSecInphyBuff = GetPhySecIncLogSecIdBuf(wPhyId);

		if ((0u == logSecInPhy) || (NULL == pLogSecInphyBuff))
		{
			/** 注：不要删除if判断条件 */
			ret = UINT8_MAX;
		}
		else
		{

			/** 获取物理区段未释放的逻辑区段 */
			for (cycleSec = 0u; cycleSec < logSecInPhy;cycleSec++)
			{
				/** 获取逻辑区段被车锁闭的数量 */
				TrainLockCnt = GetLogSecTrainInfoSum(pLogSecInphyBuff[cycleSec]);

				if (0U < TrainLockCnt)
				{
					LogSecLkInphy[LogSecLkInphyCnt] = pLogSecInphyBuff[cycleSec];
					LogSecLkInphyCnt += 1u;
				}
				else
				{
					/** 继续遍历 */
				}
			}

			if (0u == LogSecLkInphyCnt)
			{
				/** 说明岔区资源全释放，按照道岔拓扑关系落计轴 */
				ret = CI_ERROR;
			}
			else
			{
				/** 判断未释放的逻辑区段是否都为本计轴逻辑区段 */
				chLogSecCnt = GetAxisSecLogSectionSum(ACID);
				pLogSecCntBuff = GetAxisSecLogSectionIdBuf(ACID);

				if ((0u == chLogSecCnt) || (NULL == pLogSecCntBuff))
				{
					/** 注：不要删除if判断条件 */
					ret = UINT8_MAX;
				}
				else
				{
					/** 遍历查询未释放的逻辑区段是否都为本计轴逻辑区段 */
					for (cycleLogSec = 0u;cycleLogSec < chLogSecCnt; cycleLogSec++)
					{
						for (cycleSec = 0u; cycleSec < LogSecLkInphyCnt;cycleSec++)
						{
							if (pLogSecCntBuff[cycleLogSec] == LogSecLkInphy[cycleSec])
							{
								break;
							}
						}

						if (cycleSec == LogSecLkInphyCnt)
						{
							/** 说明存在非本计轴外的逻辑区段未释放*/
							break;
						}
					}

					if ((cycleLogSec == chLogSecCnt) && (chLogSecCnt == LogSecLkInphyCnt))
					{
						/** 说明未释放的逻辑区段都属于本计轴，需根据道岔拓扑关系落计轴 */
						ret = CI_ERROR;
					}
					else
					{
						/** 说明未释放的不全都属于本计轴，需按照包络落计轴*/
						ret = CI_SUCCESS;
					}
				}
			}
		}
	}

	return ret;
}

/**
* @brief 获取计轴区段对应的分界点ID
* @param[in] const UINT16 wAxisSecId 计轴区段ID
* @return 0 失败； 其它 分界点ID
* @note by cgh 20240221
*/
UINT16 GetAxisRelateCfpId(const UINT16 wAxisSecId)
{
	UINT16 wReval = 0U;
	UINT16 wBufIndex = 0U;  /*数组下标*/
	UINT8 ii = 0U;
	UINT8 wAxisSecRelateLinkNum = 0U;/*计轴区段关联LINK数量*/
	UINT16* pAxisSecRelateLinkId = NULL;/*计轴区段关联LINK ID*/
	UINT16 wCfpInFirstLink = 0U;/*分界点内方第一LINK*/
	UINT16 wCfpNum = 0U;/*本控区分界点数目*/
	UINT16 wCfpIndex = 0U;/*分界点索引下标*/
	UINT16 wCfpId = 0U;/*分界点ID*/

	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取区段数组下标*/

	if ((0U < wBufIndex) && (AXIS_SECTION_SUM_MAX > wBufIndex))
	{		
		pAxisSecRelateLinkId = GetAxisLinkIdBuf(wAxisSecId);
		wAxisSecRelateLinkNum = GetAxisLinkSum(wAxisSecId);

		if ((0U < wAxisSecRelateLinkNum) && (AXIS_INCLUDE_LINK_SUM_MAX >= wAxisSecRelateLinkNum) && (NULL != pAxisSecRelateLinkId))
		{
			wCfpNum = GetCfpSum();
			for (wCfpIndex = 0U; wCfpIndex < wCfpNum; wCfpIndex++)
			{
				wCfpId = GetCfpId(wCfpIndex);
				wCfpInFirstLink = GetCfpInFirstLink(wCfpId);
				for (ii = 0U; ii < wAxisSecRelateLinkNum; ii++)
				{
					if (pAxisSecRelateLinkId[ii] == wCfpInFirstLink)
					{
						/*计轴区段关联LINK一定不为0，此时若分界点内方第一LINK和此LINK相同，则为要找的分界点*/
						wReval = wCfpId;
						break;
					}
					else
					{
						; /*继续查找*/
					}
				}

				if (wCfpId == wReval)
				{
					break;
				}
				else
				{
					/*继续遍历*/
				}
			}
		}
		else
		{
			/*获取计轴区段包含的link失败，返回0失败*/
		}
	}
	else
	{
		; /*计轴区段ID不合法*/
	}

	return wReval;
}
/*
* 功能描述： 获取指定ID计轴区临线属性
* 参数说明： const UINT16 axisSectionId, 计轴区段ID
* 返回值  ： AXIS_SEC_LINXIAN_YES: 具备临线属性(非本线路)
*			 AXIS_SEC_LINXIAN_NO: 不具备临线属性(本线路)
*/
UINT8 GetAxisSecLinXianFlag(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = AXIS_SEC_LINXIAN_NO;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].chAxisLinXian;
	}
	else
	{
		retVal = AXIS_SEC_LINXIAN_NO;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段的存车线属性
* 参数说明： const UINT16 axisSectionId 计轴区段ID
* 返回值  ： 0 获取数据失败
*		     0x55 具有存车线属性
*            0xAA 不具有存车线属性
*/
UINT8 GetAxisSecStorageLineProperty(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].chStorageLineProperty;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段总长度
* 参数说明： const UINT16 axisSectionId 计轴区段ID
* 返回值  ： 0：错误   >0 计轴link总长度
*/
UINT32 GetAxisSecTotalLen(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 axisLinkLen = 0U;/*单个link长度 cm*/
	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		axisLinkLen = AxisSectionConfigDataStru[bufIndex].dwAxisTotalLen;
	}
	else
	{
		; /*返回0*/
	}
	return axisLinkLen;
}

/*
* 功能描述：获取指定ID计轴区段的边界计轴区段属性
* 参数说明：const UINT16 axisSectionId 计轴区段ID
* 返 回 值：0 获取数据失败
*		    0x55 边界计轴区段
*           0xAA 非边界计轴区段
*/
UINT8 GetAxisSecBorderProperty(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].cBorderAttr;
	}
	else
	{
		retVal = CI_ERROR;
	}

	return retVal;
}

/*
* 功能描述：获取指定ID计轴区段的CBTC区域属性
* 参数说明：const UINT16 axisSectionId 计轴区段ID
* 返 回 值：0x55 具有CBTC区域属性
*           0xAA 不具有CBTC区域属性
* Created By LQ 2025.08.05
*/
UINT8 GetAxisSecCbtcProperty(const UINT16 axisSectionId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = AXIS_SEC_CBTC_PROPERTY_NO;

	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/

	if (bufIndex < AXIS_SECTION_SUM_MAX)
	{
		retVal = AxisSectionConfigDataStru[bufIndex].cAcCbtcAttr;
	}
	else
	{
		/*不处理*/
	}

	return retVal;
}

/*
* 功能描述： 获取指定ID计轴区段关联防护道岔数目
* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
* 返回值  ： 0: 获取数据失败
*			>0: 道岔数目
*  创建	  :  mpt 20260331
*/
UINT8 GetAxisSecRelateProSwSum(const UINT16 wAxisSecId)
{
	UINT16 wBufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取计轴区段数组下标*/

	if (AXIS_SECTION_SUM_MAX > wBufIndex)
	{
		retVal = AxisSectionConfigDataStru[wBufIndex].chRelateProSwSum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID计轴区段关联防护道岔结构体
* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
* 返回值  ： NULL: 获取数据失败
*			非NULL: 道岔ID数组指针
* 创建	  : mpt 20260331
*/
AxisSwitchStruct* GetAxisSecRelateProSwStru(const UINT16 wAxisSecId)
{
	UINT16 wBufIndex = 0u;  /*数组下标*/
	AxisSwitchStruct* retVal = NULL;

	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取数组下标*/

	if (AXIS_SECTION_SUM_MAX > wBufIndex)
	{
		retVal = AxisSectionConfigDataStru[wBufIndex].wRelateProSwId;
	}
	else
	{
		retVal = NULL;
	}
	return retVal;
}

