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
	buf  bytes.Buffer
}

func isBroadcast(ip net.IP) bool {
	if ip.Equal(net.IPv4bcast) {
		return true
	}
	ip4 := ip.To4()
	return ip4 != nil && ip4[3] == 255
}

func interfaceIPv4(name string) (net.IP, error) {
	ifi, err := net.InterfaceByName(name)
	if err != nil {
		return nil, fmt.Errorf("interface %s: %w", name, err)
	}
	addrs, err := ifi.Addrs()
	if err != nil {
		return 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, nil
			}
		}
	}
	return nil, fmt.Errorf("interface %s has no IPv4 address", name)
}

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 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 := interfaceIPv4(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 isBroadcast(raddr.IP) {
		if err := enableBroadcast(conn); err != nil {
			conn.Close()
			return nil, fmt.Errorf("SO_BROADCAST: %w", err)
		}
	}

	return &Client{transport: &udpTransport{conn: conn, addr: raddr}, 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 {
	for {
		if t.buf.Len() > 0 {
			return &t.buf
		}
		pkt := make([]byte, 1500)
		n, err := t.conn.Read(pkt)
		if err != nil {
			return &t.buf
		}
		t.buf.Write(pkt[:n])
	}
}

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