package meshcore

import (
	"errors"
	"io"

	"git.maze.io/go/ham/protocol"
	"git.maze.io/go/ham/radio"
)

const (
	maxCompanionFrameSize = 172
)

// Node can be any type of MeshCore node.
type Node struct {
	OnPacket (*Packet)

	driver nodeDriver
}

// NewCompanion connects to a companion device type (over serial, TCP or BLE).
func NewCompanion(conn io.ReadWriteCloser) (*Node, error) {
	driver := newCompanionDriver(conn)

	if err := driver.Setup(); err != nil {
		return nil, err
	}

	return &Node{
		driver: driver,
	}, nil
}

func NewRepeater(conn io.ReadWriteCloser, hasSNR bool) (*Node, error) {
	driver := newRepeaterDriver(conn, hasSNR)

	if err := driver.Setup(); err != nil {
		return nil, err
	}

	return &Node{
		driver: driver,
	}, nil
}

func (dev *Node) Close() error {
	return dev.driver.Close()
}

func (dev *Node) Packets() <-chan *Packet {
	return dev.driver.Packets()
}

func (dev *Node) RawPackets() <-chan *protocol.Packet {
	return dev.driver.RawPackets()
}

func (dev *Node) Info() *radio.Info {
	return dev.driver.Info()
}

func (dev *Node) Stats() map[string]any {
	return dev.driver.Stats()
}

func (dev *Node) Trace(path []byte) (snr []float64, err error) {
	if tracer, ok := dev.driver.(nodeTracer); ok {
		return tracer.Trace(path)
	}
	return nil, errors.New("meshcore: node doesn't support running traces")
}

type nodeDriver interface {
	radio.Device
	protocol.PacketReceiver

	Setup() error

	Packets() <-chan *Packet
	Stats() map[string]any
}

type nodeTracer interface {
	Trace(path []byte) (snr []float64, err error)
}

var (
	_ protocol.PacketReceiver = (*Node)(nil)
	_ nodeDriver              = (*companionDriver)(nil)
)