update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        NoOp ->
            ( model, Cmd.none )

        Mdl action_ ->
            Material.update Mdl action_ model

        SelectTab idx ->
            model
                |> pure

        TooltipMsg msg_ ->
            let
                updated =
                    Tuple.first <| Tooltip.update msg_ model.tooltip_
            in
            ( { model | tooltip_ = updated }, Cmd.none )

        ShuffleList ->
            { model | history = [] }
                |> effect
                    (Random.generate SetGame
                        (Random.pair (shuffle (createDominoes 6))
                            (selectWithDefault One [ One, Two, Three, Four ])
                        )
                    )
                |> updateBoardMsg NoBoard
                |> updateBlockedMsg Reset
                |> updateSelectionMsg Nothing
                |> updateStatusMsg ""
                |> updateHistoryToggleMsg False

        SetGame ( newSet, name ) ->
            case initializePlayers name newSet of
                Nothing ->
                    ( { model | game = ErrorGame }, Cmd.none )

                Maybe.Just players ->
                    { model | game = ActiveGame, players = players } ! [ cmd RunGame ]

        RealPlay index domino boardside ->
            case model.board of
                Nothing ->
                    let
                        current_player =
                            Zipper.current model.players

                        newHand =
                            removeDominoFromHand index current_player.hand

                        updated_player =
                            updatePlayerHand newHand current_player
                    in
                    model
                        |> effect (cmd ResolveTurn)
                        |> updatePlayerMsg updated_player
                        |> updateBlockedMsg Reset
                        |> updateBoardMsg (NewDom domino boardside)
                        |> updateHistoryMsg ( Four, domino )

                Maybe.Just board ->
                    case calculateHumanMatch domino boardside board of
                        Maybe.Just ( newDom, side ) ->
                            let
                                current_player =
                                    Zipper.current model.players

                                newHand =
                                    removeDominoFromHand index current_player.hand

                                updated_player =
                                    updatePlayerHand newHand current_player
                            in
                            model
                                |> effect (cmd ResolveTurn)
                                |> updatePlayerMsg updated_player
                                |> updateBlockedMsg Reset
                                |> updateBoardMsg (NewDom newDom side)
                                |> updateHistoryMsg ( Four, newDom )

                        Nothing ->
                            model
                                |> pure
                                |> updateStatusMsg "You can't play that there. Try Again :} "

        PlayerResponse response ->
            case response of
                Pass ->
                    model
                        ! [ cmd ResolveTurn ]
                        |> updateBlockedMsg Increment

                Play index domino ->
                    model
                        |> pure
                        |> updateSelectionMsg (Maybe.Just ( index, domino ))
                        |> updateButtonMsg True
                        |> updateStatusMsg "Now pick a side!"

        PopUpResponse boardSide ->
            case model.selection of
                Nothing ->
                    ( model, Cmd.none )

                Maybe.Just ( index, domino ) ->
                    model
                        |> effect (cmd <| RealPlay index domino boardSide)
                        |> updateSelectionMsg Nothing
                        |> updateButtonMsg False

        RunGame ->
            case .name (Zipper.current model.players) of
                Four ->
                    model
                        |> pure
                        |> updateStatusMsg "Your turn!"

                _ ->
                    model |> effect (cmd RobotResponse)

        RobotResponse ->
            case model.board of
                Nothing ->
                    let
                        newhand =
                            Zipper.current model.players
                                |> .hand
                                |> removeDominoFromHand 0

                        current_player =
                            Zipper.current model.players

                        domino =
                            getDominoForInitial current_player.hand

                        updated_player =
                            updatePlayerHand newhand current_player
                    in
                    case domino of
                        Nothing ->
                            model
                                |> pure

                        Maybe.Just domino ->
                            model
                                |> effect (cmd ResolveTurn)
                                |> updateBoardMsg (NewDom domino Left)
                                |> updatePlayerMsg updated_player
                                |> updateBlockedMsg Reset
                                |> updateHistoryMsg ( current_player.name, domino )

                Maybe.Just board ->
                    let
                        current_player =
                            Zipper.current model.players
                    in
                    case calculateMatch current_player.hand model.board of
                        Maybe.Just ( newDom, newHand, side ) ->
                            let
                                updated_player =
                                    updatePlayerHand newHand current_player
                            in
                            model
                                |> effect (cmd ResolveTurn)
                                |> updatePlayerMsg updated_player
                                |> updateBlockedMsg Reset
                                |> updateBoardMsg (NewDom newDom side)
                                |> updateHistoryMsg ( current_player.name, newDom )

                        Nothing ->
                            model
                                |> effect (cmd ResolveTurn)
                                |> updateBlockedMsg Increment

        ResolveTurn ->
            case List.length <| .hand <| Zipper.current model.players of
                0 ->
                    ( model, Cmd.none )
                        |> updateWinnerMsg EmptyHand
                        |> updateBlockedMsg Reset
                        |> updateBoardMsg NoBoard

                _ ->
                    case model.blocked of
                        4 ->
                            ( model, Cmd.none )
                                |> updateWinnerMsg Blocked
                                |> updateBlockedMsg Reset
                                |> updateBoardMsg NoBoard

                        _ ->
                            model
                                ! [ delay waitTime RunGame ]
                                |> updateActiveMsg
                                |> updateStatusMsg ""
                                |> updateButtonMsg False

        ReturnToHome ->
            model
                |> pure
                |> updateGameMsg NoGame
                |> updateBlockedMsg Reset
                |> updateStatusMsg ""
                |> updateBoardMsg NoBoard

        ToggleTooltips ->
            let
                toggle =
                    if model.tooltip == True then
                        False
                    else
                        True
            in
            ( { model | tooltip = toggle }, Cmd.none )

        ToggleHistory ->
            let
                historytoggle =
                    if model.showhistory == True then
                        False
                    else
                        True
            in
            model
                |> pure
                |> updateHistoryToggleMsg historytoggle


updateHistoryToggleMsg : Bool -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateHistoryToggleMsg bool ( model, cmsg ) =
    ( { model | showhistory = bool }, cmsg )


updateHistoryMsg : ( PlayerName, Domino ) -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateHistoryMsg entry ( model, cmsg ) =
    let
        newhistory =
            List.append model.history [ entry ]
    in
    ( { model | history = newhistory }, cmsg )


updateGameMsg : Game -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateGameMsg newgamestate ( model, cmsg ) =
    ( { model | game = newgamestate }, cmsg )


updateSelectionMsg : Maybe ( Int, Domino ) -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateSelectionMsg selection ( model, cmsg ) =
    ( { model | selection = selection }, cmsg )


updateButtonMsg : Bool -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateButtonMsg showy ( model, cmsg ) =
    ( { model | buttonToggle = showy }, cmsg )


updateStatusMsg : String -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateStatusMsg message ( model, cmsg ) =
    ( { model | statusupdate = message }, cmsg )


updateWinnerMsg : WinMessage -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateWinnerMsg message ( model, cmsg ) =
    case message of
        Blocked ->
            let
                ( name, score ) =
                    findPlayerWithLowest model.players

                message =
                    "His final score was just " ++ toString score ++ "!"
            in
            ( { model | game = WonGame name message }, cmsg )

        EmptyHand ->
            let
                winMessage : Domino -> String
                winMessage domino =
                    "The winning domino was " ++ dominoToString domino

                lastdom : Maybe String
                lastdom =
                    model.history
                        |> List.reverse
                        |> List.head
                        |> Maybe.map (\( _, domino ) -> winMessage domino)

                wonresult : String
                wonresult =
                    Maybe.withDefault "" lastdom

                lastPlayer =
                    .name (Zipper.current model.players)
            in
            ( { model | game = WonGame lastPlayer wonresult }, cmsg )


updateBoardMsg : BoardMessage -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateBoardMsg message ( model, cmsg ) =
    case message of
        NoBoard ->
            ( { model | board = Nothing }, cmsg )

        NewDom domino side ->
            ( { model | board = Maybe.Just (updateBoard domino side model.board) }, cmsg )


updateBlockedMsg : BlockedMessage -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateBlockedMsg bm ( model, cmsg ) =
    case bm of
        Reset ->
            ( { model | blocked = 0 }, cmsg )

        Increment ->
            ( { model | blocked = model.blocked + 1 }, cmsg )


updateActiveMsg : ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updateActiveMsg ( model, cmsg ) =
    ( { model | players = nextPlayer model.players }, cmsg )


updatePlayerMsg : Player -> ( Model, Cmd Msg ) -> ( Model, Cmd Msg )
updatePlayerMsg player ( model, cmsg ) =
    ( { model | players = updatePlayers player model.players }, cmsg )