module Decisions.View exposing (view)

import Dict
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (onClick)
import Decisions.Messages exposing (..)
import InputTable.View
import InputTable.Model
import Decisions.Model as Model
import Decisions.BulkDecisionsView as BulkDecisionsView


type alias Config =
    { rowLink : Maybe String
    , rowsAreSelectable : Bool
    , currentPage : Int
    }


view : Config -> Model.Model -> Html Msg
view config model =
    let
        tableState =
            model.tableState

        currentPage =
            if model.tableState.currentPage == 0 then
                config.currentPage
            else
                model.tableState.currentPage

        tableConfig =
            { getRowAttributes = Just (getCompleteAttribute model.incompleteColumnAndText)
            , rowLink = config.rowLink
            , currentPage = currentPage
            }

        tableState2 =
            { tableState
                | currentPage = currentPage
            }

        tableWithfilteredRows =
            { tableState2 | rows = getDecisionFilteredRows model.decisionFilter tableState.rows }

        pendingFilterClass =
            if model.decisionFilter == Model.UndecidedFilter then
                "table__tab table__tab--active"
            else
                "table__tab"

        decidedFilterClass =
            if model.decisionFilter == Model.DecidedFilter then
                "table__tab table__tab--active"
            else
                "table__tab"

        allFilterClass =
            if model.decisionFilter == Model.NoFilter then
                "table__tab table__tab--active"
            else
                "table__tab"
    in
        div []
            [ div
                [ class "table__wrapper" ]
                (if model.isLoadingInitialRows then
                    [ div
                        [ class "table__loading-message" ]
                        [ text "Loading table data" ]
                    , div
                        [ class "loader" ]
                        []
                    ]
                 else
                    [ div [ class "table__tabs-wrapper" ]
                        [ span [ class pendingFilterClass, onClick (SetDecisionFilter Model.UndecidedFilter) ] [ text "Pending" ]
                        , span [ class decidedFilterClass, onClick (SetDecisionFilter Model.DecidedFilter) ] [ text "Decided" ]
                        , span [ class allFilterClass, onClick (SetDecisionFilter Model.NoFilter) ] [ text "All" ]
                        , BulkDecisionsView.view model
                        , Html.map Decisions.Messages.Table
                            (InputTable.View.view tableConfig
                                { tableWithfilteredRows | rowsAreSelectable = config.rowsAreSelectable }
                            )
                        ]
                    ]
                )
            ]


getCompleteAttribute : Maybe ( Int, String ) -> InputTable.Model.Row Model.RowData -> List (Attribute msg)
getCompleteAttribute incompleteColumnAndText row =
    case incompleteColumnAndText of
        Nothing ->
            []

        Just ( incompleteColumnIndex, incompleteText ) ->
            let
                complete =
                    Dict.get (toString incompleteColumnIndex) row.data.stringDictData
            in
                case complete of
                    Just cell ->
                        if cell.value == incompleteText then
                            [ class "table__row table__row--incomplete-submission" ]
                        else
                            [ class "table__row" ]

                    _ ->
                        [ class "table__row" ]


getDecisionFilteredRows : Model.DecisionFilter -> List (InputTable.Model.Row Model.RowData) -> List (InputTable.Model.Row Model.RowData)
getDecisionFilteredRows decisionFilter rows =
    List.filter
        (case decisionFilter of
            Model.DecidedFilter ->
                (\row -> (row.data.decision) /= "Pending")

            Model.UndecidedFilter ->
                (\row -> (row.data.decision) == "Pending")

            Model.NoFilter ->
                (\row -> True)
        )
        rows