turbomaps-er/cmd/run.go

package cmd

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"
	"path"
	"slices"
	"strings"
)

func Run(ctx context.Context) error {
	fs := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
	searchRadius := fs.Float64("r", 5.0, "search radius in miles")
	doArea := fs.Bool("d", false, "do result radius in miles")
	var towns FlagStringArray
	fs.Var(&towns, "t", "list of towns to search around")
	searches := StringToFloat64{}
	fs.Var(&searches, "s", "list of things to search for around each town")
	if err := fs.Parse(os.Args[1:]); err != nil {
		panic(err)
	}

	type geoJson struct {
		Type       string `json:"type"`
		Properties struct {
			Name string `json:"name"`
		} `json:"properties"`
		Geometry struct {
			Type        string `json:"type"`
			Coordinates any    `json:"coordinates"`
		} `json:"geometry"`
	}
	type Area [1][5][2]float64
	type Point [2]float64
	geoJsons := []geoJson{}
	for _, town := range towns {
		for search, area := range searches {
			radius := area / convertToMiles
			radiusX := 2 * radius / 2
			radiusY := 2 * radius / 3
			m, err := NewMapsOf(ctx, town)
			if err != nil {
				return err
			}

			results, err := m.Search(ctx, search, *searchRadius)
			if err != nil {
				return err
			}

			for i := range results {
				var a geoJson
				a.Type = "Feature"
				a.Properties.Name = path.Join(search, results[i].Name)
				if strings.Contains(search, "school") {
					a.Properties.Name = " "
				}
				a.Geometry.Type = "Point"
				a.Geometry.Coordinates = Point{results[i].Lng, results[i].Lat}
				if *doArea {
					a.Geometry.Type = "Polygon"
					x, y := results[i].Lng, results[i].Lat
					a.Geometry.Coordinates = Area{{
						[2]float64{x, y + radiusY}, // top
						[2]float64{x + radiusX, y}, // right
						[2]float64{x, y - radiusY}, // bot
						[2]float64{x - radiusX, y}, // left
						[2]float64{x, y + radiusY}, // top
					}}
				}
				geoJsons = append(geoJsons, a)
			}
		}
	}
	log.Println(len(geoJsons))
	slices.SortFunc(geoJsons, func(a, b geoJson) int {
		return strings.Compare(fmt.Sprint(a.Geometry.Coordinates), fmt.Sprint(b.Geometry.Coordinates))
	})
	geoJsons = slices.CompactFunc(geoJsons, func(a, b geoJson) bool {
		return fmt.Sprint(a.Geometry.Coordinates) == fmt.Sprint(b.Geometry.Coordinates)
	})
	if *doArea {
		for i := range geoJsons {
			areaI, ok := geoJsons[i].Geometry.Coordinates.(Area)
			if ok {
				areaI := areaI[0]
				for j := i + 1; j < len(geoJsons); j++ {
					areaJ, ok := geoJsons[j].Geometry.Coordinates.(Area)
					if ok {
						areaJ := areaJ[0]
						// if diamond i contains j, then drop j
						iAbove := areaI[0][1] > areaJ[0][1]
						iRight := areaI[1][0] > areaJ[1][0]
						iBelow := areaI[2][1] < areaJ[2][1]
						iLeft := areaI[3][0] < areaJ[3][0]
						if iAbove && iRight && iBelow && iLeft {
							geoJsons[j].Geometry.Type = "Point"
							geoJsons[j].Geometry.Coordinates = Point{
								(areaJ[1][0] + areaJ[3][0]) / 2.0,
								(areaJ[0][1] + areaJ[2][1]) / 2.0,
							}
						}
					}
				}
			}
		}
	}
	log.Println("COMPACTED", len(geoJsons))
	b, _ := json.Marshal(map[string]any{
		"features": geoJsons,
		"type":     "FeatureCollection",
	})
	fmt.Printf("%s\n", b)

	return ctx.Err()
}

type FlagStringArray []string

func (array *FlagStringArray) String() string {
	return strings.Join(*array, ", ")
}

func (array *FlagStringArray) Set(s string) error {
	*array = append(*array, s)
	return nil
}

type StringToFloat64 map[string]float64

func (array *StringToFloat64) String() string {
	return fmt.Sprintf("%+v", (*map[string]float64)(array))
}

func (array *StringToFloat64) Set(s string) error {
	idx := strings.Index(s, "=")
	if idx < 0 {
		return fmt.Errorf("should be formatted as k=v")
	}
	k := s[:idx]
	v := s[idx+1:]
	var n float64
	if err := json.Unmarshal([]byte(v), &n); err != nil {
		return err
	}
	(*array)[k] = n
	return nil
}