package serial

import (
	"time"

	"go.bug.st/serial"
)

type Mode serial.Mode

const (
	PARATY_NONE  = serial.NoParity
	PARATY_ODD   = serial.OddParity
	PARATY_EVEN  = serial.EvenParity
	PARATY_MARK  = serial.MarkParity
	PARATY_SPACE = serial.SpaceParity

	STOP_1  = serial.OneStopBit
	STOP_15 = serial.OnePointFiveStopBits
	STOP_2  = serial.TwoStopBits
)

var ModeDef = &serial.Mode{
	BaudRate: 115200,
	DataBits: 8,
	Parity:   PARATY_NONE,
	StopBits: STOP_1,
}

func GetComList() []string {
	list, err := serial.GetPortsList()
	if err != nil {
		return list
	}
	return list
}

type SerialPort struct {
	p    serial.Port
	flag bool
}

func OpenSerial(com string, conf *serial.Mode) (SerialPort, error) {
	var p serial.Port
	var err error
	s := SerialPort{}
	s.flag = false
	index := 5 //重复打开串口5次
	p, err = serial.Open(com, conf)
	// 打开串口失败，重新打开
	if err != nil {
		for i := 0; i < index; i++ {
			time.Sleep(time.Millisecond)
			p, err = serial.Open(com, conf)
			if err == nil {
				s.flag = true
				break
			} else {
			}
		}
	} else {
		s.flag = true
	}
	if !s.flag {
		return s, err
	}
	p.SetReadTimeout(time.Millisecond * 100)
	s.p = p
	return s, nil
}

func CheckCom(com string) bool {
	s ,_:= OpenSerial(com, ModeDef)
	if s.flag {
		s.Close()
		return true
	} else {
		return false
	}
}
func (s *SerialPort) GetPort() serial.Port {
	return s.p
}
func (s *SerialPort) GetFlag() bool {
	return s.flag
}
func (s *SerialPort) SetFlag(flag bool) {
	s.flag = flag
}
func (s *SerialPort) Read(buf []byte) (n int, err error) {
	n, err = s.p.Read(buf)
	if err != nil {
		s.Close()
	}
	return
}

func (s *SerialPort) ReadString() string {
	var buf = make([]byte, 1024)
	n, err := s.p.Read(buf)
	if err != nil {
		return ""
	}
	str := string(buf[0:n])
	return str
}

func (s *SerialPort) Write(buf []byte) (n int, err error) {
	n, err = s.p.Write(buf)
	return
}

func (s *SerialPort) WriteString(str string) bool {
	_, err := s.p.Write([]byte(str))
	return err == nil
}
func try() {
	if err := recover(); err != nil {
	}
}
func (s *SerialPort) Close() bool {
	defer try()
	s.flag = false
	if err := s.p.Close(); err != nil {

		return false
	}
	return true
}

func (s *SerialPort) ResetReadBuff() bool {
	if err := s.p.ResetOutputBuffer(); err != nil {
		return false
	} else {
		return true
	}
}