package main

import (
	"encoding/json"
	"fmt"
	"git.timovolkmann.de/gyrogpsc/dispatcher"
	"git.timovolkmann.de/gyrogpsc/serial_ubx"
	"github.com/gorilla/websocket"
	"github.com/tidwall/pretty"
	"html/template"
	"log"
	"net"
	"net/http"
	"os"
)

const (
	TCP_PORT    = ":3010"
	SERIAL_PORT = "/dev/tty.usbmodem14201"
)

var upgrader = websocket.Upgrader{} // use default options

func echo(d *dispatcher.Dispatcher) func(w http.ResponseWriter, r *http.Request) {
	fmt.Println("echo")
	return func(w http.ResponseWriter, r *http.Request) {
		fmt.Println("upgrading to ws")
		c, err := upgrader.Upgrade(w, r, nil)
		if err != nil {
			log.Print("upgrade:", err)
			return
		}
		//defer c.Close()
		go func() {
			for {
				if _, _, err := c.NextReader(); err != nil {
					c.Close()
					break
				}
			}
		}()

		dispatcherId, channel := d.Subscribe()
		defer d.Unsubscribe(dispatcherId)
		for {
			log.Println("")
			//if err != nil {
			//	log.Println("read:", err)
			//	break
			//}
			cmsg := <-channel
			err = c.WriteMessage(websocket.TextMessage, []byte(cmsg))
			if err != nil {
				log.Println("write:", err)

				break
			}
		}
	}
}

func home(w http.ResponseWriter, r *http.Request) {
	//var homeTemplate = template.Must(template.New("").ParseFiles("index.html"))
	tpl, err := template.ParseFiles("index.html")
	if err != nil {
		log.Fatalln(err)
	}
	err = tpl.Execute(w, "ws://"+r.Host+"/echo")
	if err != nil {
		log.Fatalln(err)
	}
}

func main() {
	d := dispatcher.New()
	collectRoutines(d)
	http.HandleFunc("/echo", echo(d))
	http.HandleFunc("/", home)
	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("."))))

	log.Fatal(http.ListenAndServe(":3011", nil))
}

func collectRoutines(d *dispatcher.Dispatcher) {
	// collectRoutines Serial UBX Sensor Data
	go serialUbxCollector(d)
	// collectRoutines TCP JSON Sensor Data
	go tcpJsonCollector(d)
}

func serialUbxCollector(d *dispatcher.Dispatcher) {
	r, err := serial_ubx.Setup(SERIAL_PORT)
	if err != nil {
		log.Fatalln(err)
	}

	for {
		meas, err := r.NextMeasurement()
		if err != nil {
			continue
		}
		fmt.Println(meas)
		measjson, err := json.Marshal(meas)
		d.Publish(string(measjson))
	}
}

func tcpJsonCollector(d *dispatcher.Dispatcher) {
	listener, err := net.Listen("tcp", TCP_PORT)
	if err != nil {
		fmt.Println("Error listening:", err.Error())
		os.Exit(1)
	}
	// Close the listener when the application closes.
	defer listener.Close()

	for {
		// Listen for an incoming connection.
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting: ", err.Error())
			os.Exit(1)
		}
		// Handle connections in a new goroutine.
		go handleTcpJsonSensorData(conn, d)
	}
}

// Handles incoming requests.
func handleTcpJsonSensorData(conn net.Conn, d *dispatcher.Dispatcher) {
	defer conn.Close()
	// Make a buffer to hold incoming data.
	for {
		buf := make([]byte, 2048)
		// Read the incoming connection into the buffer.
		_, err := conn.Read(buf)
		if err != nil {
			fmt.Println("Error reading:", err.Error())
			break
		}
		json := pretty.Pretty(buf)
		fmt.Println(string(json))
		d.Publish(string(json))
		// Send a response back to person contacting us.
		//conn.Write([]byte("success"))
		// Close the connection when you're done with it.
	}
}