using AGVLib;
using Common;
using DeviceLib.DB.Config;
using DeviceLib.Model.AGV;
using System.Collections.Generic;
using System.Data.SqlTypes;

namespace DeviceLib.BLL
{
    public class OrderManager
    {
        /// <summary>
        /// 是否启用返回点参数所在位置
        /// </summary>
        public static int idxOpenBackPoint = 2;
        /// <summary>
        /// 是否启用返回点参数的长度
        /// </summary>
        public static int lenOpenBackPoint = 1;
        /// <summary>
        /// 判断任务是否相同的方式所在位置
        /// </summary>
        public static int idxOpenSameOrder = 1;
        /// <summary>
        /// 判断任务是否相同的方式的长度
        /// </summary>
        public static int lenOpenSameOeder = 1;
        /// <summary>
        /// 动作的起始位置
        /// </summary>
        public static int idxAction = 3;

        public delegate void OrderStateChangedEventHandler(List<Order> orders);
        public static event OrderStateChangedEventHandler OrderStateChanged;
        public static List<Order> Load()
        {
            return getOrders();
        }
        /// <summary>
        /// 检查订单类型是否被启用
        /// </summary>
        /// <param name="order"></param>
        static OrderType getOrderType(Order order)
        {
            return ConfigOperation.GetOrderType(order.type);
        }
        /// <summary>
        /// 根据节点状态生成运输任务
        /// </summary>
        /// <param name="clientNodes"></param>
        /// <returns></returns>
        public static bool AutoGenerateOrder(List<ClientNode> clientNodes)
        {
            try
            {
                List<Order> orders = getOrders();
                foreach (var item in clientNodes)
                {
                    if (item.status.Equals((int)NodeStatus.None))
                    {
                        Order order = orders.Find(s => s.id.Equals(item.name) && s.type==1);
                        if (order != null && order.robot_id==0)
                            OrderManager.DeleteOrderById(order.id, out string msg, true);
                    }
                    if (!item.online) continue;
                    // if (item.shielded) continue;
                    if (!item.opened) continue;
                    if (item.status.Equals((int)NodeStatus.NeedLeave) && isValidRfid(item.shelf_id))
                    {
                        Order order = orders.Find(s => s.id.Equals(item.name));
                        if (order != null) continue;
                        order = new Order();
                        order.id = item.name;
                        if (item.name.StartsWith("A"))
                            order.type = 1;
                        //else if (item.name.StartsWith("B"))
                        // order.type = 2;
                        else
                            continue;
                        order.source = item.name;
                        order.remark = item.shelf_id;
                        bool rtn = ConfigOperation.Add_Order(order);
                        if (rtn)
                            LogUtil.Info($"订单创建成功：{order}");
                        else
                            LogUtil.Error($"订单创建失败：{order}");
                        OrderStateChanged?.Invoke(getOrders());
                    }
                }
            }
            catch
            {

            }

            return false;
        }
       static bool isValidRfid(string shelf)
        {
            return !string.IsNullOrEmpty(shelf) && shelf.StartsWith("CN");
        }
        public static void GenerateShelfOrder(List<ClientNode> clientNodes)
        {
            List<Order> orders = getOrders();
            try
            {
                if (HttpManager.getNIOutInfo(out string line))
                {
                    Order order = orders.Find(s => s.id.StartsWith("B"));
                    if(order==null)
                    {
                        order = new Order();
                        ClientNode clientNode = clientNodes.Find(s => s.name.StartsWith("B"));
                        if(clientNode!=null)
                        {
                            order.id = clientNode.name;
                             order.type = 2;
                            order.source = clientNode.name;
                            order.target = line;
                            bool rtn = ConfigOperation.Add_Order(order);
                            if (rtn)
                                LogUtil.Info($"订单创建成功：{order}");
                            else
                                LogUtil.Error($"订单创建失败：{order}");
                            OrderStateChanged?.Invoke(getOrders());
                        }

                    }

                }
                else
                {
                    Order order = orders.Find(s => s.id.StartsWith("B"));
                    if (order != null)
                        OrderManager.DeleteOrderById(order.id, out string msg, true);
                }
            }
            catch { }
          
        }
        public static bool CreateOrder(Order order, out string msg)
        {
            msg = "";
            OrderType type = getOrderType(order);
            if (type == null)
            {
                msg = $"order id ({order.id}) creates fail! due the order type ({order.type}) do not be supported. please contact administrator.";
                LogUtil.Error($"订单创建失败：{msg}");
                return false;
            }
            if (CheckIfExist(order))
            {
                msg = $"order id ({order.id}) has been existed. please make sure it is unique.";
                LogUtil.Error($"订单创建失败：{msg}");
                return false;
            }
            else if (!NodeManager.CheckNodeNames(order.source, out string msg1))
            {
                msg = $"there is a error in the value of field source.{msg1}";
                LogUtil.Warn($"订单创建失败：{msg}");
                return false;
            }
            else if (!NodeManager.CheckNodeNames(order.target, out string msg2))
            {
                msg = $"there is a error in the value of field target.{msg2}";
                LogUtil.Warn($"订单创建失败：{msg}");
                return false;
            }
            else if (!order.id.Substring(idxOpenBackPoint, lenOpenBackPoint).Equals("0") && !string.IsNullOrEmpty(order.back_point))
            {
                if (!NodeManager.CheckNodeNames(order.back_point, out string msg3))
                {
                    msg = $"there is a error in the value of field back_point.{msg2}";
                    LogUtil.Warn($"订单创建失败：{msg}");
                    return false;
                }
            }
            order.remark = type.description;
            //order.create_time = System.DateTime.Now;
            bool rtn = ConfigOperation.Add_Order(order);
            if (rtn)
                LogUtil.Info($"订单创建成功：{order}");
            else
                LogUtil.Error($"订单创建失败：{order}");
            OrderStateChanged?.Invoke(getOrders());
            return rtn;
        }
        /// <summary>
        /// 根据订单号删除订单
        /// </summary>
        /// <param name="id"></param>
        /// <param name="msg"></param>
        /// <param name="force"></param>
        /// <returns></returns>
        public static bool DeleteOrderById(string id, out string msg, bool force = false)
        {
            msg = "ok";
            if (!CheckIfExist(id))
            {
                msg = $"order ({id}) do not exist. please make sure id is correct.";
                LogUtil.Warn($"运输单删除失败：{msg}");
                return false;
            }
            else if (force)
            {
                bool rtn1 = ConfigOperation.Del_Order(id);
                if (rtn1)
                    LogUtil.Info($"运输单强制删除成功：{id}");
                else
                    LogUtil.Error($"运输单强制删除失败：{id}");
                OrderStateChanged?.Invoke(getOrders());
                return rtn1;
            }
            else if (CheckOrderIsRunning(id))
            {
                msg = $"order ({id}) has been running.Deletion is prohibited.";
                LogUtil.Warn($"运输单删除失败：{msg}");
                return false;
            }
            bool rtn = ConfigOperation.Del_Order(id);
            if (rtn)
                LogUtil.Info($"运输单删除成功：{id}");
            else
                LogUtil.Error($"运输单删除失败：{id}");
            OrderStateChanged?.Invoke(getOrders());
            return rtn;
        }
        /// <summary>
        /// 根据任务类型删除
        /// </summary>
        /// <param name="id"></param>
        /// <param name="msg"></param>
        /// <param name="force"></param>
        /// <returns></returns>
        public static bool DeleteOrderByType(int typeId, out string msg, bool force = false)
        {
            msg = "ok";
            if (!CheckIfExist(typeId))
            {
                msg = $"order type ({typeId}) do not exist. please make sure id is correct.";
                LogUtil.Warn($"订单删除失败：{msg}");
                return false;
            }
            else if (force)
            {
                bool rtn1 = ConfigOperation.Del_Order(typeId);
                if (rtn1)
                    LogUtil.Info($"订单强制删除成功：{typeId}");
                else
                    LogUtil.Error($"订单强制删除失败：{typeId}");
                OrderStateChanged?.Invoke(getOrders());
                return rtn1;
            }
            else if (CheckOrderIsRunning(typeId))
            {
                msg = $"order type({typeId}) has been running.Deletion is prohibited.";
                LogUtil.Warn($"订单删除失败：{msg}");
                return false;
            }
            bool rtn = ConfigOperation.Del_Order(typeId);
            if (rtn)
                LogUtil.Info($"订单删除成功：{typeId}");
            else
                LogUtil.Error($"订单删除失败：{typeId}");
            OrderStateChanged?.Invoke(getOrders());
            return rtn;
        }
        /// <summary>
        /// 检查订单是否已执行
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        static bool CheckOrderIsRunning(string id)
        {
            return GetOrder(id).state > 0;
        }
        /// <summary>
        /// 检查订单是否已执行
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        static bool CheckOrderIsRunning(int typeId)
        {
            return GetOrder(typeId).state > 0;
        }
        /// <summary>
        /// 检查是否已存在任务
        /// </summary>
        /// <param name="order">true：存在</param>
        /// <returns></returns>
        static bool CheckIfExist(Order order)
        {
            bool rtn = false;
            switch (order.id.Substring(idxOpenSameOrder, lenOpenSameOeder))
            {
                case "0"://根据任务编号
                    rtn = getOrders().Find(s => s.id.Equals(order.id)) != null;
                    break;
                case "1"://根据任务类型
                    rtn = getOrders().Find(s => s.type.Equals(order.type)) != null;
                    break;
                default:
                    rtn = getOrders().Find(s => s.id.Equals(order.id)) != null;
                    break;
            }
            return rtn;
        }
        /// <summary>
        /// 检查任务编号是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        static bool CheckIfExist(string id)
        {
            return getOrders().Find(s => s.id.Equals(id)) != null;
        }
        /// <summary>
        /// 检查任务类型是否存在
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        static bool CheckIfExist(int id)
        {
            return getOrders().Find(s => s.id.Equals(id)) != null;
        }
        /// <summary>
        /// 获取一个指定车间可执行的订单
        /// </summary>
        /// <param name="robot">机器人</param>
        /// <param name="state">订单状态，0：创建</param>
        /// <returns></returns>
        public static Order GetExecutableOrder(Robot robot, int state = 0)
        {
            return getOrders().Find(s => getRobotsById(s.type).Contains(robot.id) &&
            s.robot_id == 0 && s.state.Equals(state));
        }
        /// <summary>
        /// 设置订单状态
        /// </summary>
        /// <param name="orderId">订单编号</param>
        /// <param name="state">订单状态</param>
        public static bool SetOrderState(string orderId, int state)
        {
            Order order = GetOrder(orderId);
            if (order != null)
            {
                order.state = state;
                setOrder(order);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 清除AGV占用的任务
        /// </summary>
        /// <param name="missionInfo"></param>
        public static void ResetOccupiedAgv(string orderId)
        {
            Order order = GetOrder(orderId);
            if (order != null)
            {
                order.robot_id = 0;
                setOrder(order);
            }
        }
        /// <summary>
        /// 设置AGV占用的任务
        /// </summary>
        /// <param name="missionInfo"></param>
        public static void SetOccupiedAgv(string orderId, Robot robot)
        {
            Order order = GetOrder(orderId);
            if (order != null)
            {
                order.robot_id = robot.id;
                setOrder(order);
            }
        }
        public static void ClearAllOrder()
        {
            foreach (var item in getOrders())
            {
                DeleteOrderById(item.id, out string msg, true);
            }
        }
        public static Order GetOrder(string orderId)
        {
            return getOrders().Find(s => s.id == orderId);
        }
        public static Order GetOrder(int typeId)
        {
            return getOrders().Find(s => s.type == typeId);
        }
        /// <summary>
        /// 获取执行该订单类型的机器人
        /// </summary>
        /// <param name="robot"></param>
        /// <returns></returns>
        static List<int> getRobotsById(int orderTypeId)
        {
            if (orderTypes.Count == 0)
            {
                List<OrderType> tmpTypes = ConfigOperation.GetAllOrderTypes();
                foreach (var item in tmpTypes)
                {
                    string[] tmp2 = item?.robots?.Split(',');
                    if (tmp2 != null && tmp2.Length > 0)
                    {
                        orderTypes.Add(item.id, new List<int>());
                        foreach (var item1 in tmp2)
                        {
                            orderTypes[item.id].Add(int.Parse(item1));
                        }
                    }
                }
            }
            List<int> types = orderTypes[orderTypeId];
            if (types == null)
                return new List<int>();
            return types;
        }
        public static string GetOrderType(int typeId)
        {
            try
            {
                OrderType orderType = ConfigOperation.GetAllOrderTypes()?.Find(s => s.id.Equals(typeId));
                return orderType?.description ?? "转换失败";
            }
            catch
            {
                return "转换失败";
            }
        }
        public static string GetOrderState(int stateId)
        {
            try
            {
                OrderState orderState = ConfigOperation.GetOrderState(stateId);
                return orderState?.description ?? "转换失败";
            }
            catch
            {
                return "转换失败";
            }
        }
        /// <summary>
        /// 各订单可执行任务的机器人编号
        /// </summary>
        static Dictionary<int, List<int>> orderTypes = new Dictionary<int, List<int>>();
        /// <summary>
        /// 获取所有订单
        /// </summary>
        /// <returns></returns>
        static List<Order> getOrders()
        {
            return ConfigOperation.Get_Orders() ?? new List<Order>();
        }
        /// <summary>
        /// 设置订单值
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        static bool setOrder(Order order)
        {
            bool rtn = true;
            if (order.state == 100)
            {
                rtn = ConfigOperation.Del_Order(order);
            }
            else
                rtn = ConfigOperation.SetOrder(order);
            OrderStateChanged?.Invoke(getOrders());
            return rtn;
        }
    }
}