// inspired from:
// https://github.com/mactsouk/opensource.com.git
// and
// https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go

package main

import "bufio"
// import "fmt"
import "math/rand"
import "net"
// import "os"
import "strconv"
import "strings"
import "time"
import "log"

// will try to get this hosts FQDN
import "github.com/Showmax/go-fqdn"

import "github.com/miekg/dns"

import "github.com/davecgh/go-spew/spew"

const MIN = 1
const MAX = 100

const (
	CONN_HOST = "localhost"
	CONN_PORT = "3333"
	CONN_TYPE = "tcp"
)

func main() {
	hostname := fqdn.Get()
	log.Println("FQDN hostname is", hostname)

	// lookup the IP address from DNS
	dnsRR := dnstrace(hostname, "AAAA")
	spew.Dump(dnsRR)
	ipaddr := dns.Field(dnsRR, 1)
	log.Println("ipaddr", ipaddr)

	listenstr :=  "[" + ipaddr + "]:" + CONN_PORT
	log.Println("listenstr", listenstr)

	// // Listen for incoming connections on the IPv6 address only
	l, err := net.Listen(CONN_TYPE, listenstr)
	if err != nil {
		log.Println("Error listening:", err.Error())
		return
	}

	// Close the listener when the application closes.
	defer l.Close()

	log.Println("Listening on " + listenstr)

	rand.Seed(time.Now().Unix())

	for {
		// Listen for an incoming connection.
		conn, err := l.Accept()
		if err != nil {
			log.Println("Error accepting: ", err.Error())
			return
		}

		// Handle connections in a new goroutine.
		go handleConnection(conn)
	}
}


func random() int {
	return rand.Intn(MAX-MIN) + MIN
}

func getRemoteAddr(c net.Conn) string {
	clientAddr := c.RemoteAddr().String()
	return clientAddr
}

//
// Handle each connection
// Each client must send it's hostname as the first line
// Then each hostname is verified with DNSSEC
//
func handleConnection(c net.Conn) {
	ipv6client := getRemoteAddr(c)
	log.Println("Serving to %s as the IPv6 client", ipv6client)
	
	log.Println("Waiting for the client to tell me its name")
	netData, err := bufio.NewReader(c).ReadString('\n')
	if err != nil {
		log.Println(err)
		return
	}
	clientHostname := strings.TrimSpace(netData)
	log.Println("Recieved client hostname as:", clientHostname)

	dnsRR := dnstrace(clientHostname, "AAAA")
	ipaddr := dns.Field(dnsRR, 1)
	log.Println("Client claims to be:   ", ipaddr)
	log.Println("Serving to IPv6 client:", ipv6client)

	for {
		netData, err := bufio.NewReader(c).ReadString('\n')
		if err != nil {
			log.Println(err)
			return
		}

		temp := strings.TrimSpace(string(netData))
		if temp == "STOP" {
			break
		}
		log.Println("Recieved: ", temp)

		result := strconv.Itoa(random()) + "\n"
		c.Write([]byte(string(result)))
	}
	c.Close()
}