package om

import (
	"fmt"
	"net"
	"time"
)

// Client 定义OM客户端的数据结构
type Client struct {
	port     int
	host     string
	addr     string
	cert     string
	conn     net.Conn
	codec    Codec
	rtimeout time.Duration
	wtimeout time.Duration
}

var (
	DefaultPort = 20300

	DefaultReadTimeout  = 5
	DefaultWriteTimeout = 5
)

// NewClient 创建一个OM客户端
func NewClient(host string) *Client {
	return &Client{
		port:     DefaultPort,
		host:     host,
		addr:     fmt.Sprintf("%s:%d", host, DefaultPort),
		cert:     DefaultCert,
		codec:    Codec{},
		rtimeout: time.Second * time.Duration(DefaultReadTimeout),
		wtimeout: time.Second * time.Duration(DefaultWriteTimeout),
	}
}

// WithPort 指定OM连接的端口
func (own *Client) WithPort(port int) *Client {
	own.port = port
	own.addr = fmt.Sprintf("%s:%d", own.host, port)
	return own
}

// WithCertificate 设置OM连接的认证证书
func (own *Client) WithCertificate(cert string) *Client {
	own.cert = cert
	return own
}

// WithReadTimeout 设置OM连接的读超时时间
func (own *Client) WithReadTimeout(timeout int) *Client {
	own.rtimeout = time.Second * time.Duration(timeout)
	return own
}

// WithWriteTimeout 设置OM连接的写超时时间
func (own *Client) WithWriteTimeout(timeout int) *Client {
	own.wtimeout = time.Second * time.Duration(timeout)
	return own
}

// ConnectAndAuth 连接并认证
func (own *Client) ConnectAndAuth() (err error) {
	// 连接设备
	if own.conn, err = net.Dial("tcp", own.addr); err != nil {
		return err
	}

	// 连接认证
	_, err = own.Send(NewCertficateRequest().SET(own.cert))
	return err
}

// GET 发起 OM 请求
func (own *Client) Send(req Requester) (Responser, error) {
	if req == nil {
		return nil, fmt.Errorf("[OM] nil request")
	} else if own.conn == nil {
		return nil, fmt.Errorf("[OM] nil connection")
	} else if err := req.Validate(); err != nil {
		return nil, err
	}

	return own.handle(req)
}

// Execute 执行 OM 指令
func (own *Client) Execute(cmd any) (Responser, error) {
	if cmd == nil {
		return nil, fmt.Errorf("[OM] nil instruction")
	} else if own.conn == nil {
		return nil, fmt.Errorf("[OM] nil connection")
	}

	return own.handle(cmd)
}

// handle 处理 OM 请求
func (own *Client) handle(req any) (Responser, error) {
	// 对请求数据进行编码
	data, err := own.codec.Encode(req)
	if err != nil {
		return nil, err
	}

	// 发送请求
	own.conn.SetWriteDeadline(time.Now().Add(own.wtimeout))
	if _, err := own.conn.Write(data); err != nil {
		return nil, fmt.Errorf("[OM] send request error: %v", err)
	}

	// 接收响应
	own.conn.SetReadDeadline(time.Now().Add(own.rtimeout))
	res, err := own.codec.Decode(own.conn)
	if err != nil {
		return nil, err
	}

	return newResponse(res)
}

// Close 关闭OM客户端
func (own *Client) Close() error {
	return own.conn.Close()
}