keyserver/cmd/keyserver/keyserver.go

package main

import (
	"cmp"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"math"
	"net/http"
	"os"
	"slices"
	"strconv"
	"strings"
	"time"

	geo "github.com/kellydunn/golang-geo"
)

const EARTH_RADIUS = 6371

func deg2rad(deg float64) float64 {
	return deg / 180 * math.Pi
}

func distanceHaversine(lat1, lon1, lat2, lon2 float64) float64 {
	lat1 = deg2rad(lat1)
	lat2 = deg2rad(lat2)
	lon1 = deg2rad(lon1)
	lon2 = deg2rad(lon2)

	alpha := (lat1 - lat2) * 0.5
	beta := (lon1 - lon2) * 0.5

	a := math.Sin(alpha)*math.Sin(alpha) + math.Cos(lat1)*math.Cos(lat2)*math.Sin(beta)*math.Sin(beta)
	c := math.Asin(math.Min(1, math.Sqrt(a)))

	distance := 2 * EARTH_RADIUS * c
	return distance
}

func hoodVoronoi(hoods []Hood, lat, long float64) *Hood {
	var best *Hood
	var bestDist float64 = math.MaxFloat64

	for i, hood := range hoods {
		if len(hood.Location) != 1 {
			continue
		}

		dist := distanceHaversine(lat, long, hood.Location[0].Lat, hood.Location[0].Long)

		if dist < bestDist {
			best = &hoods[i]
			bestDist = dist
		}
	}

	return best
}

func hoodPoly(hoods []Hood, lat, long float64) *Hood {
	var matches []*Hood
	var best *Hood

	for i, hood := range hoods {
		if len(hood.Location) < 3 {
			continue
		}

		var poly geo.Polygon
		for _, l := range hood.Location {
			poly.Add(geo.NewPoint(l.Lat, l.Long))
		}

		if !poly.IsClosed() {
			// TODO: validate when parsing files!
			log.Printf("Polygon is not closed for hood: %s", hood.HoodInfo.Name)
			continue
		}

		if poly.Contains(geo.NewPoint(lat, long)) {
			matches = append(matches, &hoods[i])
		}
	}

	if len(matches) == 0 {
		return nil
	}

	best = matches[0]
	for i, hood := range matches {
		// TODO: prefer polygon with smallest area
		if hood.HoodInfo.Id < best.HoodInfo.Id {
			best = matches[i]
		}
	}

	return best
}

func hoodId(hoods []Hood, id uint64) *Hood {
	for _, hood := range hoods {
		if hood.HoodInfo.Id == id {
			return &hood
		}
	}

	return nil
}

func logRequestDuration(h http.Handler) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			start := time.Now()

			h.ServeHTTP(w, r)

			duration := time.Since(start)
			log.Printf("Processed request in %s", duration)
		},
	)
}

func httpHeader(w http.ResponseWriter, r *http.Request, statusCode int) {
	log.Printf("\"%s %s %s\" %d", r.Method, r.RequestURI, r.Proto, statusCode)
	w.WriteHeader(statusCode)
}

func keyserverV2Handler(hoods []Hood) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			hoodid := r.URL.Query().Get("hoodid")
			lat := r.URL.Query().Get("lat")
			long := r.URL.Query().Get("long")
			lon := r.URL.Query().Get("lon")
			var hood *Hood = hoodId(hoods, 0)

			if lon != "" && long != "" {
				httpHeader(w, r, http.StatusBadRequest)
				return
			}

			if lon != "" {
				long = lon
			}

			if hoodid != "" {
				id, err := strconv.ParseUint(hoodid, 10, 64)
				if err != nil {
					httpHeader(w, r, http.StatusBadRequest)
					return
				}
				hood = hoodId(hoods, id)
			}

			if lat != "" {
				if long == "" {
					httpHeader(w, r, http.StatusBadRequest)
					return
				}

				// parse numbers
				lat := strings.Replace(lat, ",", ".", -1)
				long := strings.Replace(long, ",", ".", -1)

				latF, err := strconv.ParseFloat(lat, 64)
				if err != nil {
					httpHeader(w, r, http.StatusBadRequest)
					return
				}
				longF, err := strconv.ParseFloat(long, 64)
				if err != nil {
					httpHeader(w, r, http.StatusBadRequest)
					return
				}

				hoodP := hoodPoly(hoods, latF, longF)
				hood = hoodVoronoi(hoods, latF, longF)

				if hoodP != nil {
					hood = hoodP
				}

				if hood == nil {
					httpHeader(w, r, http.StatusInternalServerError)
					return
				}
			} else if long != "" {
				httpHeader(w, r, http.StatusBadRequest)
				return
			}

			if hood == nil {
				log.Print("No hood found")
				httpHeader(w, r, http.StatusNotFound)
				return
			}

			b, err := json.MarshalIndent(hood, "", "    ")
			if err != nil {
				log.Printf("Marshaling error: %s", err)
				httpHeader(w, r, http.StatusInternalServerError)
				return
			}
			w.Header().Add("Content-Type", "application/json; charset=utf-8")
			w.Write(b)
		},
	)
}

func keyserverV2Hoods(hoods []Hood) http.Handler {
	var resp []HoodsResponseHood

	for _, h := range hoods {
		hi := HoodsResponseHood{
			Id:     h.HoodInfo.Id,
			Active: 1,
			Name:   h.HoodInfo.Name,
			Essid:  h.HoodInfo.Essid,
		}

		if len(h.Location) == 1 {
			hi.Lat = h.Location[0].Lat
			hi.Lon = h.Location[0].Long
		}

		if len(h.Location) > 1 {
			hi.Polygons = append(hi.Polygons, h.Location)
		}

		resp = append(resp, hi)
	}

	slices.SortFunc(resp, func(a, b HoodsResponseHood) int { return cmp.Compare(a.Id, b.Id) })

	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			b, err := json.MarshalIndent(resp, "", "    ")
			if err != nil {
				log.Printf("Marshaling error: %s", err)
				httpHeader(w, r, http.StatusInternalServerError)
				return
			}
			w.Header().Add("Content-Type", "application/json; charset=utf-8")
			w.Write(b)
		},
	)
}

func parseHoods(hoodDir string) ([]Hood, error) {
	var newHoods []Hood
	var err error

	items, err := os.ReadDir(hoodDir)
	if err != nil {
		return nil, fmt.Errorf(`Error opening dir ("%s"): %w`, hoodDir, err)
	}
	for _, item := range items {
		var tmp Hood

		if !strings.HasSuffix(item.Name(), ".json") {
			log.Printf("Ignoring file without .json suffix: %s", item.Name())
			continue
		}

		b, err := os.ReadFile(hoodDir + "/" + item.Name())
		if err != nil {
			log.Printf("%s: %s", item.Name(), err)
			// TODO
		}

		err = json.Unmarshal(b, &tmp)
		if err != nil {
			log.Printf("%s: %s", item.Name(), err)
			// TODO
			continue
		}

		newHoods = append(newHoods, tmp)
	}

	return newHoods, nil
}

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

}

func run() error {
	hoodDir := flag.String("hoods", "./hoods", "Directory of hood json files")
	addr := flag.String("addr", ":8080", "HTTP listen addr")
	flag.Parse()

	hoods, err := parseHoods(*hoodDir)
	if err != nil {
		return err
	}

	http.Handle("/v2/", logRequestDuration(keyserverV2Handler(hoods)))
	http.Handle("/v2/hoods.php", logRequestDuration(keyserverV2Hoods(hoods)))
	log.Printf("Starting HTTP Server on http://%s", *addr)
	return http.ListenAndServe(*addr, nil)
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}