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 ++ "\""

        maybeFallacyField : Element msg
        maybeFallacyField =
            case dodgeEntry.dodgeFallacy of
                Nothing ->
                    none

                Just fallacy ->
                    case fallacy of
                        SpecificFallacy str ->
                            if String.isEmpty str then
                                none

                            else
                                displayFallacy str

                        AppealToNature ->
                            displayFallacy "Appeal to Nature"

                        AppealToTradition ->
                            displayFallacy "Appeal to Tradition"

                        AppealToIgnorance ->
                            displayFallacy "Appeal to Ignorance"

                        AppealFromIncredulity ->
                            displayFallacy "Appeal from Incredulity"

                        RedHerring ->
                            displayFallacy "Red Herring"

                        BeggingTheQuestion ->
                            displayFallacy "Begging the Question"

                        Strawman ->
                            displayFallacy "Strawman"

                        Equivocation ->
                            displayFallacy "Equivocation"

                        GeneticFallacy ->
                            displayFallacy "Genetic Fallacy"

                        MotteAndBailey ->
                            displayFallacy "Motte and Bailey"

        displayFallacy : String -> Element msg
        displayFallacy fallacyText =
            row paragraphBoldFormat
                [ column [ alignTop, width (px 184) ]
                    [ text "Fallacy:" |> el [ paddingEach { top = 0, right = 0, bottom = 0, left = 70 } ]
                    ]
                , column [ width (px 350), alignLeft ]
                    [ paragraph [ F.regular ]
                        [ text fallacyText ]
                    ]
                ]
    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 ->
                                        "Debate 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"

                                    VagueGesture ->
                                        "Chose to gesture vaguely instead of engaging"
                                )
                        , text "." |> el [ F.color colourTheme.nonHighlightedText ]
                        ]
                }
            ]
        , row paragraphBoldFormat
            [ column [ alignTop, width <| px 184 ]
                [ text "Proposition:" |> el [ paddingEach { top = 0, right = 0, bottom = 0, left = 70 } ]
                ]
            , column [ width <| px 350, alignLeft ] [ paragraph [ F.regular ] [ text (formatProposition dodgeEntry.dodgeProposition) ] ]
            ]
        , maybeFallacyField
        , row (paragraphBoldFormat ++ [ width fill ])
            [ column [ alignTop, width <| px 184 ]
                [ text "Doxastic State:" |> el [ paddingEach { top = 0, right = 0, bottom = 0, left = 70 } ]
                ]
            , 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:" |> el [ paddingEach { top = 0, right = 0, bottom = 0, left = 70 } ]
                ]
            , 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."

                            SpecificPropReason 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 ++ "/" ++ 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))
            ]
        ]
