using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Graphics;
using Zebra.Sdk.Printer;
using Zebra.Sdk.Printer.Discovery;

namespace ZebraPrinterHelper
{
    public class ZebraManger
    {
        ConnectionType ConnectionType;
        string ConnectionEndpoint;
        public int PrinterDPI = 203;
        /// <summary>
        /// 初始化打印机设置
        /// </summary>
        /// <param name="endpoint">连接地址</param>
        /// <param name="connectionType">连接类型</param>
        public ZebraManger(string endpoint, ConnectionType connectionType)
        {
            ConnectionEndpoint = endpoint;
            ConnectionType = connectionType;
        }
        Connection printerConnection = null;
        ZebraPrinter printer;
        Connection GetConnection()
        {
            if (ConnectionType == ConnectionType.Network)
            {
                try
                {
                    int port = 9100;
                    return new TcpConnection(ConnectionEndpoint, port);
                }
                catch (Exception e)
                {
                    throw new ConnectionException(e.Message, e);
                }
            }
            else if (ConnectionType == ConnectionType.UsbDirect)
            {
                try
                {
                    if (string.IsNullOrEmpty(ConnectionEndpoint))
                    {

                        var dl = GetUsbDirectAddress();
                        if (dl.Count == 0)
                        {
                            new Exception("没有找到打印机");
                        }
                        ConnectionEndpoint = dl.First().Key;
                    }
                    return new UsbConnection(ConnectionEndpoint);
                }
                catch (Exception e)
                {
                    throw new ConnectionException(e.Message, e);
                }
            }
            else if (ConnectionType == ConnectionType.USB)
            {
                return new DriverPrinterConnection(ConnectionEndpoint);
            }
            else
            {
                try
                {
                    return new BluetoothConnection(ConnectionEndpoint);
                }
                catch (Exception e)
                {
                    throw new ConnectionException(e.Message, e);
                }
            }
        }
        /// <summary>
        /// 连接打印机
        /// </summary>
        /// <param name="msg">错误消息</param>
        /// <returns>是否成功</returns>
        public bool Connection(out string msg)
        {
            msg = "";
            try
            {
                printerConnection = GetConnection();
                printerConnection.Open();
                PrinterDPI = GetPrinterDPI();
                printer = ZebraPrinterFactory.GetInstance(printerConnection);
                return true;
            }
            catch (ConnectionException e)
            {
                msg = "Connection Error:" + e.Message;
            }
            catch (ZebraPrinterLanguageUnknownException e)
            {
                msg = "Connection Error:" + e.Message;
            }
            catch (IOException e)
            {
                msg = "Image Error" + e.Message;
            }
            catch (ZebraIllegalArgumentException e)
            {
                msg = "Illegal Arguments" + e.Message;
            }
            catch (ArgumentException e)
            {
                msg = "Invalid File Path" + e.Message;
            }
            finally
            {

            }
            return false;
        }
        /// <summary>
        /// 关闭打印机连接
        /// </summary>
        public void Close()
        {
            try
            {
                if (printerConnection != null)
                {
                    printerConnection.Close();
                    printerConnection = null;
                }
            }
            catch (ConnectionException)
            {
            }
            finally
            {

            }
        }
        ~ZebraManger()
        {
            Close();
        }
        /// <summary>
        /// 打印图像
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="msg">错误消息</param>
        /// <returns></returns>
        public bool PrintImage(Bitmap bmp, out string msg) {
            return PrintImage(bmp, out msg, true);
        }
        /// <summary>
        /// 打印图像
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="msg">错误消息</param>
        /// <param name="checkPeeler">是否检查剥离器</param>
        /// <returns>是否成功</returns>
        public bool PrintImage(Bitmap bmp, out string msg,bool checkPeeler)
        {
            if (!CheckAndGetStatus(out PrinterStatus status, out msg))
                return false;
            if (status.labelsRemainingInBatch > 0)
                CancelAll();

            if (!status.isReadyToPrint)
            {
                string[] printerStatusString = new PrinterStatusMessages(status).GetStatusMessage();

                msg = string.Join("\r\n", printerStatusString);
                return false;
            }
            if (checkPeeler && IsLabelOnPeeler)
            {
                msg = "上一个标签尚未移走";
                return false;
            }

            try
            {
                //var width = bmp.Width * ((double)PrinterDPI / 300);
                //var height = bmp.Height * ((double)PrinterDPI / 300);
                //var db = GetReducedImage(bmp, (int)width, (int)height);
                //db.Save("temp.bmp");
                ZebraImageI image = ZebraImageFactory.GetImage(bmp);
                printer.PrintImage(image, 0, 0, (int)bmp.Width, (int)bmp.Height, false);
                return true;
            }
            catch (ConnectionException e)
            {
                msg = "Connection Error:" + e.ToString();
            }
            catch (ZebraPrinterLanguageUnknownException e)
            {
                msg = "Language Unknown:" + e.ToString();
            }
            catch (IOException e)
            {
                msg = "Image Error" + e.ToString();
            }
            catch (ZebraIllegalArgumentException e)
            {
                msg = "Illegal Arguments" + e.ToString();
            }
            catch (ArgumentException e)
            {
                msg = "Invalid File Path" + e.ToString();
            }
            finally
            {

            }
            return false;
        }
        bool CheckAndGetStatus(out PrinterStatus status, out string msg)
        {
            msg = "";
            status = null;
            int ReTryCount = 0;
        ReTry:
            if (printerConnection == null || !printerConnection.Connected)
            {
                if (!Connection(out string m))
                {
                    msg = m;
                    return false;
                }
            }
            status = GetStatus();
            if (status == null)
            {
                Close();
                ReTryCount++;
                if (ReTryCount > 3)
                {
                    msg = "连接打印机失败";
                    return false;
                }
                goto ReTry;
            }
            ReTryCount = 0;
            if (status.isPaused)
            {
                PrintStartMode();
                ReTryCount++;
                if (ReTryCount > 2)
                {
                    msg = "暂停状态无法解除";
                    return false;
                }
                goto ReTry;
            }
            return true;
        }
        /// <summary>
        /// 检测标签有没有被取走.
        /// 只在打印任务后可以检测 
        /// 发出打印指令后需等待打印完成约需要1秒才能检测到
        /// </summary>
        public bool IsLabelOnPeeler
        {
            get
            {
                try
                {
                    string d = "! U1 getvar \"sensor.peeler\"\n";
                    var b = Encoding.ASCII.GetBytes(d);
                    var rd = printerConnection.SendAndWaitForResponse(b, 5000, 500, null);
                    var rs = Encoding.ASCII.GetString(rd);
                    //log("sensor.peeler" + rs);
                    return rs.IndexOf("not clear") > -1;
                }
                catch
                {
                    return false;
                }
            }
        }
        /// <summary>
        /// 获取打印机打印精度DPI
        /// </summary>
        /// <returns></returns>
        public int GetPrinterDPI()
        {

            string d = "! U1 getvar \"head.resolution.in_dpi\"\n";
            var b = Encoding.ASCII.GetBytes(d);
            var rd = printerConnection.SendAndWaitForResponse(b, 5000, 500, null);
            var rs = Encoding.ASCII.GetString(rd);
            if (rs.Length > 0)
            {
                rs = rs.Trim('\"');
                return int.Parse(rs);
            }
            else
            {
                throw new ZebraPrinterLanguageUnknownException("Get DPI Error!");
            }
            return 203;

        }
        /// <summary>
        /// 取消所有任务
        /// </summary>
        public void CancelAll()
        {
            try
            {
                string d = "~JA\n";
                var b = Encoding.ASCII.GetBytes(d);
                printerConnection.Write(b);
            }
            catch
            {
            }
        }
        /// <summary>
        /// 写入ZPL指令
        /// </summary>
        /// <param name="zplcommand"></param>
        public void WriteZPL(string zplcommand)
        {
            var b = Encoding.ASCII.GetBytes(zplcommand);
            printerConnection.Write(b);
        }
        /// <summary>
        /// 打印机暂停模式
        /// </summary>
        public void PauseMode()
        {
            try
            {
                string d = "~PP\n";
                var b = Encoding.ASCII.GetBytes(d);
                printerConnection.Write(b);
            }
            catch
            {
            }
        }
        /// <summary>
        /// 从暂停模式恢复到正常模式
        /// </summary>
        public void PrintStartMode()
        {
            string d = "~PS\n";
            var b = Encoding.ASCII.GetBytes(d);
            printerConnection.Write(b);
        }
        public bool IsPrinterReady(out string msg)
        {
            msg = "";
            var status = GetStatus();
            string[] printerStatusString = new PrinterStatusMessages(status).GetStatusMessage();

            if (printerStatusString.Length > 0)
            {
                msg = string.Join("\r\n", printerStatusString);
                return false;
            }
            if (status.numberOfFormatsInReceiveBuffer > 0)
            {
                msg = "打印机缓冲池内有未打印文档";
                return false;
            }
            return true;
        }
        /// <summary>
        /// 获取打印机状态
        /// </summary>
        /// <returns></returns>
        public PrinterStatus GetStatus()
        {
            if (printerConnection == null || !printerConnection.Connected)
            {
                if (!Connection(out string m))
                {
                    //msg = m;
                    //return false;
                }
            }
            try
            {
                return printer.GetCurrentStatus();
                //ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(printer);
                //return (linkOsPrinter != null) ? linkOsPrinter.GetCurrentStatus() : printer.GetCurrentStatus();
            }
            catch
            {
                return null;
            }
        }
        public static Dictionary<string, Dictionary<string, string>> GetUsbDirectAddress()
        {
            var devicelist = new Dictionary<string, Dictionary<string, string>>();
            foreach (DiscoveredUsbPrinter printer in UsbDiscoverer.GetZebraUsbPrinters(new ZebraPrinterFilter()))
            {
                devicelist[printer.Address] = printer.DiscoveryDataMap;
            }
            return devicelist;
        }
        private Image GetReducedImage(Image resourceImage, int width, int height)
        {
            try
            {
                Image data = null;
                //用指定的大小和格式初始化Bitmap类的新实例 
                using (Bitmap bitmap = new Bitmap(width, height, resourceImage.PixelFormat))
                {
                    //从指定的Image对象创建新Graphics对象 
                    using (Graphics graphics = Graphics.FromImage(bitmap))
                    {
                        //清除整个绘图面并以透明背景色填充 
                        //graphics.Clear(Color.Transparent);
                        //在指定位置并且按指定大小绘制原图片对象
                        graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
                        //graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.Low;
                        graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.None;
                        graphics.DrawImage(resourceImage, new Rectangle(0, 0, width, height));
                    }
                    data = new Bitmap(bitmap);
                }
                return data;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
    }


    public enum ConnectionType
    {

        [Description("Network")]
        Network,

        [Description("USB")]
        USB,

        [Description("USB Direct")]
        UsbDirect,

        [Description("Bluetooth")]
        Bluetooth
    }
}