using Microsoft.Win32.SafeHandles;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;

namespace PosDataTest
{
    public class PrintHelper
    {
        #region 打印机参数
        const uint GENERIC_READ = 0x80000000;
        const uint GENERIC_WRITE = 0x40000000;
        const uint FILE_ATTRIBUTE_NORMAL = 0x80;
        const int OPEN_EXISTING = 3;
        static string prnPort = "LPT1";
        [StructLayout(LayoutKind.Sequential)]
        private struct OVERLAPPED
        {
            int Internal;
            int InternalHigh;
            int Offset;
            int OffSetHigh;
            int hEvent;
        }
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        private static extern IntPtr CreateFile(string lpFileName, int dwDesiredAccess, int dwShareMode,
            int lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile);

        [DllImport("kernel32.dll ")]
        private static extern bool WriteFile(int hFile, byte[] lpBuffer, int nNumberOfBytesToWrite,
            ref int lpNumberOfBytesWritten, ref OVERLAPPED lpOverlapped);

        [DllImport("kernel32.dll ")]
        private static extern bool DefineDosDevice(int dwFlags, string lpDeviceName, string lpTargetPath);

        [DllImport("kernel32.dll ")]
        private static extern bool CloseHandle(int hObject);

        [DllImport("kernel32.dll ")]
        private static extern bool ReadFile(int hFile, byte[] lpBuffer, int nNumberOfBytesToRead,
            ref int lpNumberOfBytesRead, int lpOverlapped);
        #endregion

        #region 方法 -> LPT打印票据信息
        /// <summary>
        /// LPT打印票据信息
        /// </summary>
        /// <param name="PrintList">待打印内容列表</param>
        /// <param name="PrintCount">打印份数</param>
        /// <param name="PaperLine">票尾走纸行数</param>
        /// <param name="IsOpenBox">是否开钱箱</param>
        /// <returns></returns>
        public static bool PrintList(List<string> PrintList, int PrintCount = 1, int PaperLine = 6, bool IsOpenBox = true)
        {

            if (PrintList.Count == 0)
            {
                return false;
            }
            try
            {
                IntPtr iHandle = CreateFile(prnPort, 0x40000000, 0, 0, OPEN_EXISTING, 0, 0);
                using (SafeFileHandle _SafeFileHandle = new SafeFileHandle(iHandle, true))
                {
                    if (iHandle.ToInt32() == -1)
                    {
                        return false;
                    }
                    else
                    {
                        FileStream fs = new FileStream(_SafeFileHandle, FileAccess.ReadWrite);
                        StreamWriter sw = new StreamWriter(fs, Encoding.Default);
                        if (IsOpenBox)
                        {
                            char[] _open = { (char)27, (char)112, (char)0, (char)32, (char)160 };
                            byte[] _byte = Encoding.Default.GetBytes(_open);
                            fs.Write(_byte, 0, _byte.Length);
                        }
                        if (QualityHelper.paper_print == "1")
                        {
                            //重置行间距
                            char[] _default = { (char)27, (char)50 };
                            byte[] _bytedefault = Encoding.Default.GetBytes(_default);
                            fs.Write(_bytedefault, 0, _bytedefault.Length);
                            //取消字体倍数
                            char[] _default1 = { (char)27, (char)33 };
                            byte[] _bytedefault1 = Encoding.Default.GetBytes(_default);
                            fs.Write(_bytedefault1, 0, _bytedefault1.Length);
                            for (int p = 0; p < PrintCount; p++)
                            {
                                foreach (string _strPrint in PrintList)
                                {
                                    sw.Write(_strPrint + "\n");
                                }
                                for (int i = 0; i < PaperLine; i++)
                                {
                                    sw.Write("\n");
                                }
                            }
                        }
                        sw.Close();
                        fs.Close();
                    }
                    return true;
                }
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// LPT打印机开钱箱
        /// </summary>
        /// <returns></returns>
        public static bool LptOpenBox()
        {
            try
            {
                IntPtr iHandle = CreateFile(prnPort, 0x40000000, 0, 0, OPEN_EXISTING, 0, 0);
                using (SafeFileHandle _SafeFileHandle = new SafeFileHandle(iHandle, true))
                {
                    if (iHandle.ToInt32() == -1)
                    {
                        return false;
                    }
                    else
                    {
                        FileStream fs = new FileStream(_SafeFileHandle, FileAccess.ReadWrite);
                        StreamWriter sw = new StreamWriter(fs, Encoding.Default);

                        char[] _open = { (char)27, (char)112, (char)0, (char)32, (char)160 };
                        byte[] _byte = Encoding.Default.GetBytes(_open);
                        fs.Write(_byte, 0, _byte.Length);

                        sw.Close();
                        fs.Close();
                    }
                    return true;
                }
            }
            catch
            {
                return false;
            }
        }
        #endregion

        #region 方法 -> 生成两侧对齐行
        /// <summary>
        /// 生成两侧对齐行
        /// </summary>
        /// <param name="leftString">左侧字符字符串</param>
        /// <param name="rightString">右侧字符串</param>
        /// <param name="paddingChar">填充的字符</param>
        /// <param name="lineLength">行长度</param>
        /// <returns></returns>
        public static string CreateSideLine(string leftString, string rightString, char paddingChar = ' ', int lineLength = 32)
        {
            try
            {
                int i_Len = lineLength - StringLength(leftString) - StringLength(rightString);
                return leftString + rightString.PadLeft(i_Len + rightString.Length, paddingChar);
            }
            catch
            {
                return leftString + rightString;
            }
        }
        #endregion

        #region 方法 -> 生成居中行
        /// <summary>
        /// 生成居中对齐行
        /// </summary>
        /// <param name="centerString">居中字符串</param>
        /// <param name="paddingChar">填充的字符</param>
        /// <param name="lineLength">行长度</param>
        /// <returns></returns>
        public static string CreateCenterLine(string centerString, char paddingChar = ' ', int lineLength = 32)
        {
            try
            {
                int i_Len = (lineLength - StringLength(centerString)) / 2;
                return centerString.PadLeft(i_Len + centerString.Length, paddingChar);
            }
            catch
            {
                return centerString;
            }
        }
        #endregion

        #region 方法 -> 生成左对齐行
        /// <summary>
        /// 生成左对齐行
        /// </summary>
        /// <param name="leftString">需要左对齐的文本</param>
        /// <param name="paddingChar">填充的字符</param>
        /// <param name="lineLength">单行字符字节长度</param>
        /// <returns></returns>
        public static string CreateLeftLine(string leftString, char paddingChar = ' ', int lineLength = 32)
        {
            try
            {
                int i_Len = lineLength - StringLength(leftString);
                return leftString.PadRight(i_Len + leftString.Length, paddingChar);
            }
            catch
            {
                return leftString;
            }
        }
        #endregion

        #region 方法 -> 生成右对齐行
        /// <summary>
        /// 生成右对齐行
        /// </summary>
        /// <param name="rightString">需要右对齐的文本</param>
        /// <param name="paddingChar">填充的字符</param>
        /// <param name="lineLength">单行字符字节长度</param>
        /// <returns></returns>
        public static string CreateRightLine(string rightString, char paddingChar = ' ', int lineLength = 32)
        {
            try
            {
                int i_Len = lineLength - StringLength(rightString);
                return rightString.PadLeft(i_Len + rightString.Length, paddingChar);
            }
            catch
            {
                return rightString;
            }
        }
        #endregion

        #region 方法 -> 计算字符串字节长度
        /// <summary>
        /// 计算字符串字节长度
        /// </summary>
        /// <param name="calculateString">待计算字符串</param>
        /// <returns></returns>
        private static int StringLength(string calculateString)
        {
            if (string.IsNullOrEmpty(calculateString))
            {
                return 0;
            }
            //计算得到该字符串对应单字节字符串的长度  
            return Regex.Replace(calculateString, @"[^\x00-\xff]", "aa").Length;
        }
        #endregion

    }
}