package main

import (
	"errors"
	"net"
)

type UDPBind interface {
	SetMark(value uint32) error
	ReceiveIPv6(buff []byte, end *Endpoint) (int, error)
	ReceiveIPv4(buff []byte, end *Endpoint) (int, error)
	Send(buff []byte, end *Endpoint) error
	Close() error
}

func parseEndpoint(s string) (*net.UDPAddr, error) {

	// ensure that the host is an IP address

	host, _, err := net.SplitHostPort(s)
	if err != nil {
		return nil, err
	}
	if ip := net.ParseIP(host); ip == nil {
		return nil, errors.New("Failed to parse IP address: " + host)
	}

	// parse address and port

	addr, err := net.ResolveUDPAddr("udp", s)
	if err != nil {
		return nil, err
	}
	return addr, err
}

/* Must hold device and net lock
 */
func unsafeCloseUDPListener(device *Device) error {
	netc := &device.net
	if netc.bind != nil {
		if err := netc.bind.Close(); err != nil {
			return err
		}
		netc.bind = nil
		netc.update.Broadcast()
	}
	return nil
}

// must inform all listeners
func UpdateUDPListener(device *Device) error {
	device.mutex.Lock()
	defer device.mutex.Unlock()

	netc := &device.net
	netc.mutex.Lock()
	defer netc.mutex.Unlock()

	// close existing sockets

	if err := unsafeCloseUDPListener(device); err != nil {
		return err
	}

	// wait for reader

	// open new sockets

	if device.tun.isUp.Get() {

		// bind to new port

		var err error
		netc.bind, netc.port, err = CreateUDPBind(netc.port)
		if err != nil {
			netc.bind = nil
			return err
		}

		// set mark

		err = netc.bind.SetMark(netc.fwmark)
		if err != nil {
			return err
		}

		// clear cached source addresses

		for _, peer := range device.peers {
			peer.mutex.Lock()
			peer.endpoint.value.ClearSrc()
			peer.mutex.Unlock()
		}

		// inform readers of updated bind

		netc.update.Broadcast()
	}

	return nil
}

func CloseUDPListener(device *Device) error {
	device.mutex.Lock()
	device.net.mutex.Lock()
	err := unsafeCloseUDPListener(device)
	device.net.mutex.Unlock()
	device.mutex.Unlock()
	return err
}