// really stupid test door server

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

type DoorBoyServer struct {
	longPollers map[string]chan string
}

type card struct {
	UidHash string `json:"uid_hash"`
}

type cardToken struct {
	Token card `json:"token"`
}

type cardList struct {
	AllowedUids []cardToken `json:"allowed_uids"`
}

func getRoot(w http.ResponseWriter, r *http.Request) {
	fmt.Printf("got / request\n")
	io.WriteString(w, "This is my website!\n")
}

func getAllowed(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	keys := cardList{
		AllowedUids: []cardToken{
			{card{UidHash: "d72c87d0f077c7766f2985dfab30e8955c373a13a1e93d315203939f542ff86e73ee37c31f4c4b571f4719fa8e3589f12db8dcb57ea9f56764bb7d58f64cf705"}},
			{card{UidHash: "873636abbcf597a4835afc1c9b16a72eb6175b7ab278a8f18ab13c50172c90ea97cc3e258efd9cc1d885d7ea32d87fd006907892793e7cd6c468417bd8b8421a"}},
			{card{UidHash: "aabbccddeeff"}},
		},
	}
	respJson, _ := json.Marshal(keys)
	_, err := w.Write(respJson)
	if err != nil {
		return
	}
}

func writeAndFlush(writer http.ResponseWriter, buffer []byte) error {
	_, err := writer.Write(buffer)
	if err != nil {
		return err
	}
	if f, ok := writer.(http.Flusher); ok {
		f.Flush()
	}
	return nil
}

func (doorboyserver *DoorBoyServer) getLongPoll(w http.ResponseWriter, r *http.Request) {
	err := writeAndFlush(w, []byte("data: response-generator-started\n\n"))
	if err != nil {
		return
	}
	events := make(chan string)
	doorboyserver.longPollers[r.RemoteAddr] = events
	defer delete(doorboyserver.longPollers, r.RemoteAddr)

	err = writeAndFlush(w, []byte("data: watch-stream-opened\n\n"))
	if err != nil {
		return
	}
	d := <-events // get door open event
	_, err = w.Write([]byte("data: "))
	if err != nil {
		return
	}
	_, err = w.Write([]byte(d))
	if err != nil {
		return
	}
	err = writeAndFlush(w, []byte("\n\n"))
	if err != nil {
		return
	}
}

func (doorboyserver *DoorBoyServer) getLongPollJson(w http.ResponseWriter, r *http.Request) {
	flusher, ok := w.(http.Flusher)
	if !ok {
		fmt.Println("Failed to get flusher for http response")
	}
	w.WriteHeader(http.StatusOK)
	flusher.Flush()
	respJson, _ := json.Marshal([]string{"123456789", "aabbccddeeff", "aabbcc"})
	for i := 1; i <= 10; i++ {
		w.Write(respJson)
		w.Write([]byte("\n"))
		fmt.Println("send")
		flusher.Flush() // Trigger "chunked" encoding and send a chunk...
		time.Sleep(500 * time.Millisecond)
	}
}

func (doobserver *DoorBoyServer) postOpenDoor(w http.ResponseWriter, r *http.Request) {
	fmt.Println("longPollers:")
	for key, value := range doobserver.longPollers {
		fmt.Println(" Key:", key, "Value:", value)
		value <- "workshop"
	}
	w.Write([]byte("OK"))
}

func postCardSwipe(w http.ResponseWriter, r *http.Request) {

}

func main() {
	doorboyserver := DoorBoyServer{longPollers: map[string]chan string{}}
	http.HandleFunc("/", getRoot)
	http.HandleFunc("/allowed", getAllowed)
	http.HandleFunc("/longpoll", doorboyserver.getLongPoll)
	http.HandleFunc("/jspoll", doorboyserver.getLongPollJson)
	http.HandleFunc("/open", doorboyserver.postOpenDoor)
	http.HandleFunc("/cardswipe", postCardSwipe)

	err := http.ListenAndServe(":3333", nil)

	if errors.Is(err, http.ErrServerClosed) {
		fmt.Printf("server closed\n")
	} else if err != nil {
		fmt.Printf("error starting server: %s\n", err)
		os.Exit(1)
	}
}