szczanieckiej/server/router.go

package server

import (
	"apiote.xyz/p/szczanieckiej/api"
	"apiote.xyz/p/szczanieckiej/config"
	"apiote.xyz/p/szczanieckiej/traffic"
	traffic_errors "apiote.xyz/p/szczanieckiej/traffic/errors"

	"errors"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"golang.org/x/text/language"

	"git.sr.ht/~sircmpwn/go-bare"
)

type ServerError struct {
	code  int
	field string
	value string
	err   error
}

func (e ServerError) Error() string {
	message := ""
	switch e.code {
	case http.StatusBadRequest:
		message = e.value + " not valid as " + e.field
	case http.StatusNotFound:
		message = e.value + " not found as " + e.field
	default:
		message = fmt.Sprintf("error %d", e.code)
		if e.field != "" {
			message += " in field " + e.field
		}
		if e.value != "" {
			message += " with value " + e.value
		}
		if e.err != nil {
			message += ": " + e.err.Error()
		}
	}
	return message
}

func parseDate(dateString string, feedName string, t *traffic.Traffic) (traffic.Validity, time.Time, error) {
	versionCode := traffic.Validity("")
	if dateString == "" {
		feedNow := time.Now().In(t.Feeds[feedName].GetLocation())
		dateString = feedNow.Format(traffic.DateFormat)
	}
	date, err := time.ParseInLocation(traffic.DateFormat, dateString, t.Feeds[feedName].GetLocation())
	if err != nil {
		return versionCode, date, ServerError{
			code:  http.StatusBadRequest,
			field: "date",
			value: dateString,
		}
	}
	for _, v := range t.Versions[feedName] {
		if !v.ValidFrom.After(date) && !date.After(v.ValidTill) {
			versionCode = traffic.Validity(v.String())
		}
	}

	if versionCode == "" {
		return versionCode, date, ServerError{
			code:  http.StatusNotFound,
			field: "date",
			value: dateString,
		}
	}
	return versionCode, date, nil
}

func parsePosition(location string) (traffic.Position, error) {
	locationString := strings.Split(location, ",")
	if len(locationString) != 2 {
		return traffic.Position{}, fmt.Errorf("location is not two numbers")
	}
	lat, err := strconv.ParseFloat(locationString[0], 64)
	if err != nil {
		return traffic.Position{}, fmt.Errorf("latitude is not a float")
	}
	lon, err := strconv.ParseFloat(locationString[1], 64)
	if err != nil {
		return traffic.Position{}, fmt.Errorf("longitude is not a float")
	}
	return traffic.Position{Lat: lat, Lon: lon}, nil
}

func handleRoot(w http.ResponseWriter, r *http.Request, t *traffic.Traffic, cfg config.Config, accept uint) error {
	if accept > 2 {
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	var success api.FeedsResponse
	switch accept {
	case 0:
		success = api.FeedsResponseDev{}
	case 1:
		success = api.FeedsResponseV1{}
	default:
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	acceptLanguage := r.Header.Get("Accept-Language")
	if acceptLanguage == "" {
		acceptLanguage = "und"
	}
	preferredLanguages, _, err := language.ParseAcceptLanguage(acceptLanguage)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "Accept-Language",
			value: acceptLanguage,
			err:   err,
		}
	}
	for id, feed := range t.Feeds {
		lastUpdate, err := traffic.LastUpdate(cfg.FeedsPath, feed.String())
		if err != nil {
			return fmt.Errorf("while getting last update for %s: %w", id, err)
		}
		trafficDescription := feed.Description()
		descriptionTags := []language.Tag{}
		for t := range trafficDescription {
			descriptionTags = append(descriptionTags, t)
		}
		trafficAttribution := feed.Attribution()
		attributionTags := []language.Tag{}
		for t := range trafficAttribution {
			attributionTags = append(attributionTags, t)
		}

		matcher := language.NewMatcher(preferredLanguages)
		_, index, _ := matcher.Match(descriptionTags...)
		descriptionTag := preferredLanguages[index]
		_, index, _ = matcher.Match(attributionTags...)
		attributionTag := preferredLanguages[index]

		f := api.FeedInfoV1{
			Name:        feed.Name(),
			Id:          id,
			Attribution: trafficAttribution[attributionTag],
			Description: trafficDescription[descriptionTag],
			LastUpdate:  lastUpdate.Format(time.RFC3339),
		}

		switch accept {
		case 0:
			s := success.(api.FeedsResponseDev)
			s.Feeds = append(s.Feeds, f)
			success = s
		case 1:
			s := success.(api.FeedsResponseV1)
			s.Feeds = append(s.Feeds, f)
			success = s
		}
	}
	var response api.FeedsResponse = success
	bytes, err := bare.Marshal(&response)
	if err != nil {
		return fmt.Errorf("while marshaling: %w", err)
	}
	_, err = w.Write(bytes)
	if err != nil {
		return fmt.Errorf("while writing: %w", err)
	}
	return nil
}

func handleFeed(w http.ResponseWriter, r *http.Request, feedName string, accept uint) error {
	return ServerError{
		code:  http.StatusNotFound,
		field: "resource",
		value: "feed",
	}
	// todo(BAF17) send feed
}

func handleLocatables(w http.ResponseWriter, r *http.Request, feedNames []string, cfg config.Config, t *traffic.Traffic, accept uint) error {
	if accept > 2 {
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	var locatablesSuccess api.LocatablesResponse
	switch accept {
	case 0:
		locatablesSuccess = api.LocatablesResponseDev{}
	case 1:
		locatablesSuccess = api.LocatablesResponseV1{}
	case 2:
		locatablesSuccess = api.LocatablesResponseV2{}
	}
	err := r.ParseForm()
	if err != nil {
		return fmt.Errorf("while parsing form: %w", err)
	}
	dateString := r.Form.Get("date")
	lb, err := parsePosition(r.Form.Get("lb"))
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "lb",
			value: r.Form.Get("lb"),
			err:   err,
		}
	}
	rt, err := parsePosition(r.Form.Get("rt"))
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "rt",
			value: r.Form.Get("rt"),
			err:   err,
		}
	}
	for _, feedName := range feedNames {
		versionCode, _, err := parseDate(dateString, feedName, t)
		if err != nil {
			return fmt.Errorf("while parsing date: %w", err)
		}

		context := traffic.Context{
			DataHome: cfg.FeedsPath,
			FeedName: feedName,
			Version:  versionCode,
		}
		stops, err := traffic.GetStopsIn(lb, rt, context, t)
		if err != nil {
			return fmt.Errorf("while getting stops in bounding box: %w", err)
		}
		vehicles, err := traffic.GetVehiclesIn(lb, rt, context, t)
		if err != nil {
			return fmt.Errorf("while getting vehicles in bounding box: %w", err)
		}
		locatables := []traffic.Locatable{}
		for _, stop := range stops {
			locatables = append(locatables, stop)
		}
		for _, vehicle := range vehicles {
			locatables = append(locatables, vehicle)
		}
		switch accept {
		case 0:
			locatablesSuccess, err = api.CreateSuccessLocatablesV2(locatables, context, t, locatablesSuccess)
		case 1:
			locatablesSuccess, err = api.CreateSuccessLocatables(locatables, context, t, locatablesSuccess)
		case 2:
			locatablesSuccess, err = api.CreateSuccessLocatablesV2(locatables, context, t, locatablesSuccess)
		}
		if err != nil {
			return fmt.Errorf("while creating locatablesSuccess from near locatables: %w", err)
		}
	}
	bytes, err := bare.Marshal(&locatablesSuccess)
	if err != nil {
		return fmt.Errorf("while marshaling: %w", err)
	}
	_, err = w.Write(bytes)
	if err != nil {
		return fmt.Errorf("while writing: %w", err)
	}
	return nil
}

func handleQueryables(w http.ResponseWriter, r *http.Request, feedNames []string, cfg config.Config, t *traffic.Traffic, accept uint) error {
	if accept > 2 {
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	var queryablesSuccess api.QueryablesResponse
	switch accept {
	case 0:
		queryablesSuccess = api.QueryablesResponseDev{}
	case 1:
		queryablesSuccess = api.QueryablesResponseV1{}
	case 2:
		queryablesSuccess = api.QueryablesResponseV2{}
	}
	err := r.ParseForm()
	if err != nil {
		return fmt.Errorf("while parsing form: %w", err)
	}
	query := r.Form.Get("q")
	near := r.Form.Get("near")
	dateString := r.Form.Get("date")
	limitString := r.Form.Get("limit")
	if limitString == "" {
		limitString = "12"
	}
	limit, err := strconv.ParseUint(limitString, 10, 0)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "limit",
			value: limitString,
		}
	}
	offsetString := r.Form.Get("offset")
	if offsetString == "" {
		offsetString = "0"
	}
	offset, err := strconv.ParseUint(offsetString, 10, 0)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "offset",
			value: offsetString,
		}
	}

	for _, feedName := range feedNames {
		versionCode, _, err := parseDate(dateString, feedName, t)
		if err != nil {
			return fmt.Errorf("while parsing date: %w", err)
		}

		context := traffic.Context{
			DataHome: cfg.FeedsPath,
			FeedName: feedName,
			Version:  versionCode,
		}

		if near != "" {
			location, err := parsePosition(near)
			if err != nil {
				return ServerError{
					code:  http.StatusBadRequest,
					field: "near",
					value: near,
					err:   err,
				}
			}
			stops, err := traffic.GetStopsNear(location, context, t)
			if err != nil {
				return fmt.Errorf("while getting near stops: %w", err)
			}
			items := []traffic.Item{}
			for _, stop := range stops {
				items = append(items, stop)
			}
			switch accept {
			case 0:
				queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, items, context, t, queryablesSuccess)
			case 1:
				queryablesSuccess, err = api.CreateSuccessQueryables(items, context, t, queryablesSuccess)
			case 2:
				queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, items, context, t, queryablesSuccess)
			}
			if err != nil {
				return fmt.Errorf("while creating stopsSuccess from near stops: %w", err)
			}
		} else {
			ix := t.CodeIndexes[feedName][versionCode]
			code := query
			_, exists := ix[code]
			if exists {
				stop, err := traffic.GetStop(code, context, t)
				if err != nil {
					return fmt.Errorf("while getting stop: %w", err)
				}
				switch accept {
				case 0:
					queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, []traffic.Item{stop}, context, t, queryablesSuccess)
				case 1:
					queryablesSuccess, err = api.CreateSuccessQueryables([]traffic.Item{stop}, context, t, queryablesSuccess)
				case 2:
					queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, []traffic.Item{stop}, context, t, queryablesSuccess)
				}
				if err != nil {
					return fmt.Errorf("while creating stopsSuccess from code: %w", err)
				}
			} else {
				query, err = traffic.CleanQuery(query, t.Feeds[feedName])
				if err != nil {
					return fmt.Errorf("while cleaning query: %w", err)
				}
				lines, err1 := traffic.QueryLines(query, cfg.FeedsPath, feedName, versionCode, t)
				stops, err2 := traffic.QueryStops(query, context, t)
				if err1 != nil && err2 != nil {
					return fmt.Errorf("while querying stops and lines: %w", errors.Join(err1, err2))
				}
				items := []traffic.Item{}
				for _, line := range lines {
					items = append(items, line)
				}
				for _, stop := range stops {
					items = append(items, stop)
				}

				switch accept {
				case 0:
					queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, items, context, t, queryablesSuccess)
				case 1:
					queryablesSuccess, err = api.CreateSuccessQueryables(items, context, t, queryablesSuccess)
				case 2:
					queryablesSuccess, err = api.CreateSuccessQueryablesV2(query, items, context, t, queryablesSuccess)
				}
				if err != nil {
					return fmt.Errorf("while creating stopsSuccess from lines and stops: %w", err)
				}
			}
		}
	}

	queryablesSuccess = api.LimitQueryables(queryablesSuccess, offset, limit)
	bytes, err := bare.Marshal(&queryablesSuccess)
	if err != nil {
		return fmt.Errorf("while marshaling: %w", err)
	}
	_, err = w.Write(bytes)
	if err != nil {
		return fmt.Errorf("while writing: %w", err)
	}
	return nil
}

func handleDepartures(w http.ResponseWriter, r *http.Request, feedName string, cfg config.Config, t *traffic.Traffic, accept uint) error {
	if accept > 2 {
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	err := r.ParseForm()
	if err != nil {
		return fmt.Errorf("while parsing form: %w", err)
	}
	code := r.Form.Get("code")
	if code == "" {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "code",
			value: "EMPTY",
		}
	}
	dateString := r.Form.Get("date")
	line := r.Form.Get("line")
	limitString := r.Form.Get("limit")
	if limitString == "" {
		limitString = "12"
	}
	limit, err := strconv.ParseUint(limitString, 10, 0)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "limit",
			value: limitString,
		}
	}
	offsetString := r.Form.Get("offset")
	if offsetString == "" {
		offsetString = "0"
	}
	offset, err := strconv.ParseUint(offsetString, 10, 0)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "offset",
			value: offsetString,
		}
	}
	departuresType := traffic.DEPARTURES_FULL
	if dateString == "" {
		departuresType = traffic.DEPARTURES_HYBRID
	}

	versionCode, date, err := parseDate(dateString, feedName, t)
	if err != nil {
		return err
	}

	context := traffic.Context{
		DataHome: cfg.FeedsPath,
		FeedName: feedName,
		Version:  versionCode,
	}

	ix := t.CodeIndexes[feedName][versionCode]

	_, exists := ix[code]
	if !exists {
		return ServerError{
			code:  http.StatusNotFound,
			field: "code",
			value: string(code),
		}
	}

	stop, err := traffic.GetStop(code, context, t)
	if err != nil {
		return fmt.Errorf("while getting stop: %w", err)
	}

	departures, err := traffic.GetDepartures(code, line, cfg.FeedsPath, feedName, versionCode, t, date, departuresType)
	if err != nil {
		if _, ok := err.(traffic_errors.NoSchedule); ok {
			return ServerError{
				code:  http.StatusNotFound,
				field: "date",
				value: dateString,
			}
		} else {
			return fmt.Errorf("while getting departures: %w", err)
		}
	}

	if int(offset) > len(departures) {
		departures = []traffic.DepartureRealtime{}
	} else if len(departures) < int(offset+limit) {
		departures = departures[offset:]
	} else {
		departures = departures[offset : offset+limit]
	}

	acceptLanguage := r.Header.Get("Accept-Language")
	if acceptLanguage == "" {
		acceptLanguage, err = traffic.GetLanguage(context, t)
		if err != nil {
			log.Printf("while gettng default language: %v\n", err)
			acceptLanguage = "und"
		}
	}
	preferredLanguages, _, err := language.ParseAcceptLanguage(acceptLanguage)
	if err != nil {
		return ServerError{
			code:  http.StatusBadRequest,
			field: "Accept-Language",
			value: acceptLanguage,
			err:   err,
		}
	}

	alerts, err := traffic.GetAlerts(string(code), preferredLanguages, context, t)
	if err != nil {
		return fmt.Errorf("while getting alerts: %w", err)
	}

	var success api.DeparturesResponse
	switch accept {
	case 0:
		success, err = api.CreateSuccessDeparturesV2(stop, departures, date, t.Vehicles[feedName][versionCode], alerts, context, t, accept)
	case 1:
		success, err = api.CreateSuccessDeparturesV1(stop, departures, date, t.Vehicles[feedName][versionCode], alerts, context, t, accept)
	case 2:
		success, err = api.CreateSuccessDeparturesV2(stop, departures, date, t.Vehicles[feedName][versionCode], alerts, context, t, accept)
	}
	if err != nil {
		return fmt.Errorf("while creating departuresSuccess: %w", err)
	}
	bytes, err := bare.Marshal(&success)
	if err != nil {
		return fmt.Errorf("while marshaling: %w", err)
	}
	_, err = w.Write(bytes)
	if err != nil {
		return fmt.Errorf("while writing: %w", err)
	}
	return nil
}

func handleTrip(w http.ResponseWriter, r *http.Request, feedName string, cfg config.Config, t *traffic.Traffic, accept uint) error {
	path := strings.Split(r.URL.Path[1:], "/")
	if len(path) == 3 {
		dateString := r.Form.Get("date")
		versionCode, _, err := parseDate(dateString, feedName, t)
		if err != nil {
			return err
		}
		tripID := path[2]
		stopCode := r.Form.Get("stop")

		context := traffic.Context{
			DataHome: cfg.FeedsPath,
			FeedName: feedName,
			Version:  versionCode,
		}

		trip, err := traffic.GetTripFromStop(tripID, stopCode, context, t)
		if err != nil {
			return fmt.Errorf("while getting line: %w", err)
		}
		if len(trip) == 0 {
			return ServerError{
				code:  http.StatusNotFound,
				field: "line",
				value: tripID,
			}
		}

		success := struct{}{} //api.CreateSuccessTrip(trip)
		bytes, err := bare.Marshal(&success)
		if err != nil {
			return fmt.Errorf("while marshaling trip: %w", err)
		}
		_, err = w.Write(bytes)
		if err != nil {
			return fmt.Errorf("while writing: %w", err)
		}
	} else {
		return ServerError{
			code:  http.StatusNotFound,
			field: "trip",
			value: "EMPTY",
		}
	}
	return nil
}

func handleLine(w http.ResponseWriter, r *http.Request, feedName string, cfg config.Config, t *traffic.Traffic, accept uint) error {
	if accept > 1 {
		return ServerError{
			code: http.StatusNotAcceptable,
		}
	}
	path := strings.Split(r.URL.Path[1:], "/")
	if len(path) == 3 {
		dateString := r.Form.Get("date")
		versionCode, _, err := parseDate(dateString, feedName, t)
		if err != nil {
			return err
		}
		name := path[2]

		context := traffic.Context{
			DataHome: cfg.FeedsPath,
			FeedName: feedName,
			Version:  versionCode,
		}

		line, err := traffic.GetLine(name, context, t)
		if err != nil {
			return fmt.Errorf("while getting line: %w", err)
		}
		if line.Name == "" {
			return ServerError{
				code:  http.StatusNotFound,
				field: "line",
				value: name,
			}
		}
		var success api.LineResponse
		switch accept {
		case 0:
			success, err = api.CreateSuccessLine(line, context, t)
		case 1:
			success, err = api.CreateSuccessLine(line, context, t)
		}
		if err != nil {
			return fmt.Errorf("while creating response: %w", err)
		}
		bytes, err := bare.Marshal(&success)
		if err != nil {
			return fmt.Errorf("while marshaling line: %w", err)
		}
		_, err = w.Write(bytes)
		if err != nil {
			return fmt.Errorf("while writing: %w", err)
		}
	} else {
		return ServerError{
			code:  http.StatusNotFound,
			field: "line",
			value: "EMPTY",
		}
	}
	return nil
}

func sendError(w http.ResponseWriter, r *http.Request, err error) {
	var (
		se       ServerError
		response api.ErrorResponse
	)
	if !errors.As(err, &se) {
		se = ServerError{
			code: http.StatusInternalServerError,
			err:  err,
		}
	}
	response = api.ErrorResponse{
		Field:   se.field,
		Message: se.Error(),
	}
	log.Println(err.Error())
	b, err := bare.Marshal(&response)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	w.WriteHeader(se.code)
	w.Write(b)
}

func parseAccept(headers []string) (uint, error) {
	accept := -1
	for _, header := range headers {
		if header == "" {
			header = "EMPTY"
		}
		header, _ := strings.CutPrefix(header, "application/")
		header, _ = strings.CutSuffix(header, "+bare")
		a, err := strconv.ParseUint(header, 10, 0)
		if err != nil {
			continue
		}

		if a == 0 {
			return 0, nil
		}
		if int(a) > accept {
			accept = int(a)
		}
	}
	if accept == -1 {
		return 0, ServerError{
			code:  http.StatusBadRequest,
			field: "Accept",
			value: "",
		}
	}
	return uint(accept), nil
}

func Route(cfg config.Config, traffic *traffic.Traffic) *http.Server {
	srv := &http.Server{Addr: cfg.ListenAddress}

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		accept, err := parseAccept(r.Header.Values("Accept"))
		if err != nil {
			sendError(w, r, fmt.Errorf("while parsing accept: %w", err))
			return
		}
		if r.URL.Path[1:] == "" {
			err = handleRoot(w, r, traffic, cfg, accept)
		} else {
			path := strings.Split(r.URL.Path[1:], "/")
			feedNames := strings.Split(path[0], ",")
			for _, feedName := range feedNames {
				if traffic.Versions[feedName] == nil {
					sendError(w, r, ServerError{
						code:  http.StatusNotFound,
						field: "feed",
						value: feedName,
					})
					return
				}
			}

			if len(path) == 1 {
				if len(feedNames) > 1 {
					err = ServerError{
						code:  http.StatusBadRequest,
						field: "feed",
						value: path[0],
					}
				} else {
					err = handleFeed(w, r, feedNames[0], accept)
				}
			} else {
				resource := path[1]
				switch resource {
				case "queryables":
					err = handleQueryables(w, r, feedNames, cfg, traffic, accept)
				case "locatables":
					err = handleLocatables(w, r, feedNames, cfg, traffic, accept)
				case "departures":
					if len(feedNames) > 1 {
						err = ServerError{
							code:  http.StatusBadRequest,
							field: "feed",
							value: path[0],
						}
						break
					}
					err = handleDepartures(w, r, feedNames[0], cfg, traffic, accept)
				case "lines":
					if len(feedNames) > 1 {
						err = ServerError{
							code:  http.StatusBadRequest,
							field: "feed",
							value: path[0],
						}
						break
					}
					err = handleLine(w, r, feedNames[0], cfg, traffic, accept)
				/*case "trips":
				if len(feedNames) > 1 {
					err = ServerError{
						code:  http.StatusBadRequest,
						field: "feed",
						value: path[0],
					}
					break
				}
				err = handleTrip(w, r, feedNames[0], cfg, traffic)*/
				// todo(BAF21, BAF11): "shape" (line_id/trip_id)
				default:
					err = ServerError{
						code:  http.StatusNotFound,
						field: "resource",
						value: resource,
					}
				}
			}
		}
		if err != nil {
			sendError(w, r, err)
		}
	})

	go func() {
		fmt.Println("The wheels on the bus go round and round")
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Printf("ListenAndServe(): %v", err)
			os.Exit(1)
		}
	}()
	return srv
}