using DataEntity.Share;
using DataRWDAL;
using HxEnum;
using HxSocket;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Xml;
using XCommon;
using XCommon.Log;
using XCore;
using XHandler.Class.DataEx;
using XHandler.Controls.Run.Com;
using XHandler.View;
using XImagingXhandler.XDAL;

namespace XHandler.Controls
{
    /// <summary>
    /// 梯度稀释逻辑控制类
    /// </summary>
    public class DilutionControl
    {
        #region 变量
        // 系统语言
        private string m_currentCulture = string.Empty;

        // 涂布用变量
        private MethodDilution DilutionData = null;

        #region BLL
        private DilutionBll dilutionBll = new DilutionBll();
        private LiquidAccuracyBll liquidAccuracyBll = new LiquidAccuracyBll();
        private AspirateBll aspirateBll = new AspirateBll();
        private DispenseBll dispenseBll = new DispenseBll();
        //private BacteriaBll bacteriaBll = new BacteriaBll();
        #endregion

        // 运行界面
        public static RunWnd LaunchView = null;
        public HxSocketClient socketTcpClientToRemote = null;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public DilutionControl()
        {
            m_currentCulture = Shared.SoftwareInformation.currentculture;
        }

        #region 执行涂布转板
        /// <summary>
        /// 执行涂布转板
        /// </summary>
        /// <param name="xmlEnv"></param>
        /// <param name="methodNode"></param>
        /// <param name="isSimulator"></param>
        /// <returns></returns>
        public bool ExecuteDilution(XmlNode xmlEnv, XmlNode methodNode, bool isSimulator)
        {
            bool bResult = false;
            var platformNodeList = xmlEnv.SelectNodes("platform");
            string strMethodName = methodNode.SelectSingleNode("name").InnerText;

            #region 任务被取消
            if (LaunchView._cancelSource.IsCancellationRequested)
            {
                return bResult;
            }
            #endregion

            #region RunLog start
            if (m_currentCulture.Equals("zh-CN"))
            {
                LaunchView.AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】> Xhandler: 【" + strMethodName + "】" + Properties.MachineRunResource.strStart.ToString());
            }
            else
            {
                LaunchView.AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】> Xhandler: 【" + strMethodName + "】start:");
            }
            #endregion

            try
            {
                #region 数据准备
                DilutionData = dilutionBll.GenerateMethodDilutionDataByXmlNode(methodNode);

                #region 加稀释液
                #region 吸液
                // 获取吸液的耗材:试剂槽
                Labware aspirateLabwareAddDiluent = LabwareDB.GetLabware(DilutionData.labwareValueAddDiluent);
                // 获取吸液板位
                XmlNode xmlAspirateAddDiluent = xmlEnv.SelectSingleNode("platform[labware_sname='" + DilutionData.positionTextAddDiluent + "']");
                string aspirateLatticeNoAddDiluent = xmlAspirateAddDiluent.SelectSingleNode("lattice_id").InnerText;
                int aspirateLatticeIdAddDiluent = ControlCom.GetLatticeId(Convert.ToInt32(aspirateLatticeNoAddDiluent));
                Lattice aspirateLatticeAddDiluent = LatticeDB.GetLatticeDataByIdFromdb(aspirateLatticeIdAddDiluent.ToString());
                // 吸液选中区域排序
                List<TipsTable> aspirateWellsAddDiluent = SortWells(aspirateLabwareAddDiluent, aspirateLatticeAddDiluent, DilutionData.wellarrayAddDiluent);
                // 每个孔加稀释液的体积: 500 * (2-1) =500
                float dilutionVolAddDiluent = DilutionData.volume * (DilutionData.dilutionFactor - 1);
                // 吸液板条码
                string aspirateLabwareBarcodeAddDiluent = xmlAspirateAddDiluent.SelectSingleNode("labware_barcode").InnerText;
                #endregion

                #region 放液
                // 获取放液的耗材:96深孔板
                Labware dispenseLabwareAddDiluent = LabwareDB.GetLabware(DilutionData.labwareValueGradientDilution);
                // 获取放液板位
                XmlNode xmlDispenseAddDiluent = xmlEnv.SelectSingleNode("platform[labware_sname='" + DilutionData.positionTextGradientDilution + "']");
                string dispenseLatticeNoAddDiluent = xmlDispenseAddDiluent.SelectSingleNode("lattice_id").InnerText;
                int dispenseLatticeIdAddDiluent = ControlCom.GetLatticeId(Convert.ToInt32(dispenseLatticeNoAddDiluent));
                Lattice dispenseLatticeAddDiluent = LatticeDB.GetLatticeDataByIdFromdb(dispenseLatticeIdAddDiluent.ToString());
                // 放液板条码
                string dispenseLabwareBarcodeAddDiluent = xmlDispenseAddDiluent.SelectSingleNode("labware_barcode").InnerText;

                // 放液选中区域所有孔位信息（已排序）
                List<TipsTable> dispenseWellsAddDiluent = SortWells(dispenseLabwareAddDiluent, dispenseLatticeAddDiluent, DilutionData.wellarrayGradientDilution);

                // 放液首列数据
                List<TipsTable> dispenseFirstWellsAddDiluent = GetFirstOrLastData(dispenseWellsAddDiluent, 0, DilutionData.dilutionDirectionValue);
                List<TipsTable> dispenseNoFirstWellsAddDiluent = GetFirstOrLastData(dispenseWellsAddDiluent, 1, DilutionData.dilutionDirectionValue);

                // 最终需要加稀释液的集合
                List<TipsTable> dispenseWellsFinalAddDiluent = DilutionData.isTargetSelectRangeFirstAddDiluent ? dispenseWellsAddDiluent : dispenseNoFirstWellsAddDiluent;
                #endregion

                #region 枪头
                LoadTipsControl.launchView = DilutionControl.LaunchView;
                List<TipsTable> tipWells = LoadTipsControl.GetLeftTipsByLoadTips(platformNodeList, methodNode);
                // 加稀释液时是否更换枪头
                bool isChangeTipAddDiluent = Convert.ToInt32(DilutionData.changeTipsValueAddDiluent) ==
                    EnumManagement.GetEnumValue(ChangeTipEnum.Change) ? true : false;
                #endregion
                #endregion

                #region 梯度稀释
                #region 吸放液
                // 获取吸放液的耗材:96深孔板
                Labware labwareGradientDilution = LabwareDB.GetLabware(DilutionData.labwareValueGradientDilution);
                // 获取吸放液板位
                XmlNode xmlGradientDilution = xmlEnv.SelectSingleNode("platform[labware_sname='" + DilutionData.positionTextGradientDilution + "']");
                string latticeNoGradientDilution = xmlGradientDilution.SelectSingleNode("lattice_id").InnerText;
                int latticeIdGradientDilution = ControlCom.GetLatticeId(Convert.ToInt32(latticeNoGradientDilution));
                Lattice latticeGradientDilution = LatticeDB.GetLatticeDataByIdFromdb(latticeIdGradientDilution.ToString());
                // 梯度稀释选中区域排序
                List<TipsTable> wellsGradientDilution = SortWells(labwareGradientDilution, latticeGradientDilution, DilutionData.wellarrayGradientDilution);
                // 每个孔移液的体积: 500
                float volGradientDilution = DilutionData.volume;
                // 吸放液板条码
                string labwareBarcodeGradientDilution = xmlGradientDilution.SelectSingleNode("labware_barcode").InnerText;

                // 首列/行数据
                List<TipsTable> firstWellsGradientDilution = GetFirstOrLastData(wellsGradientDilution, 0, DilutionData.dilutionDirectionValue);
                List<TipsTable> noFirstWellsGradientDilution = GetFirstOrLastData(wellsGradientDilution, 1, DilutionData.dilutionDirectionValue);
                #endregion

                #region 枪头
                //LoadTipsControl.launchView = DilutionControl.LaunchView;
                //List<TipsTable> tipWellsGradientDilution = LoadTipsControl.GetLeftTipsByLoadTips(platformNodeList, methodNode);
                // 梯度稀释时是否更换枪头
                bool isChangeTipGradientDilution = Convert.ToInt32(DilutionData.changeTipsValueGradientDilution) ==
                    EnumManagement.GetEnumValue(ChangeTipEnum.Change) ? true : false;
                #endregion
                #endregion

                #endregion

                #region 根据所选区域 加稀释液
                // 计算加稀释液的执行seq
                List<MultiChannel> multiChannelList = GetNeedChanelInfo(DilutionData.channels, tipWells, isChangeTipAddDiluent,
                    aspirateLabwareAddDiluent, aspirateLatticeAddDiluent, aspirateWellsAddDiluent,
                    dispenseLabwareAddDiluent, dispenseLatticeAddDiluent, dispenseWellsFinalAddDiluent, DilutionData.dilutionDirectionValue);

                for (int nBatchIndex = 0; nBatchIndex < multiChannelList.Count; nBatchIndex++)
                {
                    MultiChannel multiChannel = multiChannelList[nBatchIndex];

                    #region 安装枪头 
                    if (nBatchIndex == 0 || isChangeTipAddDiluent)
                    {
                        // 自动计算位置安装Tip
                        bool bLoadTipResult = ControlCom.LoadTipAutomation(xmlEnv.SelectNodes("platform"), methodNode,
                               isSimulator, LaunchView, socketTcpClientToRemote, 0);
                        if (!bLoadTipResult)
                        {
                            return false;
                        }
                    }
                    #endregion

                    #region 吸液
                    // 获取加稀释液的吸液参数
                    AspirateMultiParams aspirateAddDiluentParams = GetAspirateParamsAddDiluent(DilutionData);
                    bResult = ControlCom.DoAspirateForMulti(LaunchView, m_currentCulture, aspirateAddDiluentParams, multiChannel,
                        aspirateLabwareAddDiluent, dilutionVolAddDiluent, strMethodName, dispenseLabwareBarcodeAddDiluent, isSimulator);
                    if (!bResult)
                    {
                        return bResult;
                    }
                    #endregion

                    #region 放液
                    // 获取吸液参数
                    DispenseMultiParams dispenseAddDiluentParams = GetDispenseParamsAddDiluent(DilutionData);
                    bResult = ControlCom.DoDispenseForMulti(LaunchView, m_currentCulture, dispenseAddDiluentParams, multiChannel,
                        dispenseLabwareAddDiluent, dilutionVolAddDiluent, strMethodName, dispenseLabwareBarcodeAddDiluent, isSimulator);
                    if (!bResult)
                    {
                        return bResult;
                    }
                    #endregion

                    #region 卸载Tip,丢在垃圾桶 
                    if ((nBatchIndex == multiChannelList.Count - 1) || isChangeTipAddDiluent)
                    {
                        UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                        unloadTipsControl.launchView = LaunchView;
                        unloadTipsControl.socketTcpClientToRemote = socketTcpClientToRemote;
                        bool bUnloadResult = unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, methodNode, isSimulator);
                        if (!bUnloadResult)
                        {
                            bResult = false;
                            return bResult;
                        }
                        LaunchView.currentIsLoadingTips = false;
                    }
                    #endregion
                }
                #endregion

                #region 进行梯度稀释
                // 放液首列数据
                //dispenseFirstWellsAddDiluent

                // 计算梯度稀释的执行seq
                List<MultiChannel> multiChannelGradientDilutionList = GetGradientDilutionSeqInfo(DilutionData.channels, tipWells, isChangeTipGradientDilution,
                    wellsGradientDilution, DilutionData.dilutionDirectionValue, DilutionData.isDiscardLastVolume);

                bool isDiscardLastTip = false;
                for (int nBatchIndex = 0; nBatchIndex < multiChannelGradientDilutionList.Count; nBatchIndex++)
                {
                    MultiChannel multiChannel = multiChannelGradientDilutionList[nBatchIndex];

                    #region 修改通道数量
                    List<int> channelList = new List<int>();
                    for (int channelNo = 1; channelNo <= multiChannel.SrcPlateWells.Count; channelNo++)
                    {
                        channelList.Add(channelNo);
                    }
                    string strChn = string.Join(",", channelList);
                    methodNode.SelectSingleNode("channels").InnerText = strChn;
                    DilutionData.channels = ComUtility.GetChannelsFromXml(strChn);
                    #endregion

                    #region 安装枪头 
                    if (nBatchIndex == 0 || isChangeTipGradientDilution || isDiscardLastTip)
                    {
                        isDiscardLastTip = false;
                        // 自动计算位置安装Tip
                        bool bLoadTipResult = ControlCom.LoadTipAutomation(xmlEnv.SelectNodes("platform"), methodNode,
                               isSimulator, LaunchView, socketTcpClientToRemote, 0);
                        if (!bLoadTipResult)
                        {
                            return false;
                        }
                    }
                    #endregion

                    #region 吸液
                    // 获取加稀释液的吸液参数
                    AspirateMultiParams aspirateAddDiluentParams = GetAspirateParamsGradientDilution(DilutionData);
                    bResult = ControlCom.DoAspirateForMulti(LaunchView, m_currentCulture, aspirateAddDiluentParams, multiChannel,
                        labwareGradientDilution, dilutionVolAddDiluent, strMethodName, labwareBarcodeGradientDilution, isSimulator);
                    if (!bResult)
                    {
                        return bResult;
                    }
                    #endregion

                    #region 放液
                    if (multiChannel.DesPlateWells != null)
                    {
                        // 获取吸液参数
                        DispenseMultiParams dispenseAddDiluentParams = GetDispenseParamsGradientDilution(DilutionData, labwareGradientDilution);
                        bResult = ControlCom.DoDispenseForMulti(LaunchView, m_currentCulture, dispenseAddDiluentParams, multiChannel,
                            labwareGradientDilution, dilutionVolAddDiluent, strMethodName, labwareBarcodeGradientDilution, isSimulator);
                        if (!bResult)
                        {
                            return bResult;
                        }
                    }
                    else
                    {
                        isDiscardLastTip = true;
                    }
                    #endregion

                    #region 卸载Tip,丢在垃圾桶 
                    if ((nBatchIndex == multiChannelGradientDilutionList.Count - 1) || isChangeTipGradientDilution || isDiscardLastTip)
                    {
                        UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                        unloadTipsControl.launchView = LaunchView;
                        unloadTipsControl.socketTcpClientToRemote = socketTcpClientToRemote;
                        bool bUnloadResult = unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, methodNode, isSimulator);
                        if (!bUnloadResult)
                        {
                            bResult = false;
                            return bResult;
                        }
                        LaunchView.currentIsLoadingTips = false;
                    }
                    #endregion
                }


                #endregion

                bResult = true;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);

                #region Exception
                LaunchView.AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + strMethodName + "】error:source:" + ex.Source + ";error:" + ex.Message + ";");
                bResult = false;
                #endregion
            }

            return bResult;
        }
        #endregion

        #region 获取吸液参数
        /// <summary>
        /// 获取加稀释液 吸液参数
        /// </summary>
        /// <param name="dilutionData"></param>
        /// <returns></returns>
        private AspirateMultiParams GetAspirateParamsAddDiluent(MethodDilution dilutionData)
        {
            AspirateMultiParams aspirateParams = new AspirateMultiParams();
            aspirateParams.liquidTypeText = dilutionData.liquidTypeTextAddDiluent;
            aspirateParams.liquidTypeValue = dilutionData.liquidTypeValueAddDiluent;
            aspirateParams.liquidRangeText = dilutionData.liquidRangeTextAddDiluent;
            aspirateParams.liquidRangeValue = dilutionData.liquidRangeValueAddDiluent;
            aspirateParams.liquidText = dilutionData.liquidTextAddDiluent;
            aspirateParams.liquidValue = dilutionData.liquidValueAddDiluent;
            aspirateParams.armValue = dilutionData.armValue;
            aspirateParams.channels = dilutionData.channels;
            aspirateParams.isMix = false;

            return aspirateParams;
        }

        /// <summary>
        /// 获取梯度稀释 吸液参数
        /// </summary>
        /// <param name="dilutionData"></param>
        /// <returns></returns>
        private AspirateMultiParams GetAspirateParamsGradientDilution(MethodDilution dilutionData)
        {
            AspirateMultiParams aspirateParams = new AspirateMultiParams();
            aspirateParams.liquidTypeText = dilutionData.liquidTypeTextGradientDilution;
            aspirateParams.liquidTypeValue = dilutionData.liquidTypeValueGradientDilution;
            aspirateParams.liquidRangeText = dilutionData.liquidRangeTextGradientDilution;
            aspirateParams.liquidRangeValue = dilutionData.liquidRangeValueGradientDilution;
            aspirateParams.liquidText = dilutionData.liquidTextGradientDilution;
            aspirateParams.liquidValue = dilutionData.liquidValueGradientDilution;
            aspirateParams.armValue = dilutionData.armValue;
            aspirateParams.channels = dilutionData.channels;
            aspirateParams.isMix = false;

            return aspirateParams;
        }

        #endregion

        #region 获取加稀释 放液参数
        /// <summary>
        /// 获取加稀释液吸液参数
        /// </summary>
        /// <param name="dilutionData"></param>
        /// <returns></returns>
        private DispenseMultiParams GetDispenseParamsAddDiluent(MethodDilution dilutionData)
        {
            DispenseMultiParams dispenseParams = new DispenseMultiParams();
            dispenseParams.liquidTypeText = dilutionData.liquidTypeTextAddDiluent;
            dispenseParams.liquidTypeValue = dilutionData.liquidTypeValueAddDiluent;
            dispenseParams.liquidRangeText = dilutionData.liquidRangeTextAddDiluent;
            dispenseParams.liquidRangeValue = dilutionData.liquidRangeValueAddDiluent;
            dispenseParams.liquidText = dilutionData.liquidTextAddDiluent;
            dispenseParams.liquidValue = dilutionData.liquidValueAddDiluent;
            dispenseParams.armValue = dilutionData.armValue;
            dispenseParams.channels = dilutionData.channels;    // 移液枪通道: 已sort
            dispenseParams.isMix = false;

            return dispenseParams;
        }
        #endregion

        #region 获取梯度稀释 放液参数
        /// <summary>
        /// 获取梯度稀释 放液参数
        /// </summary>
        /// <param name="dilutionData"></param>
        /// <param name="labware"></param>
        /// <returns></returns>
        private DispenseMultiParams GetDispenseParamsGradientDilution(MethodDilution dilutionData, Labware labware)
        {
            DispenseMultiParams dispenseParams = new DispenseMultiParams();
            dispenseParams.liquidTypeText = dilutionData.liquidTypeTextGradientDilution;
            dispenseParams.liquidTypeValue = dilutionData.liquidTypeValueGradientDilution;
            dispenseParams.liquidRangeText = dilutionData.liquidRangeTextGradientDilution;
            dispenseParams.liquidRangeValue = dilutionData.liquidRangeValueGradientDilution;
            dispenseParams.liquidText = dilutionData.liquidTextGradientDilution;
            dispenseParams.liquidValue = dilutionData.liquidValueGradientDilution;
            dispenseParams.armValue = dilutionData.armValue;
            dispenseParams.channels = dilutionData.channels;        // 移液枪通道: 已sort

            dispenseParams.isMix = dilutionData.bMix;
            dispenseParams.mixvolume = (float)Convert.ToDouble(dilutionData.mixvolume);
            dispenseParams.mixCount = dilutionData.mixcount;

            dispenseParams.mixAspiratePositionValue = Convert.ToInt32(dilutionData.mixAspiratePositionValue);
            dispenseParams.mixAspiratePositionText = dilutionData.mixAspiratePositionText;
            dispenseParams.mixAspirateDistance = (float)Convert.ToDouble(dilutionData.mixAspirateDistance);
            dispenseParams.mixAspirateSpeed = (float)Convert.ToDouble(dilutionData.mixAspirateSpeed);

            dispenseParams.mixDispensePositionValue = Convert.ToInt32(dilutionData.mixDispensePositionValue);
            dispenseParams.mixDispensePositionText = dilutionData.mixDispensePositionText;
            dispenseParams.mixDispenseDistance = (float)Convert.ToDouble(dilutionData.mixDispenseDistance);
            dispenseParams.mixDispenseSpeed = (float)Convert.ToDouble(dilutionData.mixDispenseSpeed);

            return dispenseParams;
        }
        #endregion

        #region 选中区域排序
        /// <summary>
        /// 选中区域排序
        /// </summary>
        /// <param name="srcLabware"></param>
        /// <param name="srcLattice"></param>
        /// <param name="wells"></param>
        /// <returns></returns>
        private List<TipsTable> SortWells(Labware srcLabware, Lattice srcLattice, string wells)
        {
            List<TipsTable> sortWells = new List<TipsTable>();

            if (!string.IsNullOrEmpty(wells))
            {
                List<TipsTable> dtsTips = ControlCom.GenerateWellCoordinate(srcLabware, srcLattice);
                List<string> srcWellList = wells.Split(',').ToList();

                foreach (var item in dtsTips)
                {
                    if (srcWellList.Contains(item.wellname))
                    {
                        sortWells.Add(item);
                    }
                }
            }

            return sortWells;
        }
        #endregion

        #region 计算加稀释液的执行seq
        /// <summary>
        /// 计算加稀释液的执行seq
        /// </summary>
        /// <param name="channels">通道数</param>
        /// <param name="tipWells">来源板</param>
        /// <param name="isCareTips">是否考虑枪头</param>
        /// <param name="srcLabware">来源板</param>
        /// <param name="srcLattice"></param>
        /// <param name="srcWells"></param>
        /// <param name="desLabware">目标板</param>
        /// <param name="desLattice"></param>
        /// <param name="desWells"></param>
        /// <param name="dilutionDirectionValue"></param>
        private List<MultiChannel> GetNeedChanelInfo(int[] channels, List<TipsTable> tipWells, bool isCareTips,
            Labware srcLabware, Lattice srcLattice, List<TipsTable> srcWells,
            Labware desLabware, Lattice desLattice, List<TipsTable> desWells, DilutionDirectionEnum dilutionDirectionValue)
        {
            List<MultiChannel> multiChannelList = new List<MultiChannel>();

            //int chnCount = channels.Length;
            //int srcCount = srcWells.Count;
            //int desCount = desWells.Count;

            // 根据列有效数量计算列的批次信息
            List<List<TipsTable>> tipWellBatchList = ComUtility.GetWellBatchInfo(tipWells, channels, dilutionDirectionValue);
            List<List<TipsTable>> srcWellsWellBatchList = ComUtility.GetWellBatchInfo(srcWells, channels, dilutionDirectionValue);
            List<List<TipsTable>> desWellBatchList = ComUtility.GetWellBatchInfo(desWells, channels, DilutionDirectionEnum.LeftToRight);

            // 此处算法不通用 需要优化
            for (int i = 0; i < desWellBatchList.Count; i++)
            {
                MultiChannel multiChannel = new MultiChannel();
                //multiChannel.Tips = isCareTips ? tipWellBatchList[i] : tipWellBatchList[0];

                // 试剂槽
                if (Convert.ToInt32(srcLabware.labware_type_id) == EnumManagement.GetEnumValue(ConsumableTypeEnum.Through))
                {
                    List<TipsTable> finalSrcWells = new List<TipsTable>(srcWellsWellBatchList[0]);
                    int nAddCnt = desWellBatchList[i].Count - srcWellsWellBatchList[0].Count;

                    for (int nAddIndex = 0; nAddIndex < nAddCnt; nAddIndex++)
                    {
                        finalSrcWells.Add(srcWellsWellBatchList[0][0]);
                    }

                    multiChannel.SrcPlateWells = finalSrcWells;
                }
                else
                {
                    multiChannel.SrcPlateWells = srcWellsWellBatchList[i];
                }

                multiChannel.DesPlateWells = desWellBatchList[i];
                multiChannelList.Add(multiChannel);
            }

            return multiChannelList;
        }
        #endregion

        #region 计算梯度稀释的执行seq
        /// <summary>
        /// 计算梯度稀释的执行seq
        /// </summary>
        /// <param name="channels"></param>
        /// <param name="tipWells"></param>
        /// <param name="isCareTips"></param>
        /// <param name="wellsGradientDilution"></param>
        /// <param name="dilutionDirectionValue"></param>
        /// <param name="isDiscardLastVolume">舍弃选中范围最后一行或最后一列多余的体积</param>
        /// <returns></returns>
        private List<MultiChannel> GetGradientDilutionSeqInfo(int[] channels, List<TipsTable> tipWells, bool isCareTips,
            List<TipsTable> wellsGradientDilution, DilutionDirectionEnum dilutionDirectionValue, bool isDiscardLastVolume)
        {
            List<MultiChannel> multiChannelList = new List<MultiChannel>();

            // 根据列有效数量计算列的批次信息
            List<List<TipsTable>> tipWellBatchList = ComUtility.GetWellBatchInfo(tipWells, channels, dilutionDirectionValue);

            #region 吸液范围
            // 默认为尾列以外的数据
            List<TipsTable> srcWells = GetFirstOrLastData(wellsGradientDilution, 3, DilutionData.dilutionDirectionValue);
            // 舍弃选中范围最后一行或最后一列多余的体积
            if (isDiscardLastVolume)
            {
                srcWells = wellsGradientDilution;
            }
            #endregion

            #region 放液范围
            List<TipsTable> lastWellsGradientDilution = GetFirstOrLastData(wellsGradientDilution, 2, DilutionData.dilutionDirectionValue);

            // 默认为首行/列数据以外的数据
            List<TipsTable> desWells = GetFirstOrLastData(wellsGradientDilution, 1, DilutionData.dilutionDirectionValue);
            #endregion

            List<List<TipsTable>> srcWellBatchList = ComUtility.GetWellBatchInfo(srcWells, channels, dilutionDirectionValue);
            List<List<TipsTable>> desWellBatchList = ComUtility.GetWellBatchInfo(desWells, channels, dilutionDirectionValue);

            for (int i = 0; i < srcWellBatchList.Count; i++)
            {
                MultiChannel multiChannel = new MultiChannel();
                //multiChannel.Tips = isCareTips ? tipWellBatchList[i] : tipWellBatchList[0];
                multiChannel.SrcPlateWells = srcWellBatchList[i];

                // 舍弃选中范围最后一行或最后一列多余的体积
                if (isDiscardLastVolume)
                {
                    if (srcWellBatchList[i].Exists(it => lastWellsGradientDilution.Exists(kk=>kk.wellname.Equals(it.wellname))))
                    {
                        desWellBatchList.Insert(i, null);
                    }
                }

                multiChannel.DesPlateWells = desWellBatchList[i];

                //multiChannel.DesPlateWells = null;
                //if (i < desWellBatchList.Count())
                //{
                //}

                multiChannelList.Add(multiChannel);
            }

            return multiChannelList;
        }
        #endregion
  
        #region 获取首行或首列数据
        /// <summary>
        /// 获取首行/列数据
        /// </summary>
        /// <param name="srcData"></param>
        /// <param name="type">0: 首行/列数据; 1: 首行/列数据以外的数据; 2: 尾行/列数据; 3: 尾行/列数据以外的数据</param>
        /// <param name="direction">方向</param>
        /// <returns></returns>
        private List<TipsTable> GetFirstOrLastData(List<TipsTable> srcData, int type,
            DilutionDirectionEnum direction)
        {
            List<TipsTable> rtnData = new List<TipsTable>();

            if (srcData.Count > 0)
            {
                IEnumerable<TipsTable> selTipWells = null;
                // 从左到右
                if (direction == DilutionDirectionEnum.LeftToRight)
                {
                    int strFirstColNum = ComUtility.GetColNum(srcData[0].wellname);
                    int strLastColNum = ComUtility.GetColNum(srcData.LastOrDefault().wellname);

                    selTipWells = srcData.Where(it => ((type == 0 && ComUtility.GetColNum(it.wellname) == strFirstColNum)) ||
                            (type ==1 && ComUtility.GetColNum(it.wellname) != strFirstColNum) ||
                            (type == 2 && ComUtility.GetColNum(it.wellname) == strLastColNum) ||
                            (type == 3 && ComUtility.GetColNum(it.wellname) != strLastColNum));
                }
                // 从上到下
                else if (direction == DilutionDirectionEnum.UpToDown)
                {
                    string strFirstRowChar = ComUtility.GetRowChar(srcData[0].wellname);
                    string strLastRowChar = ComUtility.GetRowChar(srcData.LastOrDefault().wellname);

                    selTipWells = srcData.Where(it => ((type == 0 && ComUtility.GetRowChar(it.wellname).Equals(strFirstRowChar))) ||
                            (type == 1 && !ComUtility.GetRowChar(it.wellname).Equals(strFirstRowChar)) ||
                            (type == 2 && ComUtility.GetRowChar(it.wellname).Equals(strLastRowChar)) ||
                            (type == 3 && !ComUtility.GetRowChar(it.wellname).Equals(strLastRowChar)));
                }
                // 从下到上
                else if (direction == DilutionDirectionEnum.DownToUp)
                {
                    string strFirstRowChar = ComUtility.GetRowChar(srcData.LastOrDefault().wellname);
                    string strLastRowChar = ComUtility.GetRowChar(srcData[0].wellname);
                    selTipWells = srcData.Where(it => ((type == 0 && ComUtility.GetRowChar(it.wellname).Equals(strFirstRowChar))) ||
                            (type == 1 && !ComUtility.GetRowChar(it.wellname).Equals(strFirstRowChar)) ||
                            (type == 2 && ComUtility.GetRowChar(it.wellname).Equals(strLastRowChar)) ||
                            (type == 3 && !ComUtility.GetRowChar(it.wellname).Equals(strLastRowChar)));
                }

                if (selTipWells.Any())
                {
                    rtnData = selTipWells.ToList();
                }
            }

            return rtnData;
        }
        #endregion
    }
}