Main.gren

module Main exposing (main)

import Node
import Bytes exposing (Bytes)
import Dict
import Stream
import Node exposing (Environment, Program)
import FileSystem
import FileSystem.Path as Path
import HttpServer as Http exposing (ServerError(..), Method(..))
import HttpServer.Response as Response exposing (Response)
import Init
import Json.Decode as Decode
import Task exposing (Task)


main : Program Model Msg
main =
    Node.defineProgram
        { init = init
        , update = update
        , subscriptions = subscriptions
        }


type alias Model =
    { stdout : Stream.Writable Bytes
    , stderr : Stream.Writable Bytes
    , server : Maybe Http.Server
    , fsPermission : FileSystem.Permission
    }


type Msg
    = CreateServerResult (Result Http.ServerError Http.Server)
    | GotRequest { request : Http.Request, response : Response }
    | GotJpeg { response : Response, result : (Result FileSystem.Error Bytes) }


init : Environment -> Init.Task { model : Model, command : Cmd Msg }
init env =
    Init.await FileSystem.initialize <| \fileSystemPermission ->
        Init.await Http.initialize <| \serverPermission ->
            Node.startProgram
                { model =
                    { stdout = env.stdout
                    , stderr = env.stderr
                    , server = Nothing
                    , fsPermission = fileSystemPermission
                    }
                , command =
                    Task.attempt CreateServerResult <|
                        Http.createServer serverPermission
                            { host = "0.0.0.0"
                            , port_ = 3000
                            }
                }


update : Msg -> Model -> { model : Model, command : Cmd Msg }
update msg model =
    when msg is
        CreateServerResult result ->
            when result is
                Ok server ->
                    { model = { model | server = Just server }
                    , command = 
                        Stream.writeLineAsBytes "Server started" model.stdout 
                            |> Task.map (\_ -> {})
                            |> Task.onError (\_ -> Task.succeed {})
                            |> Task.execute
                    }
                Err (ServerError { code, message }) ->
                    { model = model
                    , command =
                        Stream.writeLineAsBytes ("Server failed to start: " ++ code ++ "\n" ++ message) model.stderr
                            |> Task.map (\_ -> {})
                            |> Task.onError (\_ -> Task.succeed {})
                            |> Task.execute
                    }
        
        GotRequest { request = req, response = res } ->
            { model = model
            , command = 
                if req.url.path == "/george.jpeg" then
                    FileSystem.readFile model.fsPermission (Path.fromPosixString "./public/george.jpeg")
                        |> Task.attempt (\fileOp -> GotJpeg { response = res, result = fileOp })
                else
                    htmlResponse req res
            }
        
        GotJpeg { response, result = (Ok bytes) } ->
            { model = model
            , command =
                response
                    |> Response.setHeader "Content-Type" "image/jpeg"
                    |> Response.setStatus 200
                    |> Response.setBodyAsBytes bytes
                    |> Response.send
            }

        GotJpeg { response, result = (Err _) } ->
            { model = model
            , command =
                response
                    |> Response.setHeader "Content-Type" "text/plain"
                    |> Response.setStatus 404
                    |> Response.setBody "Not found"
                    |> Response.send
            }


htmlResponse : Http.Request -> Response -> Cmd Msg
htmlResponse req res =
    let
        { body, status } = when { method = req.method, path = req.url.path } is
            { method = GET, path = "/" } ->
                { body = "Welcome!"
                , status = 200
                }

            { method = GET, path = "/hello" } ->
                { body = "Hello to you too!"
                , status = 200
                }

            { method = POST, path = "/name" } ->
                { body = "Hello, " ++
                    ( req
                        |> Http.bodyFromJson (Decode.dict Decode.string)
                        |> Result.withDefault Dict.empty
                        |> Dict.get "name"
                        |> Maybe.withDefault "Oops! Can't decode body."
                    )
                , status = 200
                }
            
            { method = POST } ->
                { body = "You posted: " ++
                    ( req
                        |> Http.bodyAsString
                        |> Maybe.withDefault "Oops! Can't decode body."
                    )
                , status = 200
                }

            _ ->
                { body = "Not found: " ++ (Http.requestInfo req)
                , status = 404
                }
    in
    res
        |> Response.setStatus status
        |> Response.setHeader "Content-type" "text/html"
        |> Response.setHeader "X-Custom-Header" "hey there"
        |> Response.setBody body
        |> Response.send


subscriptions : Model -> Sub Msg
subscriptions model =
    when model.server is
        Just server ->
            Http.onRequest server <| \req res -> GotRequest { request = req, response = res }

        Nothing ->
            Sub.none