using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XImagingXhandler.XDAL;
using System.Resources;
using XCoreBLL.Resource;
using System.Xml;
using System.Xml.Linq;
using System.Data;
using DriverManager;
using DriverLibrary;
using DriverLib;
using DriverLib.Engine;
using System.Collections.ObjectModel;
using XCommon.Log;
using DataCalcDAL.Com;
using DataEntity.Share;
using XCommon;
using DataRWDAL;
using DataEntity;

namespace XCore
{
    /// <summary>
    /// 吸液业务逻辑处理
    /// </summary>
    public class AspirateBll
    {
        string strCurrentCulture = "";
        WellCalc wellCalc = new WellCalc();
        LatticeBll latticeBll = new LatticeBll();

        public AspirateBll()
        {
            strCurrentCulture = System.Threading.Thread.CurrentThread.CurrentCulture.Name;
        }

        public MethodAspirate GenerateMethodAspirateDataByXmlNode(XmlNode xmlNode)
        {
            MethodAspirate methodAspirate = new MethodAspirate();

            methodAspirate.isrun = xmlNode.SelectSingleNode("isrun").InnerText;
            methodAspirate.status = xmlNode.SelectSingleNode("status").InnerText;
            methodAspirate.name = xmlNode.SelectSingleNode("name").InnerText;
            methodAspirate.label = xmlNode.SelectSingleNode("label").InnerText;
            methodAspirate.strIndex = xmlNode.SelectSingleNode("strIndex").InnerText;
            methodAspirate.labwareText = xmlNode.SelectSingleNode("labware/text").InnerText;
            methodAspirate.labwareValue = xmlNode.SelectSingleNode("labware/value").InnerText;
            methodAspirate.positionText = xmlNode.SelectSingleNode("position/text").InnerText;
            methodAspirate.positionValue = xmlNode.SelectSingleNode("position/value").InnerText;
            methodAspirate.armText = xmlNode.SelectSingleNode("arm/text").InnerText;
            methodAspirate.armValue = xmlNode.SelectSingleNode("arm/value").InnerText;
            methodAspirate.headType= xmlNode.SelectSingleNode("headType").InnerText;
            //methodAspirate.labwaretipText = xmlNode.SelectSingleNode("labwaretip/text").InnerText;
            //methodAspirate.labwaretipValue = xmlNode.SelectSingleNode("labwaretip/value").InnerText;

            string strchs = xmlNode.SelectSingleNode("channels").InnerText;
            methodAspirate.channels = ComUtility.GetChannelsFromXml(strchs);

            methodAspirate.wellarray = xmlNode.SelectSingleNode("wellarray").InnerText;
            methodAspirate.enableSingleWellvolume = xmlNode.SelectSingleNode("enableSingleWellvolume").InnerText.ToLower() == "true" ? true : false;

            XmlNodeList xnList = xmlNode.SelectNodes("SingleWellvolume");
            List<DropdownName> list = new List<DropdownName>();
            foreach (XmlNode xn in xnList)
            {
                DropdownName dropdownName= new DropdownName();
                dropdownName.dropdown_id = xn.SelectSingleNode("channel").InnerText;
                dropdownName.dropdown_name = xn.SelectSingleNode("value").InnerText;
                list.Add(dropdownName);
            }
            methodAspirate.singlewellvolume = list;

            methodAspirate.wellvolume = Convert.ToDouble(xmlNode.SelectSingleNode("wellvolume").InnerText);
            methodAspirate.liquididText = xmlNode.SelectSingleNode("liquidid/text").InnerText;
            methodAspirate.liquididValue = xmlNode.SelectSingleNode("liquidid/value").InnerText;
            methodAspirate.liquidrangeidText = xmlNode.SelectSingleNode("liquidrangeid/text").InnerText;
            methodAspirate.liquidrangeidValue = xmlNode.SelectSingleNode("liquidrangeid/value").InnerText;
            methodAspirate.liquidpidText = xmlNode.SelectSingleNode("liquidpid/text").InnerText;
            methodAspirate.liquidpidValue = xmlNode.SelectSingleNode("liquidpid/value").InnerText;
            methodAspirate.bMix = xmlNode.SelectSingleNode("enableMix").InnerText.ToLower() == "true" ? true : false;
            methodAspirate.bMultiMix = xmlNode.SelectSingleNode("enableMultiMix").InnerText.ToLower() == "true" ? true : false;
            methodAspirate.mixvolume = Convert.ToDouble(xmlNode.SelectSingleNode("mixvolume").InnerText);
            methodAspirate.mixcount = Convert.ToInt32(xmlNode.SelectSingleNode("mixcount").InnerText);
            methodAspirate.mixAspiratePositionText = xmlNode.SelectSingleNode("mixAspiratePosition/text").InnerText;
            methodAspirate.mixAspiratePositionValue = Convert.ToInt32(xmlNode.SelectSingleNode("mixAspiratePosition/value").InnerText);
            methodAspirate.mixAspirateDistance = Convert.ToDouble(xmlNode.SelectSingleNode("mixAspirateDistance").InnerText);
            methodAspirate.mixAspirateSpeed = Convert.ToDouble(xmlNode.SelectSingleNode("mixAspirateSpeed").InnerText);
            methodAspirate.mixDispensePositionText = xmlNode.SelectSingleNode("mixDispensePosition/text").InnerText;
            methodAspirate.mixDispensePositionValue = Convert.ToInt32(xmlNode.SelectSingleNode("mixDispensePosition/value").InnerText);
            methodAspirate.mixDispenseDistance = Convert.ToDouble(xmlNode.SelectSingleNode("mixDispenseDistance").InnerText);
            methodAspirate.mixDispenseSpeed = Convert.ToDouble(xmlNode.SelectSingleNode("mixDispenseSpeed").InnerText);


            methodAspirate.enableLiquidSensor = xmlNode.SelectSingleNode("enableLiquidSensor").InnerText.ToLower()=="true"?true:false;
            methodAspirate.liquidSensorCount= Convert.ToInt32(xmlNode.SelectSingleNode("liquidSensorCount").InnerText);
            methodAspirate.liquidSensorDistance = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorDistance").InnerText);
            methodAspirate.liquidSensorEndDistance = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorEndDistance").InnerText);
            methodAspirate.liquidSensorSpeed = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorSpeed").InnerText);
            methodAspirate.liquidSensorRadio = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorRadio").InnerText);
            methodAspirate.liquidSensorDisIdText = xmlNode.SelectSingleNode("liquidSensorDisId/text").InnerText;
            methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorDisId/value").InnerText);
            methodAspirate.enableLiquidFollow = xmlNode.SelectSingleNode("enableLiquidFollow").InnerText.ToLower() == "true" ? true : false;
            methodAspirate.liquidFollowType = Convert.ToInt32(xmlNode.SelectSingleNode("liquidFollowType/value").InnerText);
            methodAspirate.liquidFollowTypeName = xmlNode.SelectSingleNode("liquidFollowType/text").InnerText;
            methodAspirate.liquidFollowSpeed = Convert.ToDouble(xmlNode.SelectSingleNode("liquidFollowSpeed").InnerText);
            methodAspirate.liquidFollowDistance = Convert.ToDouble(xmlNode.SelectSingleNode("liquidFollowDistance").InnerText);
            methodAspirate.liquidFollowArea = Convert.ToDouble(xmlNode.SelectSingleNode("liquidFollowArea").InnerText);
            methodAspirate.enableMixFollow = xmlNode.SelectSingleNode("enableMixFollow").InnerText.ToLower() == "true" ? true : false;

            methodAspirate.enableSensorBlock = xmlNode.SelectSingleNode("enableSensorBlock").InnerText.ToLower() == "true" ? true : false;
            //methodAspirate.liquidSensorBlockDistance = Convert.ToDouble(xmlNode.SelectSingleNode("liquidSensorBlockDistance").InnerText);
            methodAspirate.aspirateBlockDisIdText = xmlNode.SelectSingleNode("aspirateBlockDisId/text").InnerText;
            methodAspirate.aspirateBlockDisIdValue = Convert.ToInt32(xmlNode.SelectSingleNode("aspirateBlockDisId/value").InnerText);
            methodAspirate.aspirateAirDisIdText = xmlNode.SelectSingleNode("aspirateAirDisId/text").InnerText;
            methodAspirate.aspirateAirDisIdValue = Convert.ToInt32(xmlNode.SelectSingleNode("aspirateAirDisId/value").InnerText);
            return methodAspirate;
        }

        

        #region 根据当前的设备型号获取设备台面数据信息
        /// <summary>
        /// 根据当前的设备型号获取设备台面数据信息
        /// </summary>
        /// <param name="deviceNumber">设备型号</param>
        /// <returns>某种设备型号下的台面数据信息列表</returns>
        public List<Lattice> ProviderLatticeList(string deviceNumber)
        {
            List<Lattice> lattices= new List<Lattice>();
            try
            {
                lattices = LatticeDB.GetLatticeDataFromdb(deviceNumber);
            }
            catch(Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return lattices;
        }
        #endregion

        #region 根据当前的设备型号获取设备台面数据信息
        /// <summary>
        /// 根据当前的设备型号获取设备台面数据信息
        /// </summary>
        /// <param name="deviceNumber">设备型号</param>
        /// <returns>某种设备型号下的台面数据信息列表</returns>
        public List<Lattice> ProviderLatticeList(string deviceNumber, int device_arm_id)
        {
            List<Lattice> lattices = new List<Lattice>();
            try
            {
                TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();  //增加台面模板判断
                if (tabletopTemplate == null)
                {
                    lattices = LatticeDB.GetLatticeDataFromdb(deviceNumber, device_arm_id);
                }
                else
                {
                    lattices = LatticeDB.GetLatticeDataByTabletopTemplateFromdb(tabletopTemplate.tabletopid);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return lattices;
        }
        #endregion

        #region 根据当前的设备型号获取设备臂数据信息
        /// <summary>
        /// 根据当前的设备型号获取设备臂数据信息
        /// </summary>
        public List<DeviceArm> ProviderDeviceArmList()
        {
            List<DeviceArm> deviceArms = new List<DeviceArm>();
            try
            {
                deviceArms = DeviceArmDB.GetDeviceArmFromdb(Shared.SoftwareInformation.software_information_id);
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return deviceArms;
        }
        #endregion

        #region 根据当前的设备型号获取设备臂数据信息--用于移液精度校准模块
        /// <summary>
        /// 根据当前的设备型号获取设备臂数据信息--用于移液精度校准模块
        /// </summary>
        public List<DeviceArm> ProviderDeviceArmListForLiquidAccuracy()
        {
            List<DeviceArm> deviceArms = new List<DeviceArm>();
            try
            {
                deviceArms = DeviceArmDB.GetDeviceArmFromdb(Shared.SoftwareInformation.software_information_id);
                deviceArms.RemoveAt(2);
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return deviceArms;
        }
        #endregion

        #region 获取当前耗材下的所有吸头盒数据信息
        /// <summary>
        /// 获取当前耗材下的所有吸头盒数据信息
        /// </summary>
        /// <returns>所有吸头盒数据信息列表</returns>
        public ObservableCollection<Labware> ProviderLabwareList()
        {
            ObservableCollection<Labware> labwares = new ObservableCollection<Labware>();
            try
            {
                labwares = LabwareDB.GetTipLabwareFromdb();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return labwares;
        }
        #endregion

        #region 检查所有属性设置是否满足要求
        /// <summary>
        /// 检查所有属性设置是否满足要求
        /// </summary>
        /// <param name="methodAspirate">吸液属性对象</param>
        /// <returns>检查所有属性设置是否满足要求</returns>
        public MethodPropertyInfo CheckProperty(MethodAspirate methodAspirate)
        {
            MethodPropertyInfo methodPropertyInfo = new MethodPropertyInfo();

            if (strCurrentCulture== "zh-CN")
            {
                methodPropertyInfo.property_tips_info = AspirateResourceCHS.tipsInfo.ToString();

                if (methodAspirate.labwareValue == null || methodAspirate.labwaretipValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceCHS.labwareText.ToString();
                }
                if (methodAspirate.positionValue == null || methodAspirate.positionValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceCHS.positionText.ToString();
                }
                if (methodAspirate.armValue == null || methodAspirate.armValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceCHS.armText.ToString();
                }
                else
                {
                    if (methodAspirate.armValue == "arm1")
                    {
                        if (AspirateResourceCHS.wellarray.Contains(","))
                        {
                            methodPropertyInfo.property_name_info = AspirateResourceCHS.armWithSingleChannel.ToString();
                            methodPropertyInfo.property_tips_info = AspirateResourceCHS.errorInfo.ToString();
                        }
                    }
                    else if (methodAspirate.armValue == "arm2")
                    {
                        if (!AspirateResourceCHS.wellarray.Contains(","))
                        {
                            methodPropertyInfo.property_name_info = AspirateResourceCHS.armWithSingleChannel.ToString();
                            methodPropertyInfo.property_tips_info = AspirateResourceCHS.errorInfo.ToString();
                        }
                    }
                }
                if (methodAspirate.wellarray == null || methodAspirate.wellarray == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceCHS.labwareText.ToString();
                }
                //if (methodAspirate.mixcount != null || methodAspirate.mixcount != )
                //{
                //    if (methodAspirate.mixvolume == null || methodAspirate.mixvolume == "")
                //    {
                //        methodPropertyInfo.property_name_info = AspirateResourceCHS.mixvolume.ToString();
                //    }
                //}
                //if (methodAspirate.wellvolume == null || methodAspirate.wellvolume == "")
                //{
                //    methodPropertyInfo.property_name_info = AspirateResourceCHS.wellvolume.ToString();
                //}
                if (methodAspirate.liquididValue == null || methodAspirate.liquididValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceCHS.liquididText.ToString();
                }
            }
            else if(strCurrentCulture == "en-US")
            {
                methodPropertyInfo.property_tips_info = AspirateResourceENU.tipsInfo.ToString();

                if (methodAspirate.labwareValue == null || methodAspirate.labwaretipValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceENU.labwareText.ToString();
                }
                if (methodAspirate.positionValue == null || methodAspirate.positionValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceENU.positionText.ToString();
                }
                if (methodAspirate.armValue == null || methodAspirate.armValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceENU.armText.ToString();
                }
                else
                {
                    if (methodAspirate.armValue == "arm1")
                    {
                        if (AspirateResourceENU.wellarray.Contains(","))
                        {
                            methodPropertyInfo.property_name_info = AspirateResourceENU.armWithSingleChannel.ToString();
                            methodPropertyInfo.property_tips_info = AspirateResourceENU.errorInfo.ToString();
                        }
                    }
                    else if (methodAspirate.armValue == "arm2")
                    {
                        if (!AspirateResourceENU.wellarray.Contains(","))
                        {
                            methodPropertyInfo.property_name_info = AspirateResourceENU.armWithSingleChannel.ToString();
                            methodPropertyInfo.property_tips_info = AspirateResourceENU.errorInfo.ToString();
                        }
                    }
                }
                if (methodAspirate.wellarray == null || methodAspirate.wellarray == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceENU.labwareText.ToString();
                }
                //if (methodAspirate.mixcount != null || methodAspirate.mixcount != "")
                //{
                //    if (methodAspirate.mixvolume == null || methodAspirate.mixvolume == "")
                //    {
                //        methodPropertyInfo.property_name_info = AspirateResourceENU.mixvolume.ToString();
                //    }
                //}
                //if (methodAspirate.wellvolume == null || methodAspirate.wellvolume == "")
                //{
                //    methodPropertyInfo.property_name_info = AspirateResourceENU.wellvolume.ToString();
                //}
                if (methodAspirate.liquididValue == null || methodAspirate.liquididValue == "")
                {
                    methodPropertyInfo.property_name_info = AspirateResourceENU.liquididText.ToString();
                }
            }
            return methodPropertyInfo;
        }
        #endregion

        #region 执行吸液，返回结果字符串
        /// <summary>
        /// 执行吸液，返回结果字符串
        /// </summary>
        /// <param name="labwareNode">吸液的参数对象</param>
        /// <param name="isSimulator"></param>
        /// <returns>结果实体对象</returns>
        public HxResult ExecuteAspirate(AspirateMParam aspirateMParam, bool isSimulator=false)
        {
            HxResult ret = new HxResult();
            if (!isSimulator)
            {
                ret = MethodAction.Instance.Aspirate(aspirateMParam);
            }
            else
            {
                CommonBll.DoSimulateDelay();
                ret.Result = ResultType.Success;
            }

            return ret;
        }

        public HxResult ExecuteAspirate(AspirateMParamSH aspirateMParam, bool isSimulator = false)
        {
            HxResult ret = new HxResult();
            if (!isSimulator)
            {
                ret = MethodAction.Instance.Aspirate(aspirateMParam);
            }
            else
            {
                CommonBll.DoSimulateDelay();
                ret.Result = ResultType.Success;
            }

            return ret;
        }
        #endregion

        #region 执行吸液，返回结果字符串
        /// <summary>
        /// 执行吸液，返回结果字符串
        /// </summary>
        /// <param name="labwareNode">吸液的参数对象</param>
        /// <param name="isSimulator"></param>
        /// <returns>结果实体对象</returns>
        public HxResult ExecuteAspirate(AspirateMParamWH aspirateMParam, bool isSimulator = false)
        {
            HxResult ret = new HxResult();
            if (!isSimulator)
            {
                ret = MethodAction.Instance.Aspirate(aspirateMParam);
            }
            else
            {
                ret.Result = ResultType.Success;
            }

            return ret;
        }
        #endregion
    }
}