module Page.Admin exposing (Model)

import Api exposing (Loot)
import Api.Player as Player exposing (Player, Wealth)
import Browser.Navigation as Nav
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Page.Shop as Shop
import Route exposing (Route)
import Session exposing (Session)


type alias NewPlayerForm =
    { name : String
    , wealth : Float
    }


type alias Status =
    { session : Session
    , players : List Player
    , newPlayer : NewPlayerForm
    }


type Model
    = Dashboard Status
    | MerchantLoot Shop.Model


init : Session -> ( Model, Cmd Msg )
init session =
    ( Dashboard (Status session [] (NewPlayerForm "" 0.0))
    , Player.list GotPlayers
    )


getSession model =
    case model of
        Dashboard status ->
            Session.getSession status

        MerchantLoot shop ->
            Session.getSession shop


view : Model -> List (Html Msg)
view model =
    case model of
        Dashboard config ->
            [ div [ class "container" ]
                [ p [ class "title" ] [ text "Administration" ]
                , div [ class "section" ]
                    [ table [ class "table is-fullwidth is-striped" ]
                        [ thead [ class "table-header" ]
                            [ th [] [ text "Joueurs" ] ]
                        , tbody [] <|
                            editNewPlayer config.newPlayer
                                :: List.map viewPlayer config.players
                        ]
                    ]
                , div [ class "section" ]
                    [ p [] [ text "Campagnes" ] ]
                ]
            ]

        MerchantLoot shop ->
            let
                toShopMsg =
                    Html.map ShopMsg

                ( controls, viewShop ) =
                    Shop.view shop
                        |> Tuple.mapBoth toShopMsg (List.map toShopMsg)
            in
            [ div [ class "container" ] <|
                p [ class "title" ] [ text "Marchand" ]
                    :: controls
                    :: viewShop
            ]


viewPlayer : Player -> Html Msg
viewPlayer player =
    tr [] [ td [] [ p [] [ text (player.name ++ " (" ++ String.fromInt player.id ++ ")") ] ] ]


editNewPlayer : NewPlayerForm -> Html Msg
editNewPlayer newPlayer =
    tr []
        [ td []
            [ div [ class "field is-horizontal" ]
                [ div [ class "field-body" ]
                    [ div [ class "field" ]
                        [ input
                            [ class "input"
                            , type_ "text"
                            , value newPlayer.name
                            , onInput <| GotFormMsg << NameChanged
                            ]
                            []
                        ]
                    , div [ class "field" ]
                        [ input
                            [ class "input"
                            , type_ "text"
                            , value <| String.fromFloat newPlayer.wealth
                            , onInput <| GotFormMsg << WealthChanged
                            ]
                            []
                        ]
                    ]
                ]
            ]
        ]


type Msg
    = GotPlayers (List Player)
    | GotFormMsg FormMsg
    | ShopMsg Shop.Msg


type FormMsg
    = NameChanged String
    | WealthChanged String


updateForm : FormMsg -> NewPlayerForm -> NewPlayerForm
updateForm msg form =
    case msg of
        NameChanged newName ->
            { form | name = newName }

        WealthChanged newWealth ->
            { form | wealth = Maybe.withDefault 0.0 <| String.toFloat newWealth }


routeChanged : Route.Route -> Model -> ( Model, Cmd Msg )
routeChanged route model =
    case model of
        Dashboard config ->
            case route of
                Route.Home Route.MerchantLoot ->
                    Tuple.mapBoth
                        MerchantLoot
                        (Cmd.map ShopMsg)
                        (config.session |> Shop.init)

                _ ->
                    ( model, Cmd.none )

        MerchantLoot shop ->
            case route of
                Route.Home Route.PlayerLoot ->
                    init shop.session

                _ ->
                    ( model, Cmd.none )


update msg model =
    case ( msg, model ) of
        ( GotPlayers players, Dashboard config ) ->
            ( Dashboard { config | players = players }, Cmd.none )

        ( GotFormMsg formMsg, Dashboard config ) ->
            ( Dashboard { config | newPlayer = updateForm formMsg config.newPlayer }, Cmd.none )

        ( _, Dashboard _ ) ->
            ( model, Cmd.none )

        ( ShopMsg shopMsg, MerchantLoot shopModel ) ->
            Shop.update shopMsg shopModel
                |> Tuple.mapBoth
                    MerchantLoot
                    (Cmd.map ShopMsg)

        ( _, MerchantLoot _ ) ->
            ( model, Cmd.none )