using CentralControl.BaseData;
using CommonFunc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using XGL.Thrift;

namespace CentralControl.App_Code
{
    public class LogicLineSiteUp
    {

        // Thread UpMaterialThread;
        PlcHelper plcHelper;
        string LineNo { get; set; }
        NodeSetting ScanPoint { get; set; }
        /// <summary>
        /// 是否运行发车中
        /// </summary>
        bool IsRuning { get; set; }

        public LogicLineSiteUp(PlcHelper plc, string LineNo)
        {
            NodeSetting linenode1 = StaticData.NodeSettingList.FirstOrDefault(t => t.LineCatchArea != null && t.LineCatchArea.LineNo == LineNo && t.LineCatchArea.AreaType == 1);
            if (linenode1 != null)
            {
                this.ScanPoint = linenode1;
            }
            else
            {
                Logger logger = new Logger();
                logger.Log("创建线体,未找到扫描点位");
            }
            plcHelper = plc;
        }

        ///// <summary>
        ///// 启动上件扫描监听
        ///// </summary>
        //public void StartUpMateril(string lineNo)
        //{
        //    StaticData.OffLineLockObjDic.Add(lineNo,new object());
        //    List<UpLineMaterialList> uplinemateriallist = StaticData.UpMaterialAreaList.Where(t => t.LineNo == lineNo).ToList();
        //    StaticData.InLineMaterialsDic.Add(lineNo, uplinemateriallist);
        //    UpMaterialThread = new Thread(new ParameterizedThreadStart(StaticData.UpmaterialMethod));
        //    UpMaterialThread.Start(lineNo);
        //}


        /// <summary>
        /// 启动小车扫描监听队列
        /// </summary>
        public void StartScanThriftLogic(int point)
        {
            this.LineNo = this.LineNo;
            XGL.Thrift.ThriftServiceImp business = new XGL.Thrift.ThriftServiceImp();
            business.DischargeCarEvent += SendCar;
            XGL.Thrift.ThriftCommon thriftCommon = new XGL.Thrift.ThriftCommon();
            thriftCommon.Start(business, point);

        }

        /// <summary>
        /// 下位机点击发车
        /// </summary>
        /// <param name="carlist"></param>
        /// <returns></returns>
        private string SendCar(List<string> carlist)
        {
            if (!IsRuning)
            {
                IsRuning = true;
                Logger logger = new Logger();
                try
                {
                    List<UpLineScanCarList> mlist = StaticData.InLineScanCarDic[this.LineNo];

                    foreach (string carno in carlist)
                    {
                        logger.Log("挂件信息 [" + LineNo + "]:" + carno);
                        string[] carinfo = carno.Split('*');
                        UpLineScanCarList uplinmater = new UpLineScanCarList();
                        uplinmater.CarNo = carinfo[0];
                        uplinmater.MaterialNo = carinfo[1];
                        uplinmater.Number = Convert.ToInt32(carinfo[2]);
                        uplinmater.LineNo = this.LineNo;
                        mlist.Add(uplinmater);
                        DBService.AddUpLineScancar(uplinmater);
                    }



                    while (true)
                    {
                        UpLineScanCarList carInfo = mlist[0];


                        if (!string.IsNullOrEmpty(carInfo.MaterialNo) && carInfo.MaterialInfo != null)
                        {
                            //小车是否到位
                            object carstate = plcHelper.Read(ScanPoint.PlcSetting1);
                            //小车是否离开
                            object carrun = plcHelper.Read(ScanPoint.PlcSetting2);
                            ///读取小车号
                            object carno = plcHelper.Read(ScanPoint.PlcSetting3);
                            ///上位机写入岔道信息
                            object wcsstate = plcHelper.Read(ScanPoint.PlcSetting4);
                            ///回写plc状态处理完成,plc会清理数据
                            object wcsend = plcHelper.Read(ScanPoint.PlcSetting5);


                            if (Convert.ToInt32(carno) > 0 && Convert.ToInt32(wcsend) == 0 && Convert.ToInt32(wcsstate) == 0 && Convert.ToInt32(carstate) == 1)
                            {
                                logger.Log("[" + carno + "]小车到了 [" + this.LineNo + "]号上件点");

                                //中一系统 在点位配置维护的时候, 一个节点的子级 不需要维护多个,只需要把特定线路的点维护,然后根据线体去找到库位口位置 
                                ScanPoint.CarNo = carno.ToString();

                                int locatorid = 0;
                                ///获取预设 物料分配的库位
                                LineCatchArea area = StaticData.LineCatchAreaList.Where(t => t.MaterialNo == carInfo.MaterialNo).FirstOrDefault();
                                //当前物料之后已经存在库内,如果存在,返回位置
                                if (area != null)
                                {
                                    //增加判断  满减存储区是否有位置, 没有的话,就暂时不发车
                                    //判断库区内小车数量
                                    var locatorNum = StaticData.CarRealList.Where(t => t.LocatorNodeId == area.Id).Count();
                                    if (locatorNum < area.MaxNumber)
                                    {
                                        //未满
                                        locatorid = area.Id;
                                    }
                                    else
                                    {
                                        //满了 
                                    }
                                }

                                //如果单个的库位满了, 或者没有设定单库,进入混合库区
                                if (locatorid == 0)
                                {
                                    //增加判断  满减存储区是否有位置, 没有的话,就暂时不发车
                                    var mixtureArea = StaticData.LineCatchAreaList.Where(t => t.AreaStorageType == 0 && t.AreaType == 4);
                                    foreach (var locator in mixtureArea)
                                    {
                                        //判断库区内小车数量
                                        var locatorNum = StaticData.CarRealList.Where(t => t.LocatorNodeId == area.Id).Count();
                                        if (locatorNum < locator.MaxNumber)
                                        {
                                            area = locator;
                                            //未满
                                            locatorid = Convert.ToInt32(locator.AreaNo);
                                            break;
                                        }

                                    }

                                }

                                if (locatorid > 0)
                                {
                                    //判断小车号是否存在 ,使用内存记录
                                    // CarRealInfo car = DBService.GetCarModel(carno.ToString());
                                    CarRealInfo car = StaticData.CarRealList.Where(t => t.CarNo == carno.ToString()).FirstOrDefault();
                                    if (car == null)
                                    {
                                        //小车不存在了, 就插入初始化数据
                                        car.CarNo = carno.ToString();
                                        car.CurrNodeId = this.ScanPoint.Id;
                                        car.CurrNodeSetting = this.ScanPoint;
                                        NodeSetting nextnode = null;
                                        if (area.LineNo == "1")
                                        {
                                            nextnode = StaticData.NodeSettingList.FirstOrDefault(t => t.NodeNo == "1002");
                                        }
                                        else if (area.LineNo == "2")
                                        {
                                            nextnode = StaticData.NodeSettingList.FirstOrDefault(t => t.NodeNo == "1003");
                                        }
                                        car.LocatorNodeId = nextnode.Id;
                                        car.LocatorNodeSetting = nextnode;
                                        car.LocatorId = locatorid;
                                        car.MaterialNo = carInfo.MaterialNo;
                                        car.LocatorArea = area;
                                        car.OptDt = DateTime.Now;
                                        car.IsOver = 0;
                                        DBService.AddCarRealRecord(car);

                                    }
                                    else
                                    {
                                        //小车存在了, 就修改初始化数据 
                                        car.CarNo = carno.ToString();
                                        car.CurrNodeId = this.ScanPoint.Id;
                                        car.CurrNodeSetting = this.ScanPoint;
                                        NodeSetting nextnode = StaticData.NodeSettingList.FirstOrDefault(t => t.NodeNo == "1002");
                                        if (area.LineNo == "2")
                                        {
                                            nextnode = StaticData.NodeSettingList.FirstOrDefault(t => t.NodeNo == "1004");
                                        }
                                        car.LocatorNodeId = nextnode.Id;
                                        car.LocatorNodeSetting = nextnode;
                                        car.LocatorId = locatorid;
                                        car.LocatorArea = area;
                                        car.MaterialNo = carInfo.MaterialNo;
                                        car.OptDt = DateTime.Now;
                                        car.IsOver = 0;
                                        DBService.ModifyRealCarinfoRecord(car);

                                    }

                                    Productinfo producthistory = new Productinfo();
                                    producthistory.CreateTime = DateTime.Now;
                                    producthistory.IsDeleted = 0;
                                    producthistory.MaterialNo = carInfo.MaterialNo;
                                    // producthistory.ProductBarno = Product.ProductBarNo;
                                    ///记录产品信息
                                    DBService.AddProductInfo(producthistory);
                                    //删除上件工件队列
                                    DBService.DeleteUpLineMaterial(carInfo.Id);

                                    //添加小车记录表
                                    DBService.AddCarHistoryRecord(car);
                                    //记录小车已经离开.
                                    // DBService.UpdateCarOverState(car.Id, 1);

                                    //同步内存表小车数据
                                    StaticData.CarRealList.Add(car);

                                    //点位记录小车编号
                                    ScanPoint.CarNo = car.CarNo;
                                    ///回写plc状态,起点的分支线路为1
                                    plcHelper.Write(ScanPoint.PlcSetting4, car.LocatorNodeSetting.NodeNo);
                                    ///回写plc状态处理完成,plc会清理数据
                                    plcHelper.Write(ScanPoint.PlcSetting5, 1);
                                }

                            }//小车移动中指定点位后,并且到位了
                            else if (Convert.ToInt32(carno) == 0 && Convert.ToInt32(carstate) == 0 && Convert.ToInt32(carrun) == 1)
                            {

                                string ocarno = ScanPoint.CarNo;
                                CarRealInfo car = StaticData.CarRealList.Where(t => t.CarNo == ocarno).FirstOrDefault();
                                if (car != null)
                                {

                                    car.CurrNodeId = null;
                                    car.CurrNodeSetting = null;
                                    DBService.ModifyRealCarinfoRecord(car);
                                    ///回写plc状态,,plc会清理数据
                                    plcHelper.Write(ScanPoint.PlcSetting4, 0);
                                    ///回写plc状态处理完成,plc会清理数据
                                    plcHelper.Write(ScanPoint.PlcSetting5, 0);
                                }
                                else
                                {
                                    logger.Log("[" + this.LineNo + "] 小车已离开,反馈未找到小车");
                                }

                            }

                        }
                        else
                        {
                            logger.Log("[" + this.LineNo + "] 带上件门体,上件完毕");
                            return "小车已离开";
                        }

                        Thread.Sleep(1000);
                    }


                    IsRuning = false;

                }
                catch (Exception ex)
                {
                    logger.Error("发车操作异常:" + ex.Message + ex.StackTrace);
                    IsRuning = false;
                    return "系统异常";
                }

            }
            else
            {
                Console.WriteLine("正在发车中,等待plc反馈中");
                return "正在发车中,等待plc反馈中";
            }

        }



        /// <summary>
        /// 前端点击放行,放行小车队列
        /// </summary>
        /// <param name="lineNo"></param>
        /// <param name="materials"></param>
        public void StartCarCanR(string lineNo, int carnumber)
        {

            Logger logger = new Logger();
            while (carnumber <= 0)
            {
                try
                {
                    List<UpLineScanCarList> mlist = StaticData.InLineScanCarDic[lineNo];
                    if (mlist.Count > 0)
                    {

                        UpLineScanCarList carInfo = mlist[0];


                        if (!string.IsNullOrEmpty(carInfo.MaterialNo) && carInfo.MaterialInfo != null)
                        {
                            //小车是否到位
                            object carstate = plcHelper.Read(StaticData.getPlcInfoByCode("incarstate_p" + lineNo));
                            //小车是否离开
                            object carrun = plcHelper.Read(StaticData.getPlcInfoByCode("incarover_p" + lineNo));
                            ///读取小车号
                            object carno = plcHelper.Read(StaticData.getPlcInfoByCode("incarno_p" + lineNo));
                            ///上位机写入岔道信息
                            object wcsstate = plcHelper.Read(StaticData.getPlcInfoByCode("incaradapter_w" + lineNo));
                            ///回写plc状态处理完成,plc会清理数据
                            object wcsend = plcHelper.Read(StaticData.getPlcInfoByCode("incarclear_w" + lineNo));


                            if (Convert.ToInt32(carno) > 0 && Convert.ToInt32(wcsend) == 0 && Convert.ToInt32(wcsstate) == 0 && Convert.ToInt32(carstate) == 1)
                            {
                                logger.Log("[" + carno + "]小车到了 [" + lineNo + "]号上件点");

                                //中一系统 在点位配置维护的时候, 一个节点的子级 不需要维护多个,只需要把特定线路的点维护,然后根据线体去找到库位口位置 

                                //获取当前上件区线的第一个点信息,前置点位信息
                                NodeSetting nodeFirst = StaticData.NodeSettingList.Where(t => t.NodeType == 1 && t.LineCatchArea.LineNo == lineNo).FirstOrDefault();

                                int locatorid = 0;
                                //增加判断  满减存储区是否有位置, 没有的话,就暂时不发车
                                LineCatchArea area = StaticData.LineCatchAreaList.Where(t => t.MaterialNo == carInfo.MaterialNo).FirstOrDefault();
                                if (area != null)
                                {
                                    //判断库区内小车数量
                                    var locatorNum = StaticData.CarRealList.Where(t => t.LocatorNodeId == area.Id).Count();
                                    if (locatorNum < area.MaxNumber)
                                    {
                                        //未满
                                        locatorid = area.Id;
                                    }
                                    else
                                    {
                                        //满了 
                                    }
                                }

                                //如果单个的库位满了, 或者没有设定单库,进入混合库区
                                if (locatorid == 0)
                                {
                                    //增加判断  满减存储区是否有位置, 没有的话,就暂时不发车
                                    var mixtureArea = StaticData.LineCatchAreaList.Where(t => t.AreaStorageType == 0);
                                    foreach (var locator in mixtureArea)
                                    {
                                        //判断库区内小车数量
                                        var locatorNum = StaticData.CarRealList.Where(t => t.LocatorNodeId == area.Id).Count();
                                        if (locatorNum < locator.MaxNumber)
                                        {
                                            area = locator;
                                            //未满
                                            locatorid = locator.Id;
                                            break;
                                        }

                                    }

                                }

                                //判断小车号是否存在 ,使用内存记录
                                // CarRealInfo car = DBService.GetCarModel(carno.ToString());
                                CarRealInfo car = StaticData.CarRealList.Where(t => t.CarNo == carno.ToString()).FirstOrDefault();

                                if (car == null)
                                {
                                    //小车不存在了, 就插入初始化数据
                                    car = new CarRealInfo();
                                    car.CarNo = carno.ToString();
                                    car.CurrNodeId = nodeFirst.Id;
                                    car.CurrNodeSetting = nodeFirst;

                                    car.LocatorNodeId = nodeFirst.Id;
                                    car.LocatorNodeSetting = nodeFirst;

                                    //car.MaterialBarNo = Product.ProductBarNo;
                                    //car.MaterialInfo = Product.MaterialInfo;
                                    car.MaterialNo = carInfo.MaterialNo;
                                    car.OptDt = DateTime.Now;
                                    //car.OrderPlanId = orderplanId;
                                    //car.OrderPlan = currPlan;
                                    car.IsOver = 0;
                                    DBService.AddCarRealRecord(car);

                                }
                                else
                                {
                                    //小车存在了, 就修改初始化数据 
                                    car.CarNo = carno.ToString();
                                    car.CurrNodeId = nodeFirst.Id;
                                    car.CurrNodeSetting = nodeFirst;

                                    car.LocatorNodeId = nodeFirst.Id;
                                    car.LocatorNodeSetting = nodeFirst;
                                    //car.MaterialBarNo = Product.ProductBarNo;
                                    //car.MaterialInfo = Product.MaterialInfo;
                                    car.MaterialNo = carInfo.MaterialNo;
                                    //car.OrderPlanId = orderplanId;
                                    //car.OrderPlan = currPlan;
                                    car.OptDt = DateTime.Now;
                                    car.IsOver = 0;
                                    DBService.ModifyRealCarinfoRecord(car);

                                }

                                Productinfo producthistory = new Productinfo();
                                producthistory.CreateTime = DateTime.Now;
                                producthistory.IsDeleted = 0;
                                producthistory.MaterialNo = carInfo.MaterialNo;
                                // producthistory.ProductBarno = Product.ProductBarNo;
                                ///记录产品信息
                                DBService.AddProductInfo(producthistory);
                                //删除上件工件队列
                                DBService.DeleteUpLineMaterial(carInfo.Id);

                                //添加小车记录表
                                DBService.AddCarHistoryRecord(car);
                                //记录小车已经离开.
                                // DBService.UpdateCarOverState(car.Id, 1);

                                //同步内存表小车数据
                                StaticData.CarRealList.Add(car);

                                ///回写plc状态,起点的分支线路为1
                                plcHelper.Write(StaticData.getPlcInfoByCode("incaradapter_w" + lineNo), 1);
                                ///回写plc状态处理完成,plc会清理数据
                                plcHelper.Write(StaticData.getPlcInfoByCode("incarclear_w" + lineNo), 1);


                            }//小车移动中指定点位后,并且到位了
                            else if (Convert.ToInt32(lineNo) == 0 && Convert.ToInt32(carstate) == 0 && Convert.ToInt32(carrun) == 1)
                            {
                                //CarRealInfo car = StaticData.CarRealList.Where(t => t.CarNo == carno.ToString()).FirstOrDefault();
                                //if (car != null)
                                //{
                                logger.Log(" 小车离开了 [" + lineNo + "]号上件点");
                                ///回写plc状态,,plc会清理数据
                                plcHelper.Write(StaticData.getPlcInfoByCode("incaradapter_w" + lineNo), 0);
                                ///回写plc状态处理完成,plc会清理数据
                                plcHelper.Write(StaticData.getPlcInfoByCode("incarclear_w" + lineNo), 0);

                                ///回写plc状态处理完成,plc会清理数据
                                //    plcHelper.Write(getPlcInfoByCode("inlineoutwcs_" + lineno), 1);
                                /////回写plc状态处理完成,plc会清理数据
                                //plcHelper.Write(getPlcInfoByCode("inlinestate_" + lineno), 1);


                                //}
                                //else
                                //{
                                //    logger.Log("线体[" + lineno + "]小车信息[" + carno + "]从内存记录中没有找到");
                                //}
                            }

                        }
                        else
                        {
                            logger.Log("[" + lineNo + "]小车到位,但是工件队列是空的");
                        }

                    }
                }
                catch (Exception ex)
                {
                }
            }
        }
    }
}