using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Data;
using System.Windows.Forms;
using Model;
 
using DeiNiu.Utils;
 
 
namespace elelab
{
    public class pick
    {
        public delegate void lightReturn(int orderNo,int eleId, int color, int eleAddress, int count,int num2);
        public static event lightReturn lightOffEvent;
        public static Thread pick_work;
        public static Thread pick_work_support;
        //public static Timer check_time; 
        //public static uart_dis_data[] ele_return_data = new uart_dis_data[10000];
        //public static int ele_return_receive_address = 0;
        //public static int ele_return_manage_address = 0;
        //public static int ele_return_max = 10000;
           
        public static bool begain_pick = false;
        //  public static bool Threads_state;
        // public static bool out_start_state;
        public static byte[,] ele_lab = new byte[3000, 100];//ele_id address type 0 拣选 1 播种 2 装车
        public static uart_dis_data[] ele_lab_data = new uart_dis_data[10000];//ele_id address type 0 拣选 1 播种 2 装车
        public static int receive_add = 0;
        public static int manage_add = 0;
        public static int add_max = 10000;

        public static int[] pick_part_task = new int[100];//分区名称 分区结果 0 没有任务 正在处理任务
        public static int[] seed_part_task = new int[100];//分区名称 分区结果 0 没有任务 正在处理任务
        public static int[] tran_part_task = new int[100];//分区名称 分区结果 0 没有任务 正在处理任务

   //     public static int port_max = 100;

        public static bool pick_task = true;

        public static List<int> activeComports = new List<int>() ;//激活的com口
         

        private static byte get_byte(string data)
        {
            int length = data.Length;
            List<string> str = new List<string>();
            for (int i = 0; i < length; i++)
            {
                string result = data.Substring(i, 1);
                char aaaq = Convert.ToChar(result);
                if ((aaaq >= 0x30) && (aaaq <= 0x39))
                {
                    str.Add(data.Substring(i, 1));
                }
            }
            if (str.Count == 1)
            {
                return Convert.ToByte(str[0]);
            }
            else if (str.Count == 2)
            {
                int len = Convert.ToInt16(str[0]);
                int len1 = Convert.ToInt16(str[1]);
                len = len * 10 + len1;
                return Convert.ToByte(len);
            }
            else if (str.Count == 3)
            {
                int len = Convert.ToInt16(str[0]);
                int len1 = Convert.ToInt16(str[1]);
                int len2 = Convert.ToInt16(str[2]);

                len = len * 100 + len1 * 10 + len2;
                return Convert.ToByte(len);

            }
            return 0;
        }
        private bool send_data(DataTable[] ds, byte byt)
        {
            for (int j = 0; j < ds.Length; j++)
            {
                //string part = ;
                byte part_byte = get_byte(ds[j].Rows[0]["part"].ToString());
                string port = ds[j].Rows[0]["port"].ToString();
                byte port_byte = get_byte(port);
                byte led_color = get_byte(ds[j].Rows[0]["color"].ToString());
                elelab.pick.make_data(ds[j], led_color, part_byte, port_byte, null, null, null, byt);
            }
            return true;
        }

       

        private static void init_sys_port(enumLabelPickType pickType)
        {

           // activeComports.Clear();
            clear_order order = new clear_order();
            int port;
            for (int i = 0; i < unart_manage.com_count; i++)//init com0-10
            {
                int com = Convert.ToByte(i);
                if (elelab.unart_manage.init_com_sys(com, true) == true)
                {
                    port = Convert.ToInt16(i);
                    // order = Convert.ToInt16(dt.Rows[i]["ele_order"]);
                    order.order = Convert.ToByte(i);
                    order.state =Convert.ToByte((int)pickType);
                    if (unart_manage.com_manage[port].clear_order(order))
                    {
                        activeComports.Add( port);
                    }
                }
            }
             
            init_pick();
            // clear_order(dt);
        }
        public static bool clear_order(DataTable dt)
        {
            int port;
            clear_order order = new clear_order();
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                port = Convert.ToInt16(dt.Rows[i]["port"]);
                // order = Convert.ToInt16(dt.Rows[i]["ele_order"]);
                order.order = Convert.ToByte(dt.Rows[i]["ele_order"]);
                order.state = 1;
                unart_manage.com_manage[port].clear_order(order);
            }
            return true;

        }
        public static void init_pick()
        {
            //为数据处理开辟线程
            // Thread workTicketThread;
            //Thread workTicketThread;
            if (pick_work != null)
                return;
            pick_work = new Thread(pick_sys);
            // Make this a background thread, so it will terminate when the main thread/process is de-activated
            pick_work.IsBackground = true;
            //pick_work.SetApartmentState(ApartmentState.STA);
            pick_work.SetApartmentState(ApartmentState.MTA);
            // Start the Work
            pick_work.Start();
            //workerThreads[i] = workTicketThread;
        }

        public static void init_pick_support()
        {
            //为数据处理开辟线程
            // Thread workTicketThread;
            //Thread workTicketThread;
            pick_work_support = new Thread(pick_sys_support);
            // Make this a background thread, so it will terminate when the main thread/process is de-activated
            pick_work_support.IsBackground = true;
            //pick_work.SetApartmentState(ApartmentState.STA);
            pick_work_support.SetApartmentState(ApartmentState.MTA);
            // Start the Work
            pick_work_support.Start();
            //workerThreads[i] = workTicketThread;
        }

        public static void wake_thread()
        {

          //  if (Convert.ToInt16(pick_work.ThreadState) == 68)
            {
                try
                {
                    if (Convert.ToInt16(pick_work.ThreadState) == 68)
                    pick_work.Resume();
                }
                catch(Exception  er)
                {
                     

                }
            }

        }

        public static void wake_support_thread()
        {
            if (Convert.ToInt16(pick_work_support.ThreadState) == 68)
                pick_work_support.Resume();
        }
        private static void get_data(string data, out int dot_station, out int total_num)
        {
            data = Convert.ToDouble(data).ToString();
            string[] count = data.Split('.');//Out_count
            int full = Convert.ToInt16(count[0]);
            int dot_num;
            dot_station = 0;
            total_num = full;
            if (count.Length > 1)
            {
                dot_num = Convert.ToInt16(count[1]);
                if (dot_num > 0)
                {
                    if (dot_num < 10)
                    {
                        total_num = full * 10 + dot_num;
                        dot_station = 1;
                    }
                    else if ((dot_num > 9) && (dot_num < 100))
                    {
                        total_num = full * 100 + dot_num;
                        dot_station = 2;
                    }
                    else if ((dot_num > 99) && (dot_num < 1000))
                    {
                        total_num = full * 1000 + dot_num;
                        dot_station = 3;
                    }
                    else if ((dot_num > 999) && (dot_num < 10000))
                    {
                        total_num = full * 10000 + dot_num;
                        dot_station = 4;
                    }
                    else
                    {
                        dot_station = 0;
                    }
                }
            }
        }
        
        public static bool make_data(DataTable ds, byte led_color, byte ele_order_id, byte port,
                     string[] ele_lab_id, string[] ele_address, string[] Out_count, byte type)
        {
             
                return true;
             
        }
         
        public static bool rest_sys_device(byte port)
        {
            //clear_order order = new clear_order();
            //order.order = Convert.ToByte(ele_order_id);
            //order.state = 1;
            unart_manage.com_manage[port].write_reset_device();
            return true;
        }
        //依次点亮数据
        private void order_by_desc(string wave_order, string part, bool order)
        {

            //make_data();
            // unart_manage.com_manage[port - 1].
        }
        private static void read_single(int address)
        {
            while (unart_manage.com_manage[address].manage_address != unart_manage.com_manage[address].receive_address)
            {
                ele_lab_data[receive_add] = unart_manage.com_manage[address].return_data[unart_manage.com_manage[address].manage_address];
                receive_add++;
                if (receive_add >= add_max)
                {
                    receive_add = 0;
                }
                unart_manage.com_manage[address].manage_address++;
                if (unart_manage.com_manage[address].manage_address >= unart_manage.com_manage[address].return_max)
                {
                    unart_manage.com_manage[address].manage_address = 0;
                }
            }
        }
        private static void receive_data()
        {
            for (int i = 0; i < unart_manage.com_manage.Length; i++)
            {
                if (unart_manage.com_manage[i] != null)
                {
                    if (unart_manage.com_manage[i].wait_data == true)
                    {//读取数据
                        unart_manage.com_manage[i].wait_data = false;
                        read_single(i);
                    }
                }
            }
        }
        private static string receive_data_dot(int count, int dot_station)
        {
            string result = "0";
            if (dot_station == 0)
            {
                result = count.ToString();
            }
            else if (dot_station == 1)
            {
                result = (count / 10).ToString() + "." + (count % 10).ToString();
            }
            else if (dot_station == 2)
            {
                result = (count / 100).ToString() + "." + (count % 100).ToString();
            }
            else if (dot_station == 3)
            {
                result = (count / 1000).ToString() + "." + (count % 1000).ToString();
            }
            return result;
        }

      //  static WmsOutPickLable outPick = new WmsOutPickLable();
       // static lWmsOutPickRequest lpickRequest = new lWmsOutPickRequest();
       /// <summary>
       /// send back from elabel
       /// </summary>
        public static void return_data1()
        {
            returnData();
        }
         

        private static void manage_data()
        {
            return_data1();
        }
        private static bool read_state()
        {
            for (int i = 0; i < unart_manage.com_manage.Length; i++)
            {
                if (unart_manage.com_manage[i] != null)
                {
                    if (unart_manage.com_manage[i].wait_data == true)
                    {//读取数据
                        return true;

                    }
                }
            }
            return false;
        }
        public static void pick_sys()
        {
            //int count;Threads_state
            // Threads_state = true;
            //out_start_state = false;
            elelab.pick.init_pick_support();
            while (true)
            {
                // unart_manage.com_manage[17].return_data();
                pick_work_support.Suspend();
                //System.Threading.Thread.Sleep(15000);
                receive_data();
                manage_data();
                wake_support_thread();
                pick_work.Suspend();
            }
        }
        public static void pick_sys_support()
        {
            //int count;Threads_state
            while (true)
            {
                System.Threading.Thread.Sleep(2000);
                if (read_state() == true)
                {
                    wake_thread();
                }
                pick_work_support.Suspend();
            }
        }
        public static void test_multe()
        {

            //while (wms_usartmanage.pick.send_state == true) ;
            //wms_usartmanage.pick.send_state = true;

            //// while (get_part_task() == true) ;
            //get_part_task();
            ////while(led_lamble() == true);

            //wms_usartmanage.pick.send_state = false;
            return;
        }

        //webserver 接口
        //初始化端口
        //复位端口
        //清除订单
        public static void init_port(enumLabelPickType pickType)
        {
            elelab.unart_manage.init_sys();
            init_sys_port(pickType);
        }
        public static void init_port(enumLabelPickType pickType,bool isForce)
        {
            if (isForce)
            {
                elelab.unart_manage.clearComs();
            }
            init_port(pickType);
        }
        public static bool reset_device(int port)
        { 
            if( elelab.unart_manage.com_manage[port]!=null)
                return elelab.unart_manage.com_manage[port].write_reset_device();
            return false;

        }
      

        public static bool turnOnLight(int port, channel_led id_data)
        {
            if (unart_manage.com_manage[port] == null)
            {
                return false;
            }

            return unart_manage.com_manage[port].turnOnLight(id_data);
             
        }

        public static bool turnOffLight(int port, channel_led id_data)
        {
            if (unart_manage.com_manage[port] == null)
            {
                return false;
            }

           return unart_manage.com_manage[port].turnOffLight(id_data);
        }


        public static bool clearDis(int port, int ele_order_id)
        {
            clear_order order = new clear_order();
            order.order = Convert.ToByte(ele_order_id);
            order.state = 1;
            return unart_manage.com_manage[port].clear_order(order);
        }

        static Dictionary<int, int> portOrder = new Dictionary<int, int>();
        /// <summary>
        /// 以端口号为一组，点亮多个标签
        /// 适用于分拣墙
        /// </summary>
        /// <param name="lables"></param>
        /// <param name="portNo">端口号</param> 
        /// <returns></returns>
        public static bool lightLabels(List<DeiNiu.wms.win.ELabel> lables,bool isClearOrder,int orderNo, int portNo , enumLabelPickType pickType)////-----
        {
            // init_port(pickType);
            WmsConstants.WAVE_CURRENT_LIGHTS_PORT_STATUS.Clear();
            byte orderPort = get_byte(portNo.ToString());
            if (activeComports.Count == 0 || lables.Count == 0)
            {
                return false;
            }
            WmsConstants.WAVE_CURRENT_LIGHTS_PORT_STATUS[portNo] = false; ;
            //WmsConstants.WAVE_CURRENT_LIGHTS_STATUS.Clear();
            WmsConstants.WAVE_CURRENT_PICK_STATUS.Clear();
            WmsConstants.SEEDS_LABEL_ID.Clear();
            List<string> statuKeys = new List<string>();

            int orderId = portOrder.ContainsKey(portNo) ? portOrder[portNo]+1 : 1; 
            orderId = orderId >= 200 ? 1 : orderId;

            if (isClearOrder  )
            {
                orderId = orderNo ;
            }
            uart_dis_data[] ele_data_comment = new uart_dis_data[lables.Count];
            for (int j = 0; j < lables.Count; j++)
            {
                DeiNiu.wms.win.ELabel lb = lables[j];

                WmsConstants.SEEDS_LABEL_ID[orderId + "-" + lb.labelId] = lb.seedsId;


                ele_data_comment[j].dis_type = get_byte((lb.color).ToString());  //Convert.ToByte(textBox4.Text); 电子标签灯的颜色 1 红色 2 绿色 3 蓝色
                ele_data_comment[j].ele_id = lb.labelId; ;     //电子标签id
                ele_data_comment[j].order = Convert.ToByte(orderId);// get_byte(orderId.ToString());//Convert.ToByte(textBox2.Text);  单号
                ele_data_comment[j].receive_count = 0;  //为0
                ele_data_comment[j].little_ele_id = Convert.ToByte(lb.num1);// 货位号
                ele_data_comment[j].send_count = lb.num3;
                if (lb.num2 > 0)
                {
                    ele_data_comment[j].num2 = lb.num2;
                }
                ele_data_comment[j].state = 1;  //都为1

               
                ele_lab[ele_data_comment[j].ele_id, ele_data_comment[j].little_ele_id] = get_byte(((int)pickType).ToString());

                statuKeys.Add(Util.getLightKey(orderId, lb.color, lb.labelId, lb.num1));


            }// //向串口发送数据

             
            clear_order order = new clear_order();
            order.order = get_byte(orderId.ToString()); //orderPort;// get_byte(portNo.ToString());//Convert.ToByte(ele_order_id);
            order.state = 1;

            if (unart_manage.com_manage[orderPort].clear_order(order) == false)
            {
                return false;
            }
            portOrder[portNo] = orderId++;
            unart_manage.com_manage[orderPort].write_data(ele_data_comment);
            string result;
            bool isLightsSuccess = unart_manage.com_manage[orderPort].wait_ack(out result);

            WmsConstants.WAVE_CURRENT_LIGHTS_PORT_STATUS[portNo] = isLightsSuccess;

            foreach (string key in statuKeys)
            {
                WmsConstants.WAVE_CURRENT_LIGHTS_STATUS[key] = isLightsSuccess;  
                CURRENT_PICK_STATUS[key] = false;
            }
         
            return true;

        }

        static Dictionary<string, bool> CURRENT_PICK_STATUS = new Dictionary<string, bool>();
        /// <summary>
        /// 按灭标签，接收回传数据
        /// 用户可以在此进行标签灭灯事件的数据处理
        /// </summary>
        public static void returnData()
        {

            List<string> statuKeys = new List<string>();
            int eleId;  //标签ID
            int eleAddress;//标签坐标（层/列）
            int count;//数量
            int color;//颜色
            int orderNo; //端口
            int num2;
            // Dictionary<string, bool> tmp = CURRENT_PICK_STATUS;
            while (receive_add != manage_add)
            {
                count = Convert.ToInt16(receive_data_dot(Convert.ToInt32(ele_lab_data[manage_add].receive_count), Convert.ToInt16(ele_lab_data[manage_add].dot)));
                eleId = Convert.ToInt16(ele_lab_data[manage_add].ele_id.ToString()); //label id
                color = ele_lab_data[manage_add].dis_type;
                eleAddress = Convert.ToInt16(ele_lab_data[manage_add].little_ele_id.ToString()); //ele address
                int pickType =  ele_lab[eleId, eleAddress];

                orderNo = Convert.ToInt16(ele_lab_data[manage_add].order.ToString()); //port
                num2 = Convert.ToInt16(ele_lab_data[manage_add].num2.ToString()); //port
                //  int pno = Convert.ToInt16(ele_lab_data[manage_add].port.ToString()); //port
                string pno = ele_lab_data[manage_add].port;
                string key;

                if (eleId == 0)
                {
                    manage_add = receive_add;
                    break;
                }

                key = Util.getLightKey(orderNo, color, eleId, eleAddress);

                manage_add++;

                if (manage_add >= add_max)
                {
                    manage_add = 0;
                }

                if (CURRENT_PICK_STATUS.ContainsKey(key))
                {
                    if (CURRENT_PICK_STATUS[key])
                    {
                        Console.WriteLine("----------------------------   get key :" + key + ", orderNo: +" + orderNo);
                        continue;
                    }
                }
                else
                {
                    Console.WriteLine("------------------------------   key dose not exists :" + key);

                }


                //客户在此处进行的数据处理 
                //.....

                // 步骤3，调用delegate

                lightReturn handler = lightOffEvent;
                if (handler != null)
                {
                    handler(orderNo,eleId, color, eleAddress, count, num2);
                    CURRENT_PICK_STATUS[key] = true;
                }

            }

        }
        public static void displayLabels(int port)
        {
            if (elelab.unart_manage.com_manage[port] != null)
                elelab.unart_manage.com_manage[port].displayLabel();


        }
        public static void clearLabels(int port)
        {
            if (elelab.unart_manage.com_manage[port] != null)
                elelab.unart_manage.com_manage[port].clearLabel();

        }


        /// <summary>
        /// 熄灭指定端口标签
        /// 当熄灭端口所有标签时，熄灭端口的通道灯
        /// </summary>
        /// <param name="port">端口号</param>
        /// <param name="ltId">标签ID，默认熄灭全部标签</param>
        public static void turnOffLabel(int portNo, int ltId = 65535)
        {
            Model.dis_id id;
            id.order = 1;
            id.ele_id = ltId; //65535;
            id.state = 1;

            foreach (int port in activeComports)
            {
                if (port != portNo)
                {
                    continue;
                }

                unart_manage.com_manage[port].init_port.write_clear_comment(id);
                break;
            }

            /*
            if (ltId != 65535)  //当熄灭端口所有标签时，熄灭端口的通道灯
            {
                return;
            }
            
            id.order = 1;
            id.ele_id = ltId;// 65535;
            id.state = 1;


            foreach (int port in activeComports)
            {
                if (port == 0 || port != portNo)
                {
                    continue;
                }


                elelab.unart_manage.com_manage[port].init_port.write_clear_comment(id);

                if (!channalLights.ContainsKey(port))
                {
                    continue;
                }

                foreach (int lt in channalLights[port])
                {
                    Model.close_channel_led idx;
                    idx.channel_id = lt;
                    idx.state = 1;
                    elelab.unart_manage.com_manage[port].init_port.write_close_channel_led(idx);

                }
                break;
                // a.write_clear_comment(id);
            }
            */

        }
    }
}