package FlyModbusSlaves

import (
	"bytes"
	"encoding/binary"
	"errors"

	"gitee.com/flyiot/flylibs/FlyJSON"
	"gitee.com/flyiot/flylibs/FlyModbusSlaves/mbserver"
	"gitee.com/flyiot/flylibs/FlySerials"
)

type FlyModbusSlave struct {
	IsRunning bool
	Settings  *FlyModbusSlaveSettings
	Serv      *mbserver.Server
	Serial    *FlySerials.FlySerial
}

func NewFlyModbusSlave() *FlyModbusSlave {
	s := FlyModbusSlave{}
	s.Settings = NewFlyModbusSlaveSettings()
	s.Serv = mbserver.NewServer()
	return &s
}

func (s *FlyModbusSlave) Open(settings *FlyModbusSlaveSettings) error {
	s.LoadSettings(settings)
	return s.Start()
}

func (s *FlyModbusSlave) LoadSettings(settings *FlyModbusSlaveSettings) {
	s.Settings = settings
}

// 启动服务
func (s *FlyModbusSlave) Start() error {
	if s.IsRunning {
		return errors.New("running")
	}
	if !s.Settings.Ready {
		return errors.New("settings error")
	}
	if !s.Settings.Enable {
		return errors.New("not enable")
	}

	s.Serv.Debug = s.Settings.Debug
	s.Serv.SetID(uint8(s.Settings.SlaveID))

	if s.Settings.EnableTcp {
		// fmt.Println(s.Settings.TcpAddr)
		err := s.Serv.ListenTCP(s.Settings.TcpAddr)
		if err != nil {
			return err
		}
	}

	if s.Settings.EnableSerial {
		serialSettings := FlySerials.NewFlySerialSettings()
		FlyJSON.ObjectCopy(s.Settings, &serialSettings)
		serialSettings.LoopDisable = true

		s.Serial = FlySerials.NewFlySerial()
		port, err := s.Serial.Open(serialSettings)
		if err != nil {
			return err
		}
		err = s.Serv.ListenSerial(port)
		if err != nil {
			return err
		}
	}

	s.IsRunning = true
	return nil
}

// 获取串口配置名称
func (s *FlyModbusSlave) GetName() string {
	return s.Settings.ConfigKey
}

func (s *FlyModbusSlave) Close() {
	s.Serv.Close()
}
func (s *FlyModbusSlave) Stop() {
	s.Close()
}

func (s *FlyModbusSlave) checkAddr(addr int) int {
	return addr
}

func (s *FlyModbusSlave) GetInt16(addr int) (int16, error) {
	b, err := s.GetBytes(addr, 1)
	if err != nil {
		return 0, err
	}
	return s.BytesToInt16(b), nil
}

func (s *FlyModbusSlave) SetInt16(addr int, value int16) error {

	b := s.Int16ToBytes(value)
	return s.SetBytes(addr, b)
}

func (s *FlyModbusSlave) GetInt32(addr int) (int32, error) {

	b, err := s.GetBytes(addr, 2)
	if err != nil {
		return 0, err
	}
	return s.BytesToInt32(b), nil
}

func (s *FlyModbusSlave) SetInt32(addr int, value int32) error {
	// fmt.Println("SetInt32", addr, value)
	b := s.Int32ToBytes(value)
	return s.SetBytes(addr, b)
}

func (s *FlyModbusSlave) GetInt64(addr int) (int64, error) {
	b, err := s.GetBytes(addr, 4)
	if err != nil {
		return 0, err
	}
	return s.BytesToInt64(b), nil
}

func (s *FlyModbusSlave) SetInt64(addr int, value int64) error {
	b := s.Int64ToBytes(value)
	return s.SetBytes(addr, b)
}

func (s *FlyModbusSlave) GetFloat32(addr int) (float32, error) {
	b, err := s.GetBytes(addr, 2)
	if err != nil {
		return 0, err
	}
	return s.BytesToFloat32(b), nil
}

func (s *FlyModbusSlave) SetFloat32(addr int, value float32) error {
	b := s.Float32ToBytes(value)
	return s.SetBytes(addr, b)
}

func (s *FlyModbusSlave) GetFloat64(addr int) (float64, error) {
	b, err := s.GetBytes(addr, 2)
	if err != nil {
		return 0, err
	}
	return s.BytesToFloat64(b), nil
}

func (s *FlyModbusSlave) SetFloat64(addr int, value float64) error {
	b := s.Float64ToBytes(value)
	return s.SetBytes(addr, b)
}

// func (s *FlyModbusSlave) SetBytes(addr int, value []byte) error {
// 	addr = s.checkAddr(addr)

// 	b := mbserver.BytesToUint16(value)
// 	count := len(b)
// 	// fmt.Println("SetBytes", addr, count, b)

//		if addr+count >= 65535 {
//			return errors.New("overflow")
//		}
//		for i := 0; i < count; i++ {
//			s.Serv.HoldingRegisters[addr+i] = b[i]
//		}
//		return nil
//	}
func (s *FlyModbusSlave) SetBytes(addr int, value []byte) error {
	addr = s.checkAddr(addr)

	// 如果字节数组长度为奇数，补0使其变为偶数
	if len(value)%2 != 0 {
		value = append(value, 0)
	}

	b := mbserver.BytesToUint16(value)
	count := len(b)
	// fmt.Println("SetBytes", addr, count, b)

	addr_l := addr
	addr_h := addr
	if s.Settings.MirrorAddress != 0 {
		if addr_l >= s.Settings.MirrorAddress {
			addr_l = addr_l - s.Settings.MirrorAddress
		}
		if addr_h < s.Settings.MirrorAddress {
			addr_h = addr_h + s.Settings.MirrorAddress
		}
	}

	if addr_h+count >= 65535 {
		return errors.New("overflow")
	}
	for i := 0; i < count; i++ {
		s.Serv.HoldingRegisters[addr_l+i] = b[i]
		if addr_l != addr_h {
			s.Serv.HoldingRegisters[addr_h+i] = b[i]
		}
	}
	return nil
}
func (s *FlyModbusSlave) GetBytes(addr int, n int) ([]byte, error) {
	addr = s.checkAddr(addr)

	addr_l := addr
	if s.Settings.MirrorAddress != 0 {
		if addr_l >= s.Settings.MirrorAddress {
			addr_l = addr_l - s.Settings.MirrorAddress
		}
	}

	if addr_l+n >= 65535 {
		return []byte{}, errors.New("overflow")
	}
	return mbserver.Uint16ToBytes(s.Serv.HoldingRegisters[addr_l : addr_l+n]), nil
}

// 整形转换成字节
func (s *FlyModbusSlave) Int32ToBytes(n int32) []byte {
	x := int32(n)
	bytesBuffer := bytes.NewBuffer([]byte{})
	binary.Write(bytesBuffer, binary.BigEndian, x)
	return bytesBuffer.Bytes()
}

// 字节转换成整形
func (s *FlyModbusSlave) BytesToInt32(b []byte) int32 {
	bytesBuffer := bytes.NewBuffer(b)
	var x int32
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return x
}

func (s *FlyModbusSlave) BytesToInt16(b []byte) int16 {
	bytesBuffer := bytes.NewBuffer(b)
	var x int16
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return x
}

func (s *FlyModbusSlave) Int16ToBytes(n int16) []byte {
	x := int16(n)
	bytesBuffer := bytes.NewBuffer([]byte{})
	binary.Write(bytesBuffer, binary.BigEndian, x)
	return bytesBuffer.Bytes()
}

func (s *FlyModbusSlave) BytesToInt64(b []byte) int64 {
	bytesBuffer := bytes.NewBuffer(b)
	var x int64
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return x
}

func (s *FlyModbusSlave) Int64ToBytes(n int64) []byte {
	x := int64(n)
	bytesBuffer := bytes.NewBuffer([]byte{})
	binary.Write(bytesBuffer, binary.BigEndian, x)
	return bytesBuffer.Bytes()
}

func (s *FlyModbusSlave) BytesToFloat32(b []byte) float32 {
	bytesBuffer := bytes.NewBuffer(b)
	var x float32
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return x
}

func (s *FlyModbusSlave) Float32ToBytes(n float32) []byte {
	x := float32(n)
	bytesBuffer := bytes.NewBuffer([]byte{})
	binary.Write(bytesBuffer, binary.BigEndian, x)
	return bytesBuffer.Bytes()
}

func (s *FlyModbusSlave) BytesToFloat64(b []byte) float64 {
	bytesBuffer := bytes.NewBuffer(b)
	var x float64
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return x
}

func (s *FlyModbusSlave) Float64ToBytes(n float64) []byte {
	x := float64(n)
	bytesBuffer := bytes.NewBuffer([]byte{})
	binary.Write(bytesBuffer, binary.BigEndian, x)
	return bytesBuffer.Bytes()
}