Main.elm

module Main exposing (Model, Msg)

import Browser
import Browser.Navigation as Nav
import Html exposing (..)
import Html.Attributes exposing (..)
import Url
import Url.Parser as Parser exposing (Parser, oneOf, s, top)
-- import Types

-- MAIN


main : Program () Model Msg
main =
    Browser.application
        { init = init
        , view = view
        , update = update
        , subscriptions = \_ -> Sub.none
        , onUrlChange = UrlChanged
        , onUrlRequest = LinkClicked
        }



-- MODEL


type Page
    = Home
    | Outra
    | NotFound


type alias Model =
    { key : Nav.Key
    , url : Url.Url
    , page : Page
    }


init : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
init flags url key =
    ( Model key url Home, Cmd.none )



-- UPDATE


type Msg
    = LinkClicked Browser.UrlRequest
    | UrlChanged Url.Url


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        LinkClicked urlRequest ->
            case urlRequest of
                Browser.Internal url ->
                    ( model, Nav.pushUrl model.key (Url.toString url) )

                Browser.External href ->
                    ( model, Nav.load href )

        UrlChanged url ->
            case parseUrl url of
                Home ->
                    ({model | page = Home, url = url}, Cmd.none)
                Outra ->
                   ({model | page = Outra, url = url}, Cmd.none)
                NotFound ->
                    ({model | page = NotFound, url = url}, Cmd.none)


-- router
-- ( { model | url = url }
-- , Cmd.none
-- )
-- ROUTER


-- parseUrl : Url.Url -> Model -> ( Model, Cmd Msg )
-- parseUrl url model =
--     let
--         parser =
--             oneOf
--                 [ Parser.map ( { model | page = Types.Home}, Cmd.none ) top
--                 , Parser.map ( { model | page = Types.Outra}, Cmd.none ) (s "outra")
--                 ]
                
--     in
--     case Parser.parse parser url of
--         Just answer ->
--             answer

--         Nothing ->
--             ( { model | url = url }, Cmd.none )

parseUrl : Url.Url -> Page
parseUrl url =
    let
        parser =
            oneOf
                [ Parser.map Home top
                , Parser.map Outra (s "outra")
                ]
                
    in
    case Parser.parse parser url of
        Just answer ->
            answer

        Nothing ->
            NotFound



-- VIEW


view : Model -> Browser.Document Msg
view model =
    case model.page of
        Home ->
            { title = "URL Interceptor"
            , body =
                [ text "The current URL is: "
                , b [] [ text (Url.toString model.url) ]
                , ul []
                    [ viewLink "/"
                    , viewLink "/profile"
                    , viewLink "/reviews/the-century-of-the-self"
                    , viewLink "/reviews/public-opinion"
                    , viewLink "/reviews/shah-of-shahs"
                    , viewLink "/outra"
                    ]
                ]
            }
        Outra ->
            { title = "Outra página"
            , body =
                [ viewLink "/"
                , text "Outra"]
            }
        NotFound ->
            { title = "Page not found"
            , body =
                [ viewLink "/"
                , text "Page not Found"]}

viewLink : String -> Html msg
viewLink path =
    li [] [ a [ href path ] [ text path ] ]