package client

import (
	"bytes"
	"fmt"
	"io"
	"net"
	"syscall"
	"time"

	"golang.org/x/sys/unix"
)

const PicomapPort = 28781

type udpTransport struct {
	conn      *net.UDPConn
	addr      *net.UDPAddr
	broadcast bool
	buf       bytes.Buffer
}

func interfaceIPv4Net(name string) (net.IP, *net.IPNet, error) {
	ifi, err := net.InterfaceByName(name)
	if err != nil {
		return nil, nil, fmt.Errorf("interface %s: %w", name, err)
	}
	addrs, err := ifi.Addrs()
	if err != nil {
		return nil, nil, fmt.Errorf("interface %s addrs: %w", name, err)
	}
	for _, a := range addrs {
		if ipnet, ok := a.(*net.IPNet); ok {
			if ip4 := ipnet.IP.To4(); ip4 != nil {
				return ip4, ipnet, nil
			}
		}
	}
	return nil, nil, fmt.Errorf("interface %s has no IPv4 address", name)
}

func broadcastAddr(ip net.IP, mask net.IPMask) net.IP {
	bcast := make(net.IP, 4)
	ip4 := ip.To4()
	for i := range 4 {
		bcast[i] = ip4[i] | ^mask[i]
	}
	return bcast
}

func InterfaceBroadcast(name string) (string, error) {
	ip, ipnet, err := interfaceIPv4Net(name)
	if err != nil {
		return "", err
	}
	return broadcastAddr(ip, ipnet.Mask).String(), nil
}

func enableBroadcast(conn *net.UDPConn) error {
	raw, err := conn.SyscallConn()
	if err != nil {
		return fmt.Errorf("syscall conn: %w", err)
	}
	var serr error
	raw.Control(func(fd uintptr) {
		serr = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_BROADCAST, 1)
	})
	return serr
}

func isInterfaceBroadcast(iface string, ip net.IP) bool {
	if iface == "" {
		return false
	}
	localIP, ipnet, err := interfaceIPv4Net(iface)
	if err != nil {
		return false
	}
	return ip.Equal(broadcastAddr(localIP, ipnet.Mask)) || ip.Equal(net.IPv4bcast)
}

func NewUDP(addr string, iface string, timeout time.Duration) (*Client, error) {
	raddr, err := net.ResolveUDPAddr("udp4", fmt.Sprintf("%s:%d", addr, PicomapPort))
	if err != nil {
		return nil, fmt.Errorf("resolve %s: %w", addr, err)
	}

	var laddr *net.UDPAddr
	if iface != "" {
		ip, _, err := interfaceIPv4Net(iface)
		if err != nil {
			return nil, err
		}
		laddr = &net.UDPAddr{IP: ip, Port: 0}
	}

	conn, err := net.ListenUDP("udp4", laddr)
	if err != nil {
		return nil, fmt.Errorf("listen: %w", err)
	}

	if err := enableBroadcast(conn); err != nil {
		conn.Close()
		return nil, fmt.Errorf("SO_BROADCAST: %w", err)
	}

	bcast := isInterfaceBroadcast(iface, raddr.IP)
	return &Client{transport: &udpTransport{conn: conn, addr: raddr, broadcast: bcast}, timeout: timeout}, nil
}

func (t *udpTransport) Send(data []byte) error {
	_, err := t.conn.WriteToUDP(data, t.addr)
	return err
}

func (t *udpTransport) SetReadTimeout(timeout time.Duration) {
	t.conn.SetReadDeadline(time.Now().Add(timeout))
}

func (t *udpTransport) Reader() io.Reader {
	return t
}

func (t *udpTransport) Read(p []byte) (int, error) {
	if t.buf.Len() > 0 {
		return t.buf.Read(p)
	}
	pkt := make([]byte, 1500)
	n, err := t.conn.Read(pkt)
	if err != nil {
		return 0, err
	}
	t.buf.Write(pkt[:n])
	return t.buf.Read(p)
}

func (t *udpTransport) Broadcast() bool { return t.broadcast }

func (t *udpTransport) Close() error {
	return t.conn.Close()
}