open FSharp.Data

type GetTodos = SqlCommandProvider<"
    select Id, Title, Completed, [Order] from Todo", connectionString>
type GetTodo = SqlCommandProvider<"
    select Id, Title, Completed, [Order] from Todo where Id = @id
    ", connectionString, SingleRow = true>

let result =
    async {
        use cmd = new GetTodo()
        return! cmd.AsyncExecute(id = 1) }
    |> Async.RunSynchronously

let todo1 = GetTodo.Record(0, "New todo", false, 1)
let todo2 = GetTodo.Record(Id = 0, Title = "New todo",
                           Completed = false, Order = 2)

type Req = HttpRequestMessage
type Res = HttpResponseMessage

type Http = Req -> Res

type HttpWebApi = Req -> Task<Res>

type HttpFSharp = Req -> Async<Res>

type HiddenState = Req -> Async<Res>

type ExplicitState<'T> =
    Req ->
     // Retrieve resource state from the `Req`
     (Req -> Async<'T>) ->
     // Execute domain logic
     ('T -> 'T) ->    // or ('T -> Async<'T>)
     // Generate the response
     Async<Res>

[<Sealed>]
type Startup() =
    member __.Configuration(builder: IAppBuilder) =
        let config = new HttpConfiguration()
        config.MapHttpAttributeRoutes()
        builder
            .UseCors(Cors.CorsOptions.AllowAll)
            .UseWebApi(config)
        |> ignore

[<RoutePrefix("webapi")>]
[<Route("")>]
type TodosController() =
    inherit ApiController()

    member this.GetTodos() =
        async {
            let! todos = Sql.store.GetAll()
            let todos' =
                todos
                |> Array.map (fun x ->
                    let baseUri = this.Request.RequestUri.AbsoluteUri
                    { Url = Uri(baseUri + x.Id.ToString())
                      Title = x.Title
                      Completed = x.Completed
                      Order = x.Order })
            return this.Request.CreateResponse(todos') }
        |> Async.StartAsTask

let handle (request: Req) = async {
    let! todos = Sql.store.GetAll()
    let todos' =
        todos
        |> Array.map (fun x ->
            let baseUri = request.RequestUri.AbsoluteUri
            { Url = Uri(baseUri + x.Id.ToString())
              Title = x.Title
              Completed = x.Completed
              Order = x.Order })
    return request.CreateResponse(todos') }

[<Route("webapi")>]
type TodoController() =
    inherit ApiController()
    member this.GetTodos(request) =
        handle request |> Async.StartAsTask

let getResource (request: Req) = async {
    let! todos = Sql.store.GetAll()
    return request.RequestUri, todos }

let mapValues (uri: Uri, todos: NewTodo[]) =
    let todos' =
        todos
        |> Array.map (fun x ->
            { Url = Uri(uri.AbsoluteUri + x.Id.ToString())
              Title = x.Title
              Completed = x.Completed
              Order = x.Order })
        |> Seq.toArray
    uri, todos'

let makeHandler (request: Req) requestF domainF = async {
    let! res = requestF request
    let (_, values) = domainF res
    return request.CreateResponse(values) }

let handler request = makeHandler request getResource mapValues

module Domain =
    let domainLogic (value: string) = value.ToUpper()

module Web =
    let unwrapRequest (request: Req) = async {
        return! request.Content.ReadAsStringAsync() |> Async.AwaitTask }

    let wrapResponse value (request: Req) = request.CreateResponse(value)

module App =
    let handle request = async {
        let! value = Web.unwrapRequest request
        let value' = Domain.domainLogic value
        return Web.wrapResponse value' request }

open Frank
open System.Web.Http.HttpResource

module Sample =
    let getHandler (request: Req) = async {
        return request.CreateResponse() }

    let postHandler (request: Req) = async {
        let! value = request.Content.ReadAsStringAsync() |> Async.AwaitTask
        // Do something with value
        return request.CreateResponse(HttpStatusCode.Created, value) }

    let sampleResource =
        routeResource "/api/sample"
                    [ get getHandler
                      post postHandler ]
    
    let registerSample config = config |> register [sampleResource]