package Engine

import (
	"LAPP_SJA_ME/conf"
	"LAPP_SJA_ME/utils"
	"LAPP_SJA_ME/web/middleware/glog"
	"LAPP_SJA_ME/web/models"
	"fmt"
	"net"
	"os/exec"
	"syscall"
	"time"
)

type Printer struct {
	PrinterId	string		// 打印机ID
	PrinterName string		// 打印机名
	PrinterType string		// 打印机类型，N=网络端口打印，L=文件打印
	Ip 			string		// 打印机IP地址
	Port 		int			// 打印机端口号
	Interval 	int			// 打印机打印间隔时间，单位：秒
	conn		net.Conn	// 打印机连接句柄
	InTaskChan chan models.PrintTask		// 任务接入管道
	Printertab models.Printertab			// 打印机信息
	printer syscall.Handle
}

// 创建打印机对象
func (p *Printer) Create(printertab models.Printertab){
	p.PrinterId = printertab.Printerid
	p.PrinterName = printertab.Printername
	p.PrinterType = printertab.Printertype
	p.Ip = printertab.Ipaddress
	p.Port = printertab.Port
	p.Interval = printertab.Printinterval

	p.Printertab = printertab
	p.InTaskChan = make(chan models.PrintTask, 1000)
}

// 输出打印任务到端口
// 打印任务是以ByteArray数组类型的文件行
func (p *Printer) printTaskBytesFile(bytesFile []models.ByteFile) error {
	var(
		err error
		bytesRow models.ByteFile
	)
	for _, bytesRow = range bytesFile {
		if _, err = p.conn.Write(bytesRow.ByteLine); err != nil {
			return err
		}
	}
	return nil
}

func (p *Printer) printTaskBytesRow(bytes []byte) error {
	var err error
	if _, err = p.conn.Write(bytes); err != nil {
		return err
	}
	return nil
}

func (p *Printer) getSocketAddress() string {
	return fmt.Sprintf("%s:%d", p.Ip, p.Port)
}

// 通过TCP打开端口
func (p *Printer) openSocket() error {
	var err error
	if p.conn, err = net.Dial("tcp", p.getSocketAddress()); err != nil {
		return err
	}
	return nil
}

// 关闭通信端口
func (p *Printer) closeSocket() error {
	return p.conn.Close()
}

// 通过端口打印
func (p *Printer) printBySocket(conf *conf.EnvConfig, saveChan chan models.PrintTask){
	var (
		t models.PrintTask
		err error
		bytesFile []models.ByteFile
	)

	// 从缓存队列的头部取出一个任务并输出打印
	for {
		t = <- p.InTaskChan
		if bytesFile, err = t.GenBytesFile(conf); err != nil {
			glog.InfoExtln("Printer","Failed to generate bytes for task : ", t)
			continue
		}
		if err = p.openSocket(); err != nil {
			glog.InfoExtln("Printer","Failed to open the socket: ", p.Ip, p.Port)
			time.Sleep(time.Duration(p.Interval) * time.Second)
			continue
		}
		if err = p.printTaskBytesFile(bytesFile); err != nil {
			glog.InfoExtln("Printer","Failed to print the content due to: ", err)
			continue
		}
		if err = p.closeSocket(); err != nil {
			glog.InfoExtln("Printer","Failed to close the socket due to: ", err)
			continue
		}
		// 将输出打印的任务输出到保存管道
		saveChan <- t
		if p.Interval > 0 {
			time.Sleep(time.Duration(p.Interval) * time.Second)
		}
	}
}

// 通过输出文件打印
func (p *Printer) printByFile(conf *conf.EnvConfig, saveChan chan models.PrintTask){
	var (
		t models.PrintTask
		err error
	)

	for {
		t = <- p.InTaskChan
		if err = t.GenPrintFile(conf); err != nil {
			glog.InfoExtln("Printer","printByFile: Failed to generate print file for task :  due to: ", t, err)
			continue
		}
		// 通过windows文件输出方式打印
		c := exec.Command("cmd", "/C", "COPY", "/B", t.TaskFile, p.PrinterName)
		if err = c.Run(); err != nil {
			glog.InfoExtln("Printer","PrintByFile: copy file to printer error: ", err)
			continue
		}

		saveChan <- t
		if p.Interval > 0 {
			time.Sleep(time.Duration(p.Interval) * time.Second)
		}
	}
}

func (p *Printer) printByExcel(conf *conf.EnvConfig, printChan chan models.PrintTask){
	var (
		t models.PrintTask
		err error
	)

	for {
		t = <- p.InTaskChan
		if err = t.GenExcelFile(conf); err != nil {
			glog.InfoExtln("Printer","printByFile: Failed to generate print file for task : due to: ", t, err)
			continue
		}

		// 通过windows文件输出方式打印
		printChan <- t
		if p.Interval > 0 {
			time.Sleep(time.Duration(p.Interval) * time.Second)
		}
	}
}

// 创建打印机对象
func CreatePrinter(printertab models.Printertab)(p *Printer){
	p = &Printer{}
	p.PrinterName = printertab.Printername
	p.PrinterType = printertab.Printertype
	p.Ip = printertab.Ipaddress
	p.Port = printertab.Port
	p.Interval = printertab.Printinterval

	p.Printertab = printertab
	p.InTaskChan = make(chan models.PrintTask, 1000)

	return p
}


// 启动打印机的打印服务
func StartPrinter(p *Printer, conf *conf.EnvConfig, printChan, outChan chan models.PrintTask){
	switch p.PrinterType{
	case "N":	// 网络端口打印
		go func (){
			p.printBySocket(conf, outChan)
		}()
	case "L":	// 输出文件打印
		go func(){
			p.printByFile(conf, outChan)
		}()
	case "E":	// Excel表单打印机
		go func(){
			p.printByExcel(conf, printChan)
		}()
	}
}

// 串行打印表单文件并输出到任务保存队列
func StartSheetSerialPrintService(prnDict map[string] *Printer,printChan, outChan chan models.PrintTask){
	var (
		prn *Printer
		t models.PrintTask
		err error
		ok bool
	)

	go func() {
		for {
			t = <-printChan
			if prn, ok = prnDict[t.PrinterId]; !ok{
				glog.InfoExtln("Printer","SheetPrintService: Task:  printer:  was not in the printer list.",t.TaskId, t.PrinterId)
				continue
			}
			// 通过windows文件输出方式打印
			utils.SetDefaultPrinter(prn.PrinterName,t.Printhead.Orientation)
			if err = utils.ShellExecute(0, "print", t.TaskFile, prn.PrinterName, ".", 0); err != nil {
				glog.InfoExtln("Printer","PrintExcelFile: failed to print the file:  due to: ", t.TaskFile, err)
				continue
			}
			outChan <- t
		}
	}()
}