using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using Mesnac.Action.Base;
using Mesnac.Action.Feeding.BasicInfo;
using Mesnac.Codd.Session;
using System.Data.Common;

namespace Mesnac.Action.Feeding.FinishBatch
{
    /// <summary>
    /// 存盘数据处理业务类
    /// </summary>
    public class SaveFinishBatch
    {
        #region 基本方法
        /// <summary>
        /// 获取本地连接
        /// </summary>
        /// <returns></returns>
        private DbHelper getLocalHelper()
        {
            return new DatabaseAction().NewDbHelper(Mesnac.Basic.DataSourceFactory.MCDbType.Local);
        }
        /// <summary>
        /// 获取网络连接
        /// </summary>
        /// <returns></returns>
        private DbHelper getServerHelper()
        {
            return new DatabaseAction().NewDbHelper(Mesnac.Basic.DataSourceFactory.MCDbType.Server);
        }
        /// <summary>
        /// 获取密炼曲线连接
        /// </summary>
        /// <returns></returns>
        private DbHelper getCurveHelper()
        {
            return new DatabaseAction().NewDbHelper(Mesnac.Basic.DataSourceFactory.MCDbType.Curve);
        }
        /// <summary>
        /// 获取网络密炼曲线连接
        /// </summary>
        /// <returns></returns>
        private DbHelper getCurveServerHelper()
        {
            return new DatabaseAction().NewDbHelper(Mesnac.Basic.DataSourceFactory.MCDbType.CurveServer);
        }
        /// <summary>
        /// 判断是否为网络版
        /// </summary>
        /// <returns>如果是网络版返回true，单机版返回false</returns>
        private bool IsNet()
        {
            bool Result = false;
            Result = new BaseAction().NetType == BaseAction.NetTypes.Net;
            return Result;
        }
        #endregion

        #region 数据信息

        private RecipeData.RecipeInfo recipeInfo = new RecipeData.RecipeInfo();     //配方信息
        private RecipeData.PptPlanInfo planInfo = new RecipeData.PptPlanInfo();     //计划信息
        private List<RecipeData.RecipeWeightInfo> allWeightInfo = new List<RecipeData.RecipeWeightInfo>();      //称量信息
        private List<RecipeData.RecipeMixingInfo> allMixingInfo = new List<RecipeData.RecipeMixingInfo>();      //密炼信息

        private LotWeight lotWeight;          //车称重数据
        private LotBarcode lotBarcode;                          //车报表数据
        private ShelfBarcode shelfBarcode;                      //架子数据
        private PlanExecuteData planExecuteData = new PlanExecuteData();

        /// <summary>
        /// 初始化配方数据，从缓存中获取
        /// </summary>
        private void IniRecipeData()
        {
            this.recipeInfo = RecipeCache.Instance.RecipeInfo;
            this.planInfo = RecipeCache.Instance.PlanInfo;
            this.allWeightInfo = RecipeCache.Instance.AllWeightInfo;
            this.allMixingInfo = RecipeCache.Instance.AllMixingInfo;
            //获取设定重量
            this.lotWeight = new LotWeight();
        }

        #endregion

        #region Plc信息
        /// <summary>
        /// 重置存盘信息
        /// </summary>
        public void FinishedOneReset()
        {
            //清空密炼曲线信号
            CurveInfo.Instance.MixingCurve = new StringBuilder();
            CurveInfo.Instance.MixTimeStr = new StringBuilder();
            CurveInfo.Instance.MixTempStr = new StringBuilder();
            CurveInfo.Instance.MixPowerStr = new StringBuilder();
            CurveInfo.Instance.MixEnerStr = new StringBuilder();
            CurveInfo.Instance.MixPressStr = new StringBuilder();
            CurveInfo.Instance.MixSpeedStr = new StringBuilder();
            //重置存盘信号
            ResetFinishedBatch.ExecReset();
        }
        
        /// <summary>
        /// 初始化计划执行数据
        /// </summary>
        private void IniPlanExecuteData()
        {
            planExecuteData.PlanID = planInfo.PlanID;
            // 计划完成数量
            planExecuteData.RecipeSetNumber = PlcData.Instance.RecipeSetNumber.LastValue.ToInt();
            // 计划完成数量
            planExecuteData.MixingFinishedCount = PlcData.Instance.MixingFinishedCount.LastValue.ToInt();
            // 密炼开始时间
            planExecuteData.MixingStartTime = PlcData.Instance.MixingStartTime.NowValue.ToDateTime();
        }

        #region 配方PLC数据读取

        /// <summary>
        /// 读取PLC和配方数据
        /// </summary>
        private void ReadPlcSaveData()
        {
            Equips.Factory.Instance.ReadAll();
            this.IniRecipeData();       //初始化配方数据
            IniPlanExecuteData();
        }
        #endregion
        #endregion

        #region 更新当前车架子条码信息

        /// <summary>
        /// 获取玲珑条码最大ID
        /// </summary>
        /// <param name="planDate">计划日期yyyyMMdd</param>
        /// <param name="equip_Code">机台号</param>
        /// <param name="shiftId">班次</param>
        /// <returns>返回玲珑条码最大ID</returns>
        private int GetMaxID(DbHelper serverHelper, string planDate, string equip_Code, string shiftId)
        {
            if (IsNet())
            {
                //string strSql = "GetMaxIncID";
                //serverHelper.CommandType = CommandType.StoredProcedure;
                //serverHelper.ClearParameter();
                //serverHelper.CommandText = strSql;
                //serverHelper.AddParameter("@Plan_Date", planDate);
                //serverHelper.AddParameter("@DJTYPE", equip_Code.Substring(3, 2) + shiftId);

                string strSql = "exec GetMaxIncID '{0}','{1}'";
                strSql = String.Format(strSql, planDate, equip_Code.Substring(3, 2) + shiftId);
                serverHelper.CommandType = CommandType.Text;
                serverHelper.ClearParameter();
                serverHelper.CommandText = strSql;
                object result = serverHelper.ToScalar();
                if (result == null || result == System.DBNull.Value)
                {
                    return 0;
                }
                int IntResult = 0;
                int.TryParse(result.ToString(), out IntResult);
                return IntResult;
            }
            return 0;
        }
        /// <summary>
        /// 获取玲珑车条码，网络版
        /// </summary>
        /// <param name="planDate">计划日期yyyyMMdd</param>
        /// <param name="equip_Code">机台号</param>
        /// <param name="mater_Code">配方物料代码</param>
        /// <param name="shiftId">班次</param>
        /// <returns>返回玲珑车条码</returns>
        private string GetLLBarCode(Mesnac.Basic.DataSourceFactory.MCDbType dbType, DbHelper serverHelper, string planDate, string equip_Code, string mater_Code, string shiftId)
        {
            if (IsNet() && dbType == Basic.DataSourceFactory.MCDbType.Server)
            {
                string strSql = "Select ErpCode From BasMaterial where MaterialCode = @MaterialCode";
                serverHelper.CommandType = CommandType.Text;
                serverHelper.ClearParameter();
                serverHelper.CommandText = strSql;
                serverHelper.AddParameter("@MaterialCode", mater_Code);
                object erpCode = serverHelper.ToScalar();
                if (erpCode == null || erpCode == System.DBNull.Value)
                {
                    return String.Empty;
                }
                string result = erpCode + planDate + shiftId + equip_Code + this.GetMaxID(serverHelper, planDate, equip_Code, shiftId).ToString("D3");
                return result;
            }
            return String.Empty;
        }
        /// <summary>
        /// 更新当前车架子条码信息
        /// </summary>
        /// <param name="dbHelper"></param>
        /// <returns></returns>
        private bool UpdateCurrentShelfBarcode(Mesnac.Basic.DataSourceFactory.MCDbType dbType, DbHelper dbHelper)
        {
            try
            {
                #region 更新架子信息表防误处理
                int barcodeStart = 0;
                string memNote = String.Empty;

                string sql1 = String.Empty;
                if (dbType == Basic.DataSourceFactory.MCDbType.Server)
                {
                    sql1 = "select Shelf_Num as ShelfNum,Barcode_Start as BarcodeStart,Barcode_End as BarcodeEnd,Mem_Note as MemNote from Ppt_ShiftConfig where Barcode=@Barcode";
                }
                else
                {
                    sql1 = "select ShelfNum,BarcodeStart,BarcodeEnd,MemNote from PptShiftConfig where Barcode=@Barcode";
                }
                dbHelper.CommandType = CommandType.Text;
                dbHelper.ClearParameter();
                dbHelper.CommandText = sql1;
                dbHelper.AddParameter("@Barcode", shelfBarcode.Barcode);
                DataTable table = dbHelper.ToDataTable();
                if (table != null && table.Rows.Count > 0)
                {
                    DataRow row = table.Rows[0];
                    int shelfNum = Mesnac.Basic.DataProcessor.RowValue(row, "ShelfNum", 0);
                    barcodeStart = Mesnac.Basic.DataProcessor.RowValue(row, "BarcodeStart", 0);
                    int barcodeEnd = Mesnac.Basic.DataProcessor.RowValue(row, "BarcodeEnd", 0);
                    memNote = Mesnac.Basic.DataProcessor.RowValue(row, "MemNote", String.Empty);

                    ICSharpCode.Core.LoggingService.Debug("ShelfNum=" + shelfNum);
                    ICSharpCode.Core.LoggingService.Debug("barcodeStart=" + barcodeStart);
                    ICSharpCode.Core.LoggingService.Debug("barcodeEnd=" + barcodeEnd);
                    ICSharpCode.Core.LoggingService.Debug("memNote=" + memNote);
                }

                #endregion

                string userId = String.Empty;
                string ZJSID = String.Empty;
                string LLBarCode = String.Empty;
                if (IsNet())
                {
                    FeedingAction action = new FeedingAction();
                    userId = action.GetConfigValue("LastUserID", String.Empty);
                    ZJSID = "test"; //action.GetMainHanderCodeByUserCode(userId);
                    //LLBarCode = this.GetLLBarCode(dbType, dbHelper, planInfo.PlanID.Trim().Substring(0, 6), action.CurrEquipCode, planInfo.RecipeMaterialCode.Trim(), planInfo.ShiftID);
                }
                string sqlstr = string.Empty;
                if (dbType == Basic.DataSourceFactory.MCDbType.Server)
                {
//                    sqlstr = @"
//                    UPDATE Ppt_ShiftConfig SET Shelf_Num=Shelf_Num+1,Barcode_End=@BarcodeEnd,Prod_Date=convert(varchar,getdate(),120),
//                    Real_Weight=Real_Weight+@RealWeight,Total_Weight=@TotalWeight,Mem_Note=case when len(Mem_Note) = 0 then @MemNote when Mem_Note is null then @MemNote else Mem_Note + ',' + @MemNote end,
//                    Plan_Date=@PlanDate,Equip_Code=@EquipCode,Shift_ID=@ShiftID,Shift_class=@ClassID,
//                    mater_code=@MaterialCode,mater_name=@MaterialName";
                    sqlstr = @"
                    UPDATE Ppt_ShiftConfig SET Shelf_Num=@ShelfNum,Barcode_End=@BarcodeEnd,Prod_Date=convert(varchar,getdate(),120),
                    Real_Weight=Real_Weight+@RealWeight,Total_Weight=@TotalWeight,Mem_Note=@MemNote,
                    Plan_Date=@PlanDate,Equip_Code=@EquipCode,Shift_ID=@ShiftID,Shift_class=@ClassID,
                    mater_code=@MaterialCode,mater_name=@MaterialName";
                }
                else
                {
//                    sqlstr = @"
//                    UPDATE PptShiftConfig SET ShelfNum=ShelfNum+1,BarcodeEnd=@BarcodeEnd,ProdDate=convert(varchar,getdate(),120),
//                    RealWeight=RealWeight+@RealWeight,TotalWeight=@TotalWeight,MemNote=case when len(MemNote) = 0 then @MemNote when MemNote is null then @MemNote else MemNote + ',' + @MemNote end,
//                    PlanDate=@PlanDate,EquipCode=@EquipCode,ShiftID=@ShiftID,ClassID=@ClassID,
//                    MaterialCode=@MaterialCode,MaterialName=@MaterialName";
                    sqlstr = @"
                    UPDATE PptShiftConfig SET ShelfNum=@ShelfNum,BarcodeEnd=@BarcodeEnd,ProdDate=convert(varchar,getdate(),120),
                    RealWeight=RealWeight+@RealWeight,TotalWeight=@TotalWeight,MemNote=@MemNote,
                    PlanDate=@PlanDate,EquipCode=@EquipCode,ShiftID=@ShiftID,ClassID=@ClassID,
                    MaterialCode=@MaterialCode,MaterialName=@MaterialName";
                    if (!IsNet())
                    {
                        sqlstr += ",IsUpFlag=0";
                    }
                }
                ///玲珑业务
                //if (IsNet())
                //{
                //    sqlstr += ",ZJSID=@ZJSID,UserID=@UserID,LLMemNote=case when len(LLMemNote) = 0 then @LLMemNote when LLMemNote is null then @LLMemNote else LLMemNote + ',' + @LLMemNote end,LLBarCode=@LLBarCode";
                //}
                sqlstr += "  WHERE Barcode=@Barcode";
                dbHelper.CommandType = CommandType.Text;
                dbHelper.ClearParameter();
                dbHelper.CommandText = sqlstr;
                dbHelper.AddParameter("@ShelfNum", lotBarcode.SerialBatchId - barcodeStart + 1);


                dbHelper.AddParameter("@BarcodeEnd", lotBarcode.SerialBatchId);
                dbHelper.AddParameter("@RealWeight", lotWeight.RealWeight);
                dbHelper.AddParameter("@TotalWeight", lotWeight.SetWeight);
                //dbHelper.AddParameter("@MemNote", lotBarcode.SerialBatchId.ToString());

                memNote = String.Empty;
                for (int i = barcodeStart; i <= lotBarcode.SerialBatchId; i++)
                {
                    if (String.IsNullOrEmpty(memNote))
                    {
                        memNote = i.ToString();
                    }
                    else
                    {
                        memNote += "," + i.ToString();
                    }
                }

                dbHelper.AddParameter("@MemNote", memNote);

                dbHelper.AddParameter("@PlanDate", Convert.ToDateTime(planInfo.PlanDate).ToString("yyyy-MM-dd"));
                dbHelper.AddParameter("@EquipCode", planInfo.RecipeEquipCode);
                dbHelper.AddParameter("@ShiftID", planInfo.ShiftID);
                dbHelper.AddParameter("@ClassID", planInfo.ClassID);
                dbHelper.AddParameter("@MaterialCode", planInfo.RecipeMaterialCode);
                dbHelper.AddParameter("@MaterialName", planInfo.RecipeMaterialName);
                //dbHelper.AddParameter("@PlanID", planInfo.PlanID.Trim());

                if (IsNet())
                {
                    //dbHelper.AddParameter("@ZJSID", ZJSID);
                    //dbHelper.AddParameter("@UserID", userId);
                    //dbHelper.AddParameter("@LLMemNote", this.lotBarcode.LLSerialId.ToString());
                    //dbHelper.AddParameter("@LLBarCode", LLBarCode);
                }

                dbHelper.AddParameter("@Barcode", shelfBarcode.Barcode);
                dbHelper.ExecuteNonQuery();
                ICSharpCode.Core.LoggingService.Info("完成更新架子条码,车次：" + lotBarcode.SerialBatchId.ToString());
                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService.Error("存盘业务-更新当前车架子条码信息失败:" + ex.Message);
                return false;
            }
        }
        #endregion

        #region 更新本地库计划完成数和计划状态
        /// <summary>
        /// 设定当前本地计划完成车数
        /// </summary>
        /// <param name="dbHelper">数据访问对象</param>
        /// <returns>成功返回true，失败返回false</returns>
        private bool SetLocalPlanFinishedLotCount(DbHelper dbHelper)
        {
            try
            {
                //完成当前计划车数
                int finishLotCount = planExecuteData.MixingFinishedCount;
                string sqlstr = string.Empty;
                sqlstr = "UPDATE PptGroupLot SET FinishNum=@FinishNum ,EndDatetime=convert(varchar,getdate(),120) WHERE FinishTag=0";
                dbHelper.CommandType = CommandType.Text;
                dbHelper.CommandText = sqlstr;
                dbHelper.ClearParameter();
                dbHelper.AddParameter("@FinishNum", finishLotCount);
                dbHelper.ExecuteNonQuery();
                //sqlstr = "UPDATE dbo.PptPlan SET RealNum=@RealNum,RealEndtime=GETDATE() WHERE PlanID=@PlanID";
                sqlstr = "UPDATE ppt_plan SET real_num=@RealNum,real_datetime=convert(varchar,getdate(),120) WHERE plan_id=@PlanID";
                dbHelper.CommandText = sqlstr;
                dbHelper.ClearParameter();
                dbHelper.AddParameter("@RealNum", PlcData.Instance.MixingFinishedCount.LastValue.ToInt());
                dbHelper.AddParameter("@PlanID", planExecuteData.PlanID);
                dbHelper.ExecuteNonQuery();

                //sqlstr = "UPDATE PptPlan set PlanState=5 where PlanNum=RealNum AND PlanID=@PlanID";
                if (IsNet())
                {
                    sqlstr = "UPDATE ppt_plan set plan_state=5 where plan_num=real_num AND plan_id=@PlanID";
                }
                else
                {
                    //如果是单机版，把计划上传标志modi_code设置为0
                    sqlstr = "UPDATE ppt_plan set plan_state=5,modi_code=0 where plan_num=real_num AND plan_id=@PlanID";
                }
                dbHelper.CommandText = sqlstr;
                dbHelper.ClearParameter();
                dbHelper.AddParameter("@PlanID", planExecuteData.PlanID);
                dbHelper.ExecuteNonQuery();
                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService.Error("存盘业务-更新本地库计划完成数和计划状态失败:" + ex.Message);
                return false;
            }
        }
        /// <summary>
        /// 更新网络计划完成车数
        /// </summary>
        /// <param name="serverHelper">数据访问对象</param>
        /// <returns>成功返回true，失败返回false</returns>
        private bool SetServerPlanFinishedLotCount(DbHelper serverHelper)
        {
            try
            {
                int finishLotCount = planExecuteData.MixingFinishedCount;
                string sqlstr = string.Empty;
                sqlstr = "UPDATE Ppt_Plan SET Real_Num=@realNum,Real_Endtime=convert(varchar(19),getdate(),120) WHERE Plan_ID=@PlanId";
                serverHelper.CommandType = CommandType.Text;
                serverHelper.CommandText = sqlstr;
                serverHelper.ClearParameter();
                serverHelper.AddParameter("@realNum", finishLotCount);
                serverHelper.AddParameter("@PlanId", planExecuteData.PlanID);
                serverHelper.ExecuteNonQuery();

                PlanStates planState = PlanCommon.GetPlanState(planExecuteData.PlanID);    //获取本地计划状态

                //如果本地计划位完成状态，则把网络计划状态也改为完成。
                if (planState == PlanStates.Completed)
                {
                    sqlstr = "UPDATE Ppt_Plan set Plan_State=5 where Plan_ID=@PlanID";
                    serverHelper.CommandText = sqlstr;
                    serverHelper.ClearParameter();
                    serverHelper.AddParameter("@PlanID", planExecuteData.PlanID);
                    serverHelper.ExecuteNonQuery();
                }
                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService.Error("存盘业务-更新网络计划完成车数失败:" + ex.Message);
                return false;
            }
        }
        #endregion

        #region 追溯方法

        /// <summary>
        /// 建立追溯关系，只对应网络库
        /// </summary>
        /// <param name="dbHelper">数据访问对象</param>
        /// <param name="barcode">车条码</param>
        /// <param name="planId">计划号</param>
        /// <param name="serialId">当前车次</param>
        private bool ConstructBarTrace(DbHelper dbHelper, string barcode, string planId, int serialId)
        {
            try
            {
                if (dbHelper == null)
                {
                    ICSharpCode.Core.LoggingService.Warn("建立追溯失败：获取数据连接失败...");
                    return false;
                }
                string strSql = "Proc_MainBarTraceNew";
                dbHelper.CommandType = CommandType.StoredProcedure;
                dbHelper.ClearParameter();
                dbHelper.CommandText = strSql;
                dbHelper.AddParameter("@tBarcode", barcode);      //车条码
                dbHelper.AddParameter("@Serial_id", serialId);      //车次
                dbHelper.AddParameter("@Plan_id", planId);           //计划号
                DbParameter para = dbHelper.CreateParameter("@OutBarCode");
                para.Direction = ParameterDirection.Output;
                para.DbType = DbType.String;
                para.Size = 6030;
                dbHelper.AddParameter(para);
                dbHelper.ExecuteNonQuery();

                object result = para.Value;

                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService.Error("建立追溯失败：" + ex.Message);
                ICSharpCode.Core.LoggingService.Error(ex.StackTrace);
                return false;
            }

        }

        #endregion

        #region 向网络中发送密炼曲线数据
        /// <summary>
        /// 向网络中发送密炼曲线数据
        /// </summary>
        /// <param name="recipeData">配方数据对象</param>
        public void SendMixingCurveData(RecipeData recipeData)
        {
            #region 密炼曲线字符串
            double mixingTime = PlcData.Instance.CurrentMixingTime.LastValue.ToDouble();
            double mixingTemp = PlcData.Instance.CurrentMixingTemp.LastValue.ToDouble();
            double mixingPower = PlcData.Instance.CurrentMixingPower.LastValue.ToDouble();
            double mixingEnergy = PlcData.Instance.CurrentMixingEnergy.LastValue.ToDouble();
            double mixingPressureRam = PlcData.Instance.CurrentMixingPressureRam.LastValue.ToDouble();
            double mixingSpeedRotor = PlcData.Instance.CurrentMixingSpeedRotor.LastValue.ToDouble();
            double mixingHoopPerstion = PlcData.Instance.CurrentMixingHoopPerstion.LastValue.ToDouble();
            StringBuilder sb = new StringBuilder();
            if (mixingTime > 0)
            {
                //密炼时间>0时记录曲线
                sb.Append(String.Format("{0:N2}", mixingTime)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingTemp)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingPower)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingEnergy)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingPressureRam)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingSpeedRotor)).Append(":");
                sb.Append(String.Format("{0:N2}", mixingHoopPerstion)).Append("/");
                CurveInfo.Instance.MixingCurve.Append(sb);
                CurveInfo.Instance.MixTimeStr.Append(String.Format("{0:N2}", mixingTime)).Append(":");
                CurveInfo.Instance.MixTempStr.Append(String.Format("{0:N2}", mixingTemp)).Append(":");
                CurveInfo.Instance.MixPowerStr.Append(String.Format("{0:N2}", mixingPower)).Append(":");
                CurveInfo.Instance.MixEnerStr.Append(String.Format("{0:N2}", mixingEnergy)).Append(":");
                CurveInfo.Instance.MixPressStr.Append(String.Format("{0:N2}", mixingPressureRam)).Append(":");
                CurveInfo.Instance.MixSpeedStr.Append(String.Format("{0:N2}", mixingSpeedRotor)).Append(":");
                if (mixingTime >= 1 && mixingTime <= 3 && CurveInfo.Instance.MixingCurve.Length > 1000)
                {
                    CurveInfo.Instance.MixingCurve = new StringBuilder();

                    CurveInfo.Instance.MixTimeStr = new StringBuilder();
                    CurveInfo.Instance.MixTempStr = new StringBuilder();
                    CurveInfo.Instance.MixPowerStr = new StringBuilder();
                    CurveInfo.Instance.MixEnerStr = new StringBuilder();
                    CurveInfo.Instance.MixPressStr = new StringBuilder();
                    CurveInfo.Instance.MixSpeedStr = new StringBuilder();
                    //ICSharpCode.Core.LoggingService.Debug("=============密炼时间<2，并且密炼曲线长度>1000时，密炼曲线数据被清除======================");
                    //ICSharpCode.Core.LoggingService.Debug("密炼时间:" + mixingTime);
                    //ICSharpCode.Core.LoggingService.Debug("曲线字符串长度:" + CurveInfo.Instance.MixingCurve.Length);
                    //ICSharpCode.Core.LoggingService.Debug("===================================");
                }
            }
            #endregion

            #region 网络数据发送

            DbHelper dbHelper = getLocalHelper();
            string planID = recipeData.GetCurrentPlanID();
            string socketSendstr = sb.ToString() + Global.ProtocalHeader.ReceivePlanIdIpNumber + ":" + planID + "/";
            socketSendstr = String.Format("{0}:{1}", Global.ProtocalHeader.ReceiveCurveData, socketSendstr);
            //Mesnac.Communication.TcpService.Instance.NetSendMsg(GetAllRecipeData23() + GetAllRecipeData24());
            //Mesnac.Communication.TcpService.Instance.NetSendMsg();
            Mesnac.Communication.TcpService.Instance.NetSendMsg(socketSendstr);

            #endregion
        }

        #endregion

        #region 存盘主业务方法
        /// <summary>
        /// 存盘主业务方法
        /// </summary>
        /// <returns>存盘成功返回true，失败返回false</returns>
        private bool SaveInfo()
        {
            bool save = false;
            DbHelper localHelper = getLocalHelper();
            DbHelper serverHelper = null;
            DbHelper curveHelper = getCurveHelper();
            DbHelper curveServerHelper = null;

            FeedingAction action = new FeedingAction();
            
            if (IsNet()) { serverHelper = getServerHelper(); curveServerHelper = getCurveServerHelper(); }
            if (localHelper == null)
            {
                ICSharpCode.Core.LoggingService.Error("保存存盘信息失败：获取本地数据连接失败！");
                return false;
            }
            try
            {
                this.lotWeight = new LotWeight();

                SaveDataPerLotHandler saveDataPerLotHandler = new SaveDataPerLotHandler();  //获取PLC每车报表存盘数据区数据

                bool result = true;
                //1、更新完成数
                try
                {
                    if (result) { result = SetLocalPlanFinishedLotCount(localHelper); }
                    if (result && IsNet()) { result = SetServerPlanFinishedLotCount(serverHelper); }
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("更新计划完成数失败：" + ex.Message);
                }

                //2、架子信息存盘
                try
                {
                    ICSharpCode.Core.LoggingService.Info("架子信息存盘...");
                    lotBarcode.IniLotBarcode(localHelper, this.planInfo);
                    if (result) { shelfBarcode = new ShelfBarcode(localHelper, serverHelper, IsNet(), lotBarcode, this.planInfo, this.planExecuteData); }
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("架子信息存盘失败：" + ex.Message);
                }

                //3、保存车报表
                ICSharpCode.Core.LoggingService.Info("保存车报表...");
                PptLotSaveHelper pptLotSaveHelper = new PptLotSaveHelper(saveDataPerLotHandler, this.lotBarcode, this.shelfBarcode, this.lotWeight, this.recipeInfo, this.planInfo, this.planExecuteData);
                try
                {
                    if (result) { result = pptLotSaveHelper.SavePptLotData(Mesnac.Basic.DataSourceFactory.MCDbType.Local, localHelper, IsNet()); }       //本地车报表存盘
                    if (result && IsNet()) { result = pptLotSaveHelper.SavePptLotData(Mesnac.Basic.DataSourceFactory.MCDbType.Server, serverHelper, IsNet()); }      //网络车报表存盘
                    if (result && IsNet()) { pptLotSaveHelper.UpdateIsUpFlag(localHelper); }    //更新本地库车报表上传标志
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("车报表存盘失败：" + ex.Message);
                }

                //4、更新当前车架子条码
                try
                {
                    ICSharpCode.Core.LoggingService.Info("更新当前车架子条码...");
                    if (result) { result = UpdateCurrentShelfBarcode(Basic.DataSourceFactory.MCDbType.Local, localHelper); }
                    if (result && IsNet()) { result = UpdateCurrentShelfBarcode(Basic.DataSourceFactory.MCDbType.Server, serverHelper); };
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("更新当前车架子条码存盘失败：" + ex.Message);
                }

                //5、保存密炼数据
                try
                {
                    ICSharpCode.Core.LoggingService.Info("保存密炼数据...");
                    PptMixingDataHelper pptMixingDataHelper = new PptMixingDataHelper(this.lotBarcode, this.allMixingInfo);
                    if (result) { result = pptMixingDataHelper.SavePptMixingData(Mesnac.Basic.DataSourceFactory.MCDbType.Local, localHelper); }     //本地密炼数据存盘
                    if (result && IsNet()) { result = pptMixingDataHelper.SavePptMixingData(Mesnac.Basic.DataSourceFactory.MCDbType.Server, serverHelper); }        //网络密炼数据存盘
                    if (result && IsNet()) { pptMixingDataHelper.UpdateIsUpFlag(localHelper); }     //更新本地库密炼数据上传标志
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("密炼数据存盘失败：" + ex.Message);
                }
                //6、保存称量数据
                try
                {
                    ICSharpCode.Core.LoggingService.Info("保存称量数据...");
                    PptWeighDataHelper pptWeighDataSaveHelper = new PptWeighDataHelper(saveDataPerLotHandler, this.lotBarcode, this.lotWeight, this.planInfo, this.allWeightInfo);
                    if (result) { result = pptWeighDataSaveHelper.SavePptWeighData(Mesnac.Basic.DataSourceFactory.MCDbType.Local, localHelper); }                //本地称量数据存盘
                    if (result && IsNet()) { result = pptWeighDataSaveHelper.SavePptWeighData(Mesnac.Basic.DataSourceFactory.MCDbType.Server, serverHelper); }   //网络称量数据存盘
                    if (result && IsNet()) { pptWeighDataSaveHelper.UpdateIsUpFlag(localHelper); }  //更新本地库称量数据上传标志
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("称量数据存盘失败：" + ex.Message);
                }

                //7、更新车报表的超差标志
                try
                {
                    ICSharpCode.Core.LoggingService.Info("更新车报表的超差标志、设定重量和实际重量...");
                    if (result) { result = pptLotSaveHelper.UpdateErrorSgnAndWeight(Basic.DataSourceFactory.MCDbType.Local, localHelper); }
                    if (result && IsNet()) { result = pptLotSaveHelper.UpdateErrorSgnAndWeight(Basic.DataSourceFactory.MCDbType.Server, serverHelper); }
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("更新车报表的超差标志存盘失败：" + ex.Message);
                }

                //8、保存密炼曲线
                try
                {
                    ICSharpCode.Core.LoggingService.Info("保存密炼曲线...");
                    ICSharpCode.Core.LoggingService.Debug("MixTime:" + CurveInfo.Instance.MixTimeStr);
                    MixingCurveSaveHelper mixingCurveSaveHelper = new MixingCurveSaveHelper(this.lotBarcode, this.planInfo);
                    if (result) { result = mixingCurveSaveHelper.SaveMixingCurve(localHelper, curveHelper); }
                    if (result && IsNet()) { result = mixingCurveSaveHelper.SaveMixingCurve(localHelper, curveServerHelper); }
                    if (result && IsNet()) { mixingCurveSaveHelper.UpdateIsUpFlag(curveHelper); }
                }
                catch (Exception ex)
                {
                    save = false;
                    ICSharpCode.Core.LoggingService.Error("密炼曲线存盘失败：" + ex.Message);
                }

                //9、网络版，则建立追溯
                if (IsNet())
                {
                    ICSharpCode.Core.LoggingService.Info("建立追溯...");
                    result = this.ConstructBarTrace(serverHelper, lotBarcode.Barcode, lotBarcode.PlanID.Trim(), lotBarcode.SerialId);
                }
                //10、停止掺用
                if (lotBarcode.SerialId == planInfo.PlanNum)
                {
                    result = PlanCommon.StopChanYongPlan(localHelper);
                }
                save = true;
            }
            catch (Exception ex)
            {
                save = false;
                ICSharpCode.Core.LoggingService.Error("数据存盘失败：" + ex.Message);
            }
            finally
            {
                //保存上次存盘的计划号
                LastSavePlanID = planInfo.PlanID.Trim();
                //保存上次存盘车次
                LastSaveRealNum = planExecuteData.MixingFinishedCount;
                SaveDataPerLotHandler.RecipeTime = 0;                   //存盘完成后清空密炼时间
                //存盘复位，防止重复执行
                this.FinishedOneReset();
                //触发存盘完成事件
                if (OnFinishBatchSave != null)
                {
                    OnFinishBatchSave(null, EventArgs.Empty);
                }
            }
            return save;
        }
        #endregion

        #region 存盘 验证业务
        /// <summary>
        /// 存盘完成事件
        /// </summary>
        public static event EventHandler OnFinishBatchSave;
        /// <summary>
        /// 上次存盘的计划号
        /// </summary>
        public static string LastSavePlanID = String.Empty;
        /// <summary>
        /// 上次存盘的完成数
        /// </summary>
        public static int LastSaveRealNum = 0;
        /// <summary>
        /// 保存存盘数据 业务入口
        /// </summary>
        private void SaveFinishBatchData()
        {
            this.ReadPlcSaveData();

            if (String.IsNullOrEmpty(planInfo.PlanID))
            {
                ICSharpCode.Core.LoggingService.Warn("存盘失败：没有缓存配方计划！");
                FinishedOneReset(); //重置存盘信号
                return;
            }
            BaseAction action = new BaseAction();
            DbHelper dbHelper = getLocalHelper();

            //当前计划设定车数
            int planLotCount = planExecuteData.RecipeSetNumber;
            //当前计划完成车数
            int finishLotCount = planExecuteData.MixingFinishedCount;
            if (new FinishBatchFlag().Run())
            {
                //action.LogDebug("开始存盘要生成车条码..." + planInfo.PlanID + "," + planExecuteData.PlanID);
                lotBarcode = new LotBarcode(getLocalHelper(), getServerHelper(), planInfo.PlanID, finishLotCount);
                //action.LogDebug("成车条码..." + lotBarcode);
                if (string.IsNullOrWhiteSpace(lotBarcode.Barcode))
                {
                    action.LogDebug("条码存在:" + lotBarcode.Barcode);
                    FinishedOneReset();
                    return;
                }
                action.LogDebug("开始存盘:" + lotBarcode.Barcode);
                //调用存盘主业务方法
                if (SaveInfo())
                {
                    //刷新胶料称量画面的物料列表
                    PlanCommon.GetScanBarcode();

                    if (Mesnac.Basic.RunSchema.Instance.GetConfigValue("PlanExecuteType", "0").Trim() == "1")       //判断计划是否连续执行
                    {
                        if (finishLotCount == planLotCount)
                        {
                            new ProducingPlan.ExecutePlan().ExecuteNext();      //执行下一个计划
                        }
                    }
                    //new SaveMixingData().FinishedOneReset();
                }
            }
        }
        #endregion

        #region 存盘业务入口
        /// <summary>
        /// 存盘业务入口，保存胶料生成数据   执行下一个计划
        /// </summary>
        public void Run()
        {
            PlanLog currentPlan = PlanCommon.PlanLog;
            if (currentPlan == null)
            {
                ICSharpCode.Core.LoggingService.Warn("存盘业务入口：计划日志为NULL....，不会存盘...");
                return;
            }

            RecipeData recipeData = new RecipeData();

            this.SendMixingCurveData(recipeData);

            if (PlcData.Instance.FinishedBatch.LastValue.ToInt() == 1)
            {
                SaveFinishBatchData();      //调用存盘 验证业务
            }
        }
        #endregion

        #region 广播循环数据
        public string GetAllRecipeData23()
        {
            object AllRecipeData23 = PlcData.Instance.AllRecipeData23.LastValue.ToObject();
            if (AllRecipeData23 == null)
            {
                ICSharpCode.Core.LoggingService.Warn("从PLC中获取配方（N23）数据失败_NULL！");
                return string.Empty;
            }
            if (!(AllRecipeData23 is object[]))
            {
                ICSharpCode.Core.LoggingService.Warn("从PLC中获取配方（N23）数据失败_Not Array！");
                return string.Empty;
            }
            object[] values = AllRecipeData23 as object[];
            StringBuilder sbMsg = new StringBuilder();
            sbMsg.AppendFormat("{0}:", Global.ProtocalHeader.ReceiveFirstPlcIpNumber);
            for (int i = 0; i < values.Length; i++)
            {
                if (i == values.Length - 1)
                    sbMsg.AppendFormat("{0}/", values[i].ToString());
                else
                    sbMsg.AppendFormat("{0}:", values[i].ToString());
            }
            return sbMsg.ToString();
            
        }

        public string GetAllRecipeData24()
        {
            object AllRecipeData24 = PlcData.Instance.AllRecipeData24.LastValue.ToObject();
            if (AllRecipeData24 == null)
            {
                ICSharpCode.Core.LoggingService.Warn("从PLC中获取配方（N24）数据失败_NULL！");
                return string.Empty;
            }
            if (!(AllRecipeData24 is object[]))
            {
                ICSharpCode.Core.LoggingService.Warn("从PLC中获取配方（N24）数据失败_Not Array！");
                return string.Empty;
            }
            object[] values = AllRecipeData24 as object[];
            StringBuilder sbMsg = new StringBuilder();
            sbMsg.AppendFormat("{0}:", Global.ProtocalHeader.ReceiveSecondPlcIpNumber);
            for (int i = 0; i < values.Length; i++)
            {
                if (i == values.Length - 1)
                    sbMsg.AppendFormat("{0}/", values[i].ToString());
                else
                    sbMsg.AppendFormat("{0}:", values[i].ToString());
            }
            return sbMsg.ToString();

        }
        #endregion

    }
}