package dinet

import (
	"errors"
	"time"

	"src.dualinventive.com/go/dinet/rpc"
)

// Transport is the type of Transport to encode/decode rpc messages
type Transport int

const (
	// TransportLowlevel is the Transport for encoding/decoding low level messages
	TransportLowlevel Transport = iota
	// TransportZmq is the Transport for encoding/decoding Zmq messages
	TransportZmq
	// TransportTest is a test-transport used for testing DI-Net connections
	TransportTest
)

// Reader interface allows reading of RPC messages
type Reader interface {
	Recv() (*rpc.Msg, error)
}

// Writer interface allows writing RPC messages
type Writer interface {
	Send(*rpc.Msg) error
}

// Closer interface allows closing the RPC interface
type Closer interface {
	Close() error
}

// ReadCloser implements the Reader and Closer interface
type ReadCloser interface {
	Reader
	Closer
}

// WriteCloser implements the Writer and Closer interface
type WriteCloser interface {
	Writer
	Closer
}

// ReadWriter implements the Reader and Writer interface
type ReadWriter interface {
	Reader
	Writer
}

// ReadWriteCloser implements the Reader, Writer and Closer interface
type ReadWriteCloser interface {
	Reader
	Writer
	Closer
}

// Conn is a DI-Net connection, reading/writing RPC messages via different transports
type Conn interface {
	ReadWriteCloser
	Connect(string) error
	Reconnect() error

	SetTimeout(timeout time.Duration) error
}

// DeviceConn is a DI-Net connection which provides an interface for device abstraction
type DeviceConn interface {
	Conn
	DeviceHandshake(string) error
	DeviceRegister(string) error
	DeviceUnregister(string) error
}

// Compile-time interface validation
var _ DeviceConn = &LowLevelTransport{}
var _ DeviceConn = &TestTransport{}
var _ Conn = &ZmqTransport{}

// NewConn creates a new connection based on the given Transport
func NewConn(enc Transport) (Conn, error) {
	switch enc {
	case TransportTest:
		return &TestTransport{}, nil
	case TransportLowlevel:
		return &LowLevelTransport{}, nil
	case TransportZmq:
		return &ZmqTransport{timeout: ZmqTransportTimeoutInfinite}, nil
	}
	return nil, errors.New("not supported")
}

// NewDeviceConn creates a new device-based connection based on the given Transport
func NewDeviceConn(enc Transport) (DeviceConn, error) {
	switch enc {
	case TransportLowlevel:
		return &LowLevelTransport{}, nil
	case TransportTest:
		return &TestTransport{}, nil
	}
	return nil, errors.New("not supported")
}