using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Threading;
using Microsoft.VisualBasic;
using DBFactory;
using ICommLayer;

namespace FINSTCPIP
{
   
    /// <summary>
    /// 20210405 FINS 协议通讯接口派生类
    /// 发送设备命令类
    /// 创建者：zcy
    /// </summary>
    public class CSendDeviceOrder: ISendDeviceOrder
    {
        string _commLayerError;

        public string CommLayerError
        {
            get { return _commLayerError; }
            set { _commLayerError = value; }
        }
        DBOperator dbo = CommonClassLib.AppSettings.dbo;//20130510
        public CSendDeviceOrder()
        {
            dbo.Open();
        }
        //~CSendDeviceOrder()
        //{
        //    dbo.Close();
        //}

        /// <summary>
        /// 发送穿梭板命令
        /// </summary>
        /// <param name="MessageIndex">消息编号</param>
        /// <param name="TaskIndex">任务编号</param>
        /// <param name="Order">环穿命令字</param>
        ///1-入货
        ///2-出货
        ///3-上堆垛机
        ///4-下堆垛机
        ///6-复位
        ///7-掉头到B边
        ///12-掉头到A边
        ///30-开始充电
        ///50-停止充电
        /// <returns>发送穿梭板命令是否成功</returns>
        public bool SendDeviceOrder(int MessageIndex, int TaskIndex, int Order, int DeviceIndex, int ArrowDeviceIndex )
        {
            
            Model.MDevice devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIndex);
            string shuttleIP = devinfo.RemoteIP;

            if (FINSTCPIP.SHICANGProtocol.ShuttleConnected(shuttleIP) == false)
            {
                return false;
            }

            StringBuilder sql = new StringBuilder();
            DataView dv = new DataView();


            //只有入货和出货时才检测 TaskIndex
            if ( Order == 1 || Order == 2 )
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT * FROM T_Monitor_Task WHERE F_MonitorIndex = ").Append(TaskIndex).Append(" AND F_Status = 0");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count == 0)
                {
                    _commLayerError = "FINSTCPIP.CSendDeviceOrder.SendDeviceOrder发生错误：不存在" + TaskIndex + " 对应的空闲指令!";
                    return false;
                }
            }
            
            #region 在充电桩的货架里，发送任何指令时，都先发位置(LYJL更改了协议)
            if (FINSTCPIP.SHICANGProtocol.ShuttleInBetteyLane(DeviceIndex) == true)
            {
                SHICANGProtocol.Order_InBetteyLocatLane(DeviceIndex);
                #region  在充电桩的货架里，不能发送切换模式
                if (Order == 3 || Order == 4)
                {
                    _commLayerError = "FINSTCPIP.CSendDeviceOrder.SendDeviceOrder发生错误："+ DeviceIndex + "在充电位置，不能发送切换模式！";
                    return false;
                }
                #endregion
            }
            #endregion
            #region 发禁止动作时，车状态必须空闲、报警、充电中
            if (Order == 11)
            {
                if (devinfo.RunState == 0 || devinfo.SplitByte_3 == 1 || devinfo.RunState == 2)
                {

                }
                else
                {
                    return false;
                }
            }
            #endregion

            #region 没有坐标/在堆垛机上，不能发送任何指令
            int z = FINSTCPIP.SHICANGProtocol.GetZ(DeviceIndex);
            if (z == 0 || z > 10 || z == -1)
            {
                _commLayerError = "FINSTCPIP.CSendDeviceOrder.SendDeviceOrder发生错误：" + DeviceIndex + "坐标不正确，不能发送指令！";
                return false;
            }
            #endregion

            //如果时间是10秒以前的，则认为车状态未更新，不能发送
            //DateTime appdt = new DateTime();
            //DateTime.TryParse(dv[0]["F_Time"].ToString(), out appdt);
            //if (appdt.AddSeconds(10) < DateTime.Now)
            //{
            //    return false;
            //}
            if (FINSTCPIP.SHICANGProtocol.GetTime(DeviceIndex).AddSeconds(10) < DateTime.Now)
            {
                return false;
            }

            try
            {
                #region 入货、出货需要先检查车位置和货位是否一致 (未完成)
                //所有的车坐标都不一致要调车过来，有车一致则更新车号
                #endregion

                if (MessageIndex != 1)
                {
                    return false;

                }

                switch (Order)
                {
                    case 1:
                        // RGV入货（穿梭板前往堆垛机放货站台取货，送到货位深处）
                        SHICANGProtocol.Order_SetGood(shuttleIP, TaskIndex);
                        break;
                    case 2:
                        // RGV出货（穿梭板前往第一个有货货位取货，送往堆垛机取货站台）
                        SHICANGProtocol.Order_GetGood(shuttleIP, TaskIndex);
                        break;
                    case 3:
                        // 穿梭板上堆垛机
                        SHICANGProtocol.Order_ChangeMode(shuttleIP, SHICANGProtocol.CHACHEMODE);
                        break;
                    case 4:
                        //穿梭板下堆垛机
                        SHICANGProtocol.Order_ChangeMode(shuttleIP, SHICANGProtocol.DUIDUOMODE);
                        break;
                    case 7:
                        // 穿梭板掉头到B边
                        SHICANGProtocol.Order_ChangeAB(shuttleIP, SHICANGProtocol.TOBSIDE);
                        break;
                    case 12:
                        //穿梭板掉头到A边
                        SHICANGProtocol.Order_ChangeAB(shuttleIP, SHICANGProtocol.TOASIDE);
                        break;
                    case 10:
                        
                        break;
                    case 11:
                            SHICANGProtocol.Order_ForbidShuttleMove(shuttleIP);
                            System.Threading.Thread.Sleep(100);
                        break;
                    case 13:
                            SHICANGProtocol.Order_AllowShuttleMove(shuttleIP);
                        break;
                    case 30:
                            SHICANGProtocol.Order_BeginCharge(shuttleIP);
                        break;
                    case 50:
                        // 穿梭板停止充电
                        SHICANGProtocol.Order_EndCharge(shuttleIP);
                       
                        break;
                    case 6:
                        //穿梭板复位
                        SHICANGProtocol.Order_ResetShuttle(shuttleIP);
                        break;
                    case 5:
                        //穿梭板回原点
                        SHICANGProtocol.Order_ToOrigin(shuttleIP);
                        break;
                    default:
                            break;
                }

                
                //在发送成功时，将车锁定。SendOrderSuccess()


                int Fid = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(TaskIndex);
                writeDark(Fid, TaskIndex, DeviceIndex, Order, 0);

                return true;
            }
            catch (Exception ex)
            {
                _commLayerError = this.ToString() + ":SendDeviceOrder---" + ex.Message;
                return false;
            }
            finally
            {
                
                dv.Dispose();
            }

        }
        public void writeDark(int Fid, int TaskIndex, int DeviceIndex, int dorder, int AGVAddress)
        {
            DataView dv;
            try
            {
                string barcode = string.Empty;
                StringBuilder sss = new StringBuilder("");
                sss.Remove(0, sss.Length);
                sss.Append("SELECT  F_TxtParam FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(TaskIndex).Append(")");
                dv = dbo.ExceSQL(sss.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    barcode = dv[0]["F_TxtParam"].ToString();
                }
                else
                {
                    barcode = "-";
                }
                sss.Remove(0, sss.Length);
                sss.Append("条码：").Append(barcode).Append("").Append("**管理任务：" + Fid.ToString()).Append("**设备指令索引：" + TaskIndex.ToString())
                                    .Append("**命令字" + dorder.ToString()).Append("**位置" + AGVAddress.ToString());

                CommonClassLib.CCarryConvert.WriteDarkCasket(this.ToString(), "发送RGV指令", DeviceIndex.ToString(), sss.ToString());
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv = null;
            }
        }
        public bool SendDeviceOrder(int MessageIndex, int TaskIndex, int Order, int DeviceIndex, int StartX, int StartY, int StartZ, int EndX, int EndY, int EndZ)
        {
            _commLayerError = "穿梭板指令发送时，选择重载方法错误";
            return false;
        }
        public bool SendDeviceOrder(int MessageIndex, int TaskIndex, int Order, int DeviceIndex, int StartX, int StartY, int StartZ, int EndX, int EndY, int EndZ, string DoubleFork)
        {
            return true;

        }
        public bool SendDeviceOrder(int DeviceIndex, string TobaccoCode, bool HaveFirstProjectCode, bool IfSmallTobacco, int Count)
        {
            return true;
        }
        public bool WriteDBData(StringBuilder[] ItemNames, StringBuilder[] ItemValues)
        {
            return true;
        }
        public bool WriteDBData(StringBuilder[] ItemNames, StringBuilder[] ItemValues, string PLCconnectionID)
        {
            return true;
        }
    }
}