nidus-sync/tomtom/route.go

package tomtom

import (
	"fmt"
	"net/url"
	"strconv"

	"github.com/google/go-querystring/query"
)

// CalculateRouteRequest combines both path parameters and POST body
type CalculateRouteRequest struct {
	Params   CalculateRouteParams
	PostData *CalculateRoutePostData
}

func (sgr CalculateRouteRequest) toQueryParams() (url.Values, error) {
	return query.Values(sgr)
}

// BuildURL builds the URL for the Calculate Route request
func (req *CalculateRouteRequest) BuildURL(apiKey string) (string, error) {
	baseURL := fmt.Sprintf("%s/routing/%d/calculateRoute/%s/%s",
		BaseURL,
		req.Params.VersionNumber,
		req.Params.Locations,
		req.Params.ContentType)

	// Add query parameters
	query := url.Values{}
	query.Add("key", apiKey)

	// Add all the query parameters if they're set
	if req.Params.MaxAlternatives != nil {
		query.Add("maxAlternatives", strconv.Itoa(*req.Params.MaxAlternatives))
	}

	if req.Params.AlternativeType != "" {
		query.Add("alternativeType", req.Params.AlternativeType)
	}

	if req.Params.MinDeviationDistance != nil {
		query.Add("minDeviationDistance", strconv.Itoa(*req.Params.MinDeviationDistance))
	}

	if req.Params.MinDeviationTime != nil {
		query.Add("minDeviationTime", strconv.Itoa(*req.Params.MinDeviationTime))
	}

	if req.Params.InstructionsType != "" {
		query.Add("instructionsType", req.Params.InstructionsType)
	}

	if req.Params.Language != "" {
		query.Add("language", req.Params.Language)
	}

	if req.Params.ComputeBestOrder != nil {
		query.Add("computeBestOrder", strconv.FormatBool(*req.Params.ComputeBestOrder))
	}

	if req.Params.RouteRepresentation != "" {
		query.Add("routeRepresentation", req.Params.RouteRepresentation)
	}

	if req.Params.ComputeTravelTimeFor != "" {
		query.Add("computeTravelTimeFor", req.Params.ComputeTravelTimeFor)
	}

	if req.Params.VehicleHeading != nil {
		query.Add("vehicleHeading", strconv.Itoa(*req.Params.VehicleHeading))
	}

	for _, sectionType := range req.Params.SectionType {
		query.Add("sectionType", sectionType)
	}

	if req.Params.IncludeTollPaymentTypes != "" {
		query.Add("includeTollPaymentTypes", req.Params.IncludeTollPaymentTypes)
	}

	if req.Params.Callback != "" {
		query.Add("callback", req.Params.Callback)
	}

	if req.Params.Report != "" {
		query.Add("report", req.Params.Report)
	}

	if req.Params.DepartAt != "" {
		query.Add("departAt", req.Params.DepartAt)
	}

	if req.Params.ArriveAt != "" {
		query.Add("arriveAt", req.Params.ArriveAt)
	}

	if req.Params.RouteType != "" {
		query.Add("routeType", req.Params.RouteType)
	}

	if req.Params.Traffic != nil {
		query.Add("traffic", strconv.FormatBool(*req.Params.Traffic))
	}

	for _, avoid := range req.Params.Avoid {
		query.Add("avoid", avoid)
	}

	if req.Params.TravelMode != "" {
		query.Add("travelMode", req.Params.TravelMode)
	}

	// Add other parameters similarly...
	// Too many to list all here, but the pattern is the same

	return baseURL + "?" + query.Encode(), nil
}

// CalculateRoute sends a route calculation request to TomTom API
func (c *TomTom) CalculateRoute(req *CalculateRouteRequest) (*CalculateRouteResponse, error) {
	/*url, err := req.BuildURL(c.APIKey)
	if err != nil {
		return nil, err
	}*/

	var result CalculateRouteResponse
	/*
		query, err := req.toQueryParams()
		if err != nil {
			return nil, fmt.Errorf("structured geocode query: %w", err)
		}
	*/

	resp, err := c.client.R().
		//SetQueryParamsFromValues(query).
		SetResult(&result).
		SetPathParam("locations", req.Params.Locations).
		SetPathParam("urlBase", c.urlBase).
		SetQueryParam("key", c.APIKey).
		Get("https://{urlBase}/routing/1/calculateRoute/{locations}/json")
	if err != nil {
		return nil, fmt.Errorf("calculate route get: %w", err)
	}
	if !resp.IsSuccess() {
		return nil, fmt.Errorf("calculate route status: %d", resp.Status)
	}

	return &result, nil
}