(City "Houston, TX", City "San Mateo, CA")
|> lookupLocations
|> tryFindDistance
|> Option.map metersToFeet

using City = string;

module Alias =
    type City = string

public interface ILocatable {
    float Latitude { get; }
    float Longitude { get; }
}

public class Place : ILocatable {
    public string Name { get; set; }
    public float Latitude { get; set; }
    public float Longitude { get; set; }
}

type ILocatable =
    abstract Latitude : float
    abstract Longitude : float

module FirstTry =

    type Place =
        { Name : string
          Latitude : float
          Longitude : float }
        interface ILocatable with
            member this.Latitude = this.Latitude
            member this.Longitude = this.Longitude

[<Measure>] type degLat
[<Measure>] type degLng

let degreesLatitude x = x * 1.<degLat>
let degreesLongitude x = x * 1.<degLng>

    type Location = {
        Latitude : float<degLat>
        Longitude : float<degLng>
    }

    type Place = { Name : City; Location : Location option }

type City = City of name : string
    with
    static member Create (name : string) =
        match name with
        | null | "" ->
            invalidArg "Invalid city"
                "The city name cannot be null or empty."
        | x -> City x

type Location =
    internal { latitude : float<degLat>; longitude : float<degLng> }
    member this.Latitude = this.latitude
    member this.Longitude = this.longitude
    static member Create (lat, lng) =
        if -90.<degLat> > lat || lat > 90.<degLat> then
            invalidArg "lat"
                "Latitude must be within the range -90 to 90."
        elif -180.<degLng> > lng && lng > 180.<degLng> then
            invalidArg "lng"
                "Longitude must be within the range -180 to 180."
        else { latitude = lat; longitude = lng }

type Place = { Name : City; Location : Location option }

(City "Houston, TX", City "San Mateo, CA")
|> lookupLocations
|> tryFindDistance
|> Option.map metersToFeet

type LookupLocations = City * City -> Place * Place

type TryFindDistance = Place * Place -> float<m> option

type MetersToFeet = float<m> -> float<ft>

type Show = Place * Place * float<ft> option -> string

type GetCityLocation = SqlCommandProvider<"
    SELECT City, Latitude, Longitude
    FROM [dbo].[CityLocations]
    WHERE City = @city
    ", ConnStr, SingleRow = true>

let lookupLocation (City name) =
    use cmd = new GetCityLocation()
    let result = cmd.Execute(name)
    match result with
    | Some p ->
        match p.Latitude, p.Longitude with
        | Some lat, Some lng ->
            { Name = City.Create(p.City)
              Location = Location.Create(
                            degreesLatitude lat,
                            degreesLongitude lng) |> Some }
        | _, _ ->
            { Name = City.Create(p.City); Location = None }
    | None -> { Name = City.Create(name); Location = None }

let lookupLocations (start, dest) =
    lookupLocation start, lookupLocation dest

open System.Device.Location
let toGeoCoordinate = function
    { latitude = lat; longitude = lng } ->
        GeoCoordinate(lat / 1.<degLat>, lng / 1.<degLng>)

let findDistance (start: Location, dest: Location) : float<m> =
    (start |> toGeoCoordinate).GetDistanceTo(dest |> toGeoCoordinate)
    * 1.<m>

let tryFindDistance : TryFindDistance = function
    | { Location = Some start }, { Location = Some dest } ->
        findDistance (start, dest) |> Some
    | _, _ -> None

[<Measure>] type m
[<Measure>] type ft

let metersToFeet (input: float<m>) =
    input * 3.2808399<ft/m>

let workflow =
    lookupLocations
    >> tryFindDistance
    >> Option.map metersToFeet

let rec receiveInput(start, dest) =
    let start', dest' = lookupLocations(start, dest)
    calculateDistance(start', dest')
and calculateDistance(start, dest) =
    match tryFindDistance(start, dest) with
    | Some distance ->
        showPlacesWithDistanceInMeters(start, dest, distance)
    | None -> showPlaces(start, dest, None)
and showPlacesWithDistanceInMeters(start, dest, distance) =
    showPlaces(start, dest, Some(metersToFeet distance))
and showPlaces(start, dest, distance) =
    serializeResult start dest distance

type Stage =
    | AwaitingInput
    | InputReceived of start : City * dest : City
    | Located of start : Place * dest : Place
    | Calculated of Place * Place * float<m> option
    | Show of Place * Place * float<ft> option

type RunWorkflow = Stage -> string

let rec runWorkflow = function
    | AwaitingInput -> runWorkflow AwaitingInput
    | InputReceived(start, dest) ->
        runWorkflow (Located(lookupLocations(start, dest)))
    | Located(start, dest) ->
        runWorkflow (Calculated(start, dest, tryFindDistance(start, dest)))
    | Calculated(start, dest, distance) ->
        runWorkflow (Show(start, dest, distance |> Option.map metersToFeet))
    | Show(start, dest, distance) -> serializeResult start dest distance

{
    "start": {
        "name": "Houston, TX",
        "location": {
            "latitude": 29.760427,
            "longitude": -95.369803
        }
    },
    "dest": {
        "name": "San Mateo, CA",
        "location": {
            "latitude": 31.700148,
            "longitude": -106.275785
        }
    },
    "distance": 3493771.738857
}

let distanceCalculator =
    freyaMachine {
        including common
        corsMethodsSupported [GET; OPTIONS]
        methodsSupported [GET; OPTIONS]
        handleOk getHandler }

let app =
    freyaRouter {
        resource "/calc{?start,dest}" distanceCalculator
    }

let mediaTypes =
    [ MediaType.Html; MediaType.Json
      MediaType.Css; MediaType.JavaScript]
let common =
    freyaMachine {
        using http
        using httpCors
        charsetsSupported Charset.Utf8
        corsHeadersSupported [ "accept"; "content-type" ]
        corsOriginsSupported AccessControlAllowOriginRange.Any
        languagesSupported (LanguageTag.parse "en")
        mediaTypesSupported mediaTypes }

let cities = freya {
    let! qs = Freya.Optic.get Request.query_
    let (Some [ "start", Some start
                "dest",  Some dest ]) = qs |> fst Query.pairs_
    return City.Create(urlDecode start),
           City.Create(urlDecode dest) }

let get = freya {
    let! cities = cities
    let stage = InputReceived cities
    return runWorkflow stage } |> Freya.memo

let getHandler _ = freya {
    let! json = get
    return represent json }