website/frontend/src/Cuckery/Helpers.elm

module Cuckery.Helpers exposing (..)

import Config.Colour exposing (..)
import Config.Format exposing (..)
import Cuckery.Types exposing (..)
import Effect exposing (Effect)
import Element exposing (..)
import Element.Border as D
import Element.Font as F
import Html.Attributes as H exposing (style)
import Layouts
import Page exposing (Page)
import Route exposing (Route)
import Shared
import View exposing (View)


makeDodge : Dodge -> Int -> Element msg
makeDodge dodgeEntry index =
    let
        formatProposition : String -> String
        formatProposition proposition =
            if proposition == "N/A" then
                proposition

            else
                "\"" ++ proposition ++ "\""
    in
    column paragraphAlignLeft
        [ row (paragraphFormat ++ [ F.size 18 ])
            [ text "    "
            , text (String.fromInt index ++ ". ")
            , paragraphLinkFormat
                { url = dodgeEntry.dodgeLink
                , label =
                    row [ F.size 18 ]
                        [ transitionHighlightedLinkHover <|
                            text
                                (case dodgeEntry.dodgeDescription of
                                    NoReply ->
                                        "Invitation extended with no response"

                                    RanAway ->
                                        "Engaged in written debate and ran away when cornered"

                                    GhostedMe ->
                                        "Debate invitation accepted with no follow-up"

                                    OutrightNo ->
                                        "Debate invitation declined"

                                    InTooDeep ->
                                        "Debate invitation accepted and subsequently retracted"

                                    KillScreen ->
                                        "All further debate invitations preemptively declined"
                                )
                        , text "." |> el [ F.color colourTheme.nonHighlightedText ]
                        ]
                }
            ]
        , row paragraphBoldFormat
            [ column [ alignTop, width <| px 184 ]
                [ text "                Proposition:"
                ]
            , column [ width <| px 350, alignLeft ] [ paragraph [ F.regular ] [ text (formatProposition dodgeEntry.dodgeProposition) ] ]
            ]
        , row (paragraphBoldFormat ++ [ width fill ])
            [ column [ alignTop, width <| px 184 ]
                [ text "                Doxastic State:"
                ]
            , column [ width <| px 350, alignLeft ]
                [ case dodgeEntry.dodgeNicksDoxasticState of
                    Nothing ->
                        paragraph [ F.regular ] [ text "I don't form a doxastic state." ]

                    Just Belief ->
                        paragraph [ F.regular ]
                            [ text "I lean more toward "
                            , el [ F.bold ] (text "TRUE")
                            , text " than false."
                            ]

                    Just Disbelief ->
                        paragraph [ F.regular ]
                            [ text "I lean more toward "
                            , text "FALSE" |> el [ F.bold ]
                            , text " than true."
                            ]

                    Just Agnostic ->
                        el [ F.regular ] (text "I don't form beliefs about this proposition.")
                ]
            ]
        , row (paragraphBoldFormat ++ [ width fill ])
            [ column [ alignTop, width <| px 184 ]
                [ text "                Reason:"
                ]
            , column [ width <| px 350, alignLeft ]
                [ paragraph [ F.regular ]
                    [ text <|
                        case dodgeEntry.dodgeNicksDoxasticReason of
                            NoProp ->
                                "There is no proposition to evaluate."

                            VagueProp ->
                                "The proposition is too vague to evaluate."

                            SpecificProp str ->
                                str
                    ]
                ]
            ]
        ]


cuckMaker : Cuck -> Element msg
cuckMaker cuck =
    row [ imageSpacer, alignLeft ]
        [ image
            [ centerX
            , centerY
            , alignTop
            , D.rounded 100
            , clip
            , width <| px 72
            ]
            { src = "cucks/" ++ cuck.cuckImage ++ ".png"
            , description = cuck.cuckName
            }
        , column
            paragraphAlignLeft
            [ row nonHighlightedTitleFormat [ text cuck.cuckName ]
            , row (paragraphBoldFormat ++ [ F.size 18 ])
                [ text "Social:"
                , paragraphLinkFormat
                    { url = cuck.cuckSocial
                    , label = transitionHighlightedLinkHover <| text (formatCuckSocial cuck.cuckSocial)
                    }
                ]
            , row (paragraphBoldFormat ++ [ F.size 18 ]) [ text "Dodges:" ]
            , column [ spacing 8 ] <|
                List.map2 (\x y -> makeDodge x y)
                    cuck.cuckDodges
                    (List.range 1 (List.length cuck.cuckDodges))
            ]
        ]