mapbox

type Client interface {
	// Geocoder covers forward and reverse geocoding mapbox API
	Geocoder
}

type Context struct {
	ID        string `json:"id"`
	Text      string `json:"text"`
	Wikidata  string `json:"wikidata"`
	ShortCode string `json:"short_code"`
}

type FastHttpClient interface {
	Do(req *fasthttp.Request, resp *fasthttp.Response) error
}

type FastHttpGeocoder struct {
	// contains filtered or unexported fields
}

type Feature struct {
	ID          string     `json:"id"`
	Type        string     `json:"type"`
	PlaceType   []string   `json:"place_type"`
	Relevance   float64    `json:"relevance"`
	Properties  Properties `json:"properties"`
	Text        string     `json:"text"`
	PlaceName   string     `json:"place_name"`
	Center      []float64  `json:"center"`
	Geometry    Geometry   `json:"geometry"`
	Address     string     `json:"address"`
	Context     []Context  `json:"context"`
	BoundingBox []float64  `json:"bbox"`
}

type ForwardGeocodeRequest struct {
	//The feature you’re trying to look up.
	//This could be an address, a point of interest name, a city name, etc.
	//When searching for points of interest, it can also be a category name (for example, “coffee shop”).
	//For information on categories, see the Point of interest category coverage section.
	//The search text should be expressed as a URL-encoded UTF-8 string,
	//and must not contain the semicolon character (either raw or URL-encoded).
	//Your search text, once decoded, must consist of at most 20 words and numbers separated by spacing and punctuation,
	//and at most 256 characters.
	//
	//The accuracy of coordinates returned by a forward geocoding request can be impacted
	//by how the addresses in the query are formatted. Learn more about address formatting
	//best practices in the https://docs.mapbox.com/help/troubleshooting/address-geocoding-format-guide.
	SearchText string

	//Specify whether to return autocomplete results (true, default) or not (false).
	//When autocomplete is enabled, results will be included that start with the requested string,
	//rather than just responses that match it exactly.
	//For example, a query for India might return both India and Indiana with autocomplete enabled,
	//but only India if it’s disabled.
	//
	//When autocomplete is enabled, each user keystroke counts as one request to the Geocoding API.
	//For example, a search for "coff" would be reflected as four separate Geocoding API requests.
	//To reduce the total requests sent, you can configure your application
	//to only call the Geocoding API after a specific number of characters are typed.
	Autocomplete *bool // default true

	//Limit results to only those contained within the supplied bounding box
	//Bounding boxes should be supplied as four numbers separated by commas,
	//in  minLon,minLat,maxLon,maxLat order.
	//The bounding box cannot cross the 180th meridian.
	Bbox []float64

	//Limit results to one or more countries.
	//Permitted values are ISO 3166 alpha 2 country codes separated by commas.
	Country string

	//Specify whether the Geocoding API should attempt approximate,
	//as well as exact, matching when performing searches (true, default),
	//or whether it should opt out of this behavior and only attempt exact matching (false).
	//For example, the default setting might return Washington, DC for a query of wahsington,
	//even though the query was misspelled.
	FuzzyMatch *bool // default true

	//Specify the user’s language.
	//This parameter controls the language of the text supplied in responses, and also affects result scoring,
	//with results matching the user’s query in the requested language being preferred over results
	//that match in another language. For example, an autocomplete query for things
	//that start with Frank might return Frankfurt as the first result with an English (en) language parameter,
	//but Frankreich (“France”) with a German (de) language parameter.
	//
	//Options are IETF language tags comprised of a mandatory ISO 639-1 language code and, optionally,
	//one or more IETF subtags for country or script.
	//
	//More than one value can also be specified, separated by commas,
	//for applications that need to display labels in multiple languages.
	//
	//For more information on which specific languages are supported, see the https://docs.mapbox.com/api/search/#language-coverage.
	Language string

	//Specify the maximum number of results to return. The default is 5 and the maximum supported is 10.
	Limit int // default 5

	//Bias the response to favor results that are closer to this location
	Proximity *GeoPoint

	//Specify whether to request additional metadata about the recommended navigation destination
	//corresponding to the feature (true) or not (false, default). Only applicable for address features.
	//
	//For example, if routing=true the response could include data about a point on the road the feature fronts.
	//Response features may include an array containing one or more routable points.
	//Routable points cannot always be determined.
	//Consuming applications should fall back to using the feature’s normal geometry for routing
	//if a separate routable point is not returned.
	Routing bool //default false

	//Filter results to include only a subset (one or more) of the available feature types.
	//Options are country, region, postcode, district, place, locality, neighborhood, address, and poi.
	//Multiple options can be comma-separated. Note that poi.landmark is a deprecated type that,
	//while still supported, returns the same data as is returned using the poi type.
	//
	//For more information on the available types, see the https://docs.mapbox.com/api/search/#data-types.
	Types []string
}

type GeoPoint struct {
	Lon float64
	Lat float64
}

type GeocodeResponse struct {
	RateLimit RateLimit
	// Raw mapbox API response
	RawResp []byte
	// passed query to mapbox
	ReverseQuery GeoPoint
	ForwardQuery []string
	// response result type
	Type string
	// response data
	Features []Feature
}

type Geocoder interface {
	// ReverseGeocode calls geocode/v5 reverse mapbox API
	ReverseGeocode(ctx context.Context, req *ReverseGeocodeRequest) (*GeocodeResponse, error)
	// ReverseGeocode calls geocode/v5 reverse mapbox API
	ForwardGeocode(ctx context.Context, req *ForwardGeocodeRequest) (*GeocodeResponse, error)
}

type GeocoderMock struct {
	ForwardGeocodeMock mGeocoderMockForwardGeocode

	ReverseGeocodeMock mGeocoderMockReverseGeocode
	// contains filtered or unexported fields
}

type GeocoderMockForwardGeocodeExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

type GeocoderMockForwardGeocodeParams struct {
	// contains filtered or unexported fields
}

type GeocoderMockForwardGeocodeResults struct {
	// contains filtered or unexported fields
}

type GeocoderMockReverseGeocodeExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

type GeocoderMockReverseGeocodeParams struct {
	// contains filtered or unexported fields
}

type GeocoderMockReverseGeocodeResults struct {
	// contains filtered or unexported fields
}

type Geometry struct {
	Type        string    `json:"type"`
	Coordinates []float64 `json:"coordinates"`
}

type Logger interface {
	Debugf(msg string, params ...interface{})
	Errorf(msg string, params ...interface{})
}

type LoggerMock struct {
	DebugfMock mLoggerMockDebugf

	ErrorfMock mLoggerMockErrorf
	// contains filtered or unexported fields
}

type LoggerMockDebugfExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

type LoggerMockDebugfParams struct {
	// contains filtered or unexported fields
}

type LoggerMockErrorfExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

type LoggerMockErrorfParams struct {
	// contains filtered or unexported fields
}

type Option func(c config) config

type Properties struct {
	Accuracy  string `json:"accuracy"`
	ShortCode string `json:"short_code"`
}

type RateLimit struct {
	Interval []byte
	Limit    []byte
	Reset    []byte
}

type ReverseGeocodeRequest struct {
	GeoPoint GeoPoint
	// Limit results to one or more countries.
	Limit int
	// Filter results to include only a subset (one or more) of the available feature types.
	// Options are country, region, postcode, district, place, locality, neighborhood, address, and poi.
	// Multiple options can be comma-separated. Note that poi.landmark is a deprecated type that, while still supported,
	// returns the same data as is returned using the poi type.
	Types []string
	// Permitted values are ISO 3166 alpha 2(https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country codes separated by commas.
	Country string
	// Specify the user’s language. This parameter controls the language of the text supplied in responses.
	// Options are IETF language tags comprised of a mandatory ISO 639-1 language code and, optionally,
	// one or more IETF subtags for country or script.
	// More than one value can also be specified, separated by commas,
	// for applications that need to display labels in multiple languages.
	// For more information on which specific languages are supported, see https://docs.mapbox.com/api/search/#language-coverage
	Language string
	// Decides how results are sorted in a reverse geocoding query
	// if multiple results are requested using a limit other than 1.
	// Options are distance (default), which causes the closest feature
	// to always be returned first, and score, which allows high-prominence features
	// to be sorted higher than nearer, lower-prominence features.
	ReverseMode int
	// Specify whether to request additional metadata about the recommended navigation destination corresponding
	// to the feature (true) or not (false, default). Only applicable for address features.
	// For example, if routing=true the response could include data about a point on the road the feature fronts.
	// Response features may include an array containing one or more routable points.
	// Routable points cannot always be determined.
	// Consuming applications should fall back to using the feature’s normal geometry for routing
	// if a separate routable point is not returned.
	Routing bool
}