package main

import (
	"encoding/base64"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
	"strings"
	"time"

	"github.com/google/gopacket"
	"github.com/google/gopacket/pcap"
)

func errCheck(err error) {
	if err != nil {
		panic(err)
	}
	return
}

func listenDiscoverResponse(addrChan chan string, readyFlag chan int) {
	handle, err := pcap.OpenLive("any", int32(1600), true, pcap.BlockForever)
	errCheck(err)

	err = handle.SetBPFFilter("udp and port 8850")
	errCheck(err)

	packets := gopacket.NewPacketSource(handle, handle.LinkType()).Packets()

	readyFlag <- 1

	for pkt := range packets {
		msg, err := base64.StdEncoding.DecodeString(string(pkt.ApplicationLayer().Payload()))
		if err == nil {
			if strings.Contains(string(msg), "clientapi") {
				addrChan <- string(msg)
				return
			}
		}
	}

	return
}

func toMaxHost(n *net.IPNet) (net.IP, error) {
	if n.IP.To4() == nil {
		return net.IP{}, errors.New("IP address is not IPv4")
	}

	ip := make(net.IP, len(n.IP.To4()))
	binary.BigEndian.PutUint32(ip,
		binary.BigEndian.Uint32(n.IP.To4())|^binary.BigEndian.Uint32(net.IP(n.Mask).To4()))

	return ip, nil
}

func bcastAddresses() []string {
	var addrs []string = nil
	interfaceInfo, _ := net.Interfaces()
	for i := 0; i < len(interfaceInfo); i++ {
		addr, err := interfaceInfo[i].Addrs()
		errCheck(err)
		for j := 0; j < len(addr); j++ {
			_, ipNet, _ := net.ParseCIDR(addr[j].String())
			bcast, err := toMaxHost(ipNet)

			if err != nil {
			} else {
				addrs = append(addrs, bcast.String())
			}
		}
	}

	return addrs
}

func main() {
	sendAddrs := bcastAddresses()

	addrChan := make(chan string)
	readyFlag := make(chan int)

	go listenDiscoverResponse(addrChan, readyFlag)

	// Wait for device to listen
	<- readyFlag

	for i := 0; i < len(sendAddrs); i++ {
		remoteAddr := sendAddrs[i] + ":8888"
		remote, err := net.ResolveUDPAddr("udp4", remoteAddr)
		errCheck(err)
		conn, err := net.DialUDP("udp4", nil, remote)
		errCheck(err)
		defer conn.Close()

		_, err = conn.Write([]byte(conn.LocalAddr().String() + "here"))
		errCheck(err)
	}

	// Listen timeout
	select {
		case returnMSG := <- addrChan:
			fmt.Printf("%s\n", strings.Fields(returnMSG)[1])
		case <- time.After(5 * time.Second):
			fmt.Printf("error\n")
	}
}