using iWareCc.Cache.Entity;
using iWareCc.Conveyor.Entity;
using iWareCc.HeartBeat.Entity;
using iWareCc.Properties;
using iWareCc.Srm.Entity;
using iWareCc.Task.Service;
using iWareCc.WCF.ThreeEntity;
using iWareCommon.Common.Entity;
using iWareCommon.Utils;
using iWareDataCore.ORM;
using iWareDataCore.TASK.Entity;
using iWareDataCore.TASK.EnumType;
using iWareDataCore.TASK.Service;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace iWareCc.WCF.ControlCenter
{
    // 注意: 使用“重构”菜单上的“重命名”命令，可以同时更改代码和配置文件中的类名“ControlCenterWCFService”。
    public class ControlCenterWcfService : IControlCenterWcfService
    {
        /// <summary>
        /// 1获取堆垛机各个属性的值
        /// </summary>
        /// <param name="stackName">堆垛机名称</param>
        /// <param name="msg">异常错误信息</param>
        /// <returns>堆垛机各个属性的值</returns>
        public StackerInfoEntity GetStackInfo(string stackName, out string msg)
        {
            try
            {
                msg = "";
                var stacker = CacheEntity.Stackers.FirstOrDefault(x => x.Equipment.EquipName == stackName);
                return new StackerInfoEntity(stacker);
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetStackInfo", msg);
                return null;
            }
        }

        /// <summary>
        /// 获取堆垛机
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public List<StackerInfoEntity> GetStackInfos(out string msg)
        {
            try
            {
                msg = "";
                var stackerInfos = new List<StackerInfoEntity>();
                CacheEntity.Stackers.ForEach(x => stackerInfos.Add(new StackerInfoEntity(x)));
                return stackerInfos;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetStackInfos", msg);
                return null;
            }
        }

        /// <summary>
        /// 2获取输送机各端口个属性的值
        /// </summary>s
        /// <param name="conveyorName">输送机名称</param>
        /// <param name="msg">异常错误信息</param>
        /// <returns>输送机各端口个属性的值</returns>
        public List<GateInfoEntity> GetConveyorInfo(string conveyorName, out string msg)
        {
            try
            {
                msg = "";
                var gateInfos = new List<GateInfoEntity>();
                var conveyor = CacheEntity.Conveyors.FirstOrDefault(x => x.Equipment.EquipName == conveyorName);
                conveyor.Gates.ForEach(x => gateInfos.Add(new GateInfoEntity(x)));
                return gateInfos;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetConveyorInfo", msg);
                return new List<GateInfoEntity>();
            }
        }

        /// <summary>
        /// 获取输送机信息列表
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public List<ConveyorInfoEntity> GetConveyorInfos(out string msg)
        {
            try
            {
                msg = "";
                var conveyorInfos = new List<ConveyorInfoEntity>();
                CacheEntity.Conveyors.ForEach(x => conveyorInfos.Add(new ConveyorInfoEntity(x)));
                return conveyorInfos;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetConveyorInfos", msg);
                return null;
            }
        }

        /// <summary>
        /// 2获取输送机各端口个属性的值
        /// </summary>
        /// <param name="conveyorName">输送机名称</param>
        /// <param name="gateName">端口名称</param>
        /// <param name="msg">异常错误信息</param>
        /// <returns>输送机各端口个属性的值</returns>

        public GateInfoEntity GetGateInfo(string conveyorName, string gateName, out string msg)
        {
            try
            {
                msg = "";
                var conveyor = CacheEntity.Conveyors.FirstOrDefault(x => x.Equipment.EquipName == conveyorName);

                var gate = conveyor.Gates.FirstOrDefault(x => x.Place.PlaceTypeName == gateName);

                return new GateInfoEntity(gate);
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetGateInfo", "msg={0},conveyorName={1},gateName={2}", ex.Message, conveyorName, gateName);
                return null;
            }
        }
       /// <summary>
       /// 验证输入物料是否在数据库中存在，并确认是下发的任务
       /// </summary>
       /// <param name="materialcode"></param>
       /// <param name="msg"></param>
       /// <returns></returns>
        public bool SendAndChackMaterial(string materialcode, out string msg)
        {
            try
            {
                var conveyor = CacheEntity.Conveyors.FirstOrDefault(x => x.Equipment.EquipName == "conveyor1");
                var gate = conveyor.Gates.FirstOrDefault(x => x.Place.PlaceTypeName == "sc");
                using (var dbmode = new DbModelCore())
                {
                    var material = dbmode.BASEMaterials.FirstOrDefault(x => x.code == materialcode);
                    if (material == null)
                    {
                        msg = "您输入的物料不存在！";
                        return false;
                    }
                    else 
                    {
                        //var task = dbmode.TASKPartTasks.FirstOrDefault(x => x.materialcode == materialcode&&x.isfinished==0);
                        //if (task==null)
                        //{
                        //    msg = "您输入的物料在下发的任务中不存在！";
                        //    return false;
                        //}
                        msg = "";
                        gate.RCheckMaterialCode = materialcode;
                        return true;
                    }
                };
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetOccupied", ex.Message);
                return false;
            }
        }

        ///// <summary>
        ///// 2获取心跳各属性的值
        ///// </summary>
        ///// <returns>输送机各端口个属性的值</returns>
        //public HeartBeatInfoEntity GetHeartBeatInfo(out string msg)
        //{
        //    try
        //    {
        //        msg = "";
        //        return new HeartBeatInfoEntity(CacheEntity.HeartBeat);
        //    }
        //    catch (Exception ex)
        //    {
        //        msg = ex.Message;
        //        LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "GetHeartBeatInfo", ex.Message);
        //        return null;
        //    }
        //}



       
        /// <summary>
        /// 8获取自动模式
        /// </summary>
        public bool GetIsAutoMode() { return CacheEntity.IsAutoMode; }

        /// <summary>
        /// 9修改自动模式
        /// </summary>
        public void SetIsAutoMode(bool flag) { CacheEntity.IsAutoMode = flag; }

        /// <summary>
        /// 10获取自动处理任务
        /// </summary>
        public bool GetIsAutoHandle() { return CacheEntity.IsAutoHandle; }

        /// <summary>
        /// 11修改自动处理任务
        /// </summary>
        public void SetIsAutoHandle(bool flag) { CacheEntity.IsAutoHandle = flag; }


        /// <summary>
        /// 12获取自动执行任务
        /// </summary>
        public bool GetIsAutoRun() { return CacheEntity.IsAutoRun; }

        /// <summary>
        /// 13修改自动执行任务
        /// </summary>
        public void SetIsAutoRun(bool flag) { CacheEntity.IsAutoRun = flag; }




        /// <summary>
        /// 获取是否批次
        /// </summary>
        public bool GetIsLots() { return CacheEntity.IsLots; }

        /// <summary>
        /// 修改是否批次
        /// </summary>
        public void SetIsLots(bool flag) { CacheEntity.IsLots = flag; }


        /// <summary>
        /// 14更新运行模式配置缓存
        /// </summary>
        public void UpdateDeviceRunningMode()
        {
            string msg;
            string stackerName = Enum.GetName(typeof(iWareDataCore.DEV.EnumType.EEquipmentCnName), iWareDataCore.DEV.EnumType.EEquipmentCnName.stacker1);
            var modes = DeviceRunningModeService.GetInstance().QueryByParam(new QueryParam { }, out msg);

            CacheEntity.DeviceRunningMode = modes.Count > 0 ? modes[0] : new DeviceRunningModeEntity { Mode = (int)EDeviceMode.双堆垛机模式, EquipmentName = stackerName };
        }

        /// <summary>
        /// 15获取模式
        /// </summary>
        public string GetMode()
        {
            return CacheEntity.DeviceRunningMode == null ? EDeviceMode.双堆垛机模式.ToString() : ((EDeviceMode)CacheEntity.DeviceRunningMode.Mode).ToString();
        }

        /// <summary>
        /// 16获取运行的堆垛机
        /// </summary>
        public string GetStacker()
        {
            string stackerName = Enum.GetName(typeof(iWareDataCore.DEV.EnumType.EEquipmentCnName), iWareDataCore.DEV.EnumType.EEquipmentCnName.stacker1);

            return CacheEntity.DeviceRunningMode == null ? "堆垛机1" : CacheEntity.DeviceRunningMode.EquipmentName == stackerName ? "堆垛机1" : "堆垛机2";
        }


        /// <summary>
        /// 获取是否判断RFID
        /// </summary>

        public bool GetIsRfid() { return CacheEntity.IsRfid; }

        /// <summary>
        /// 修改是否判断RFID
        /// </summary>
        public void SetIsRfid(bool flag) { CacheEntity.IsRfid = flag; }


        /// <summary>
        /// 设置IP字典
        /// </summary>
        /// <param name="ip1">本机IP</param>
        /// <param name="ip2">配置的IP</param>
        public void SetIpDict(string ip1, string ip2)
        {
            if (!CacheEntity.IpDict.ContainsKey(ip1))
            {
                CacheEntity.IpDict.Add(ip1, ip2);
            }
            else
            {
                CacheEntity.IpDict[ip1] = ip2;
            }
        }

        /// <summary>
        /// 获取ip
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        public string GetIp(string ip)
        {
            return CacheEntity.IpDict.ContainsKey(ip) ? CacheEntity.IpDict[ip] : ip;
        }
        /// <summary>
        /// 获取是否使虚拟模式
        /// </summary>
        public bool GetIsVisualMode() { return CacheEntity.IsVisualMode; }

        /// <summary>
        /// 修改是否使虚拟模式
        /// </summary>
        public void SetIsVisualMode(bool flag) { CacheEntity.IsVisualMode = flag; }


        #region spx对接外部接口
        /// <summary>
        ///下发入库单请求
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public List<StockTransferResponseItem> StockTransferRequestItemSend(List<StockTransferRequestItem> data)
        {
            ///将需要入库的型材批次信息保存到数据库

            return new List<StockTransferResponseItem>();
        }
        /// <summary>
        /// 下发出库单信息
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public List<PickListResponse> PickListAdd(List<PickList> data)
        {
            ///将需要出库的型材信息保存到数据库

            return new List<PickListResponse>();
        }
        /// <summary>
        /// 获取库存信息
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public List<StockItem> StockItemGet(StockItemFilter data) 
        {

            return new List<StockItem>();
        }


        
        #endregion
    }
}