module Cuckery.Helpers exposing (..)

import Config.CardFormat exposing (..)
import Config.Colour exposing (..)
import Config.Format exposing (..)
import Cuckery.Types exposing (..)
import Effect exposing (Effect)
import Element as E exposing (..)
import Element.Background as B 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)


cuckMaker : Cuck -> Element msg
cuckMaker cuck =
    row
        topLevelBox
        [ cardImageMaker (cuckImage cuck)
        , cardMaker
            [ cardTitleMaker (cuckTitle cuck)
            , cardFormatter
                [ cardContentSpacing
                    [ column
                        fieldSpacer
                        [ socialMaker cuck
                        , dodgeTitle cuck
                        , dodgeMaker cuck
                        ]
                    ]
                ]
            ]
        ]


cuckImage :
    Cuck
    ->
        { src : String
        , description : String
        }
cuckImage cuck =
    { src = "cucks/" ++ cuck.cuckImage ++ "/" ++ cuck.cuckImage ++ ".png"
    , description = cuck.cuckName
    }


cuckTitle : Cuck -> String
cuckTitle cuck =
    cuck.cuckName


dodgeMaker : Cuck -> Element msg
dodgeMaker cuck =
    column
        [ spacing 15
        , width fill
        ]
    <|
        List.map2 (\x y -> makeDodge x y)
            cuck.cuckDodges
            (List.range 1 (List.length cuck.cuckDodges))


socialMaker : Cuck -> Element msg
socialMaker cuck =
    row
        (paragraphBoldFormat
            ++ [ F.size 18
               , spacing 8
               ]
        )
        [ text "Social:"
        , paragraphLinkFormat
            { url = cuck.cuckSocial
            , label = transitionHighlightedLinkHover <| text (formatCuckSocial cuck.cuckSocial)
            }
        ]


dodgeTitle : Cuck -> Element msg
dodgeTitle cuck =
    row
        (paragraphBoldFormat
            ++ [ F.size 18
               ]
        )
        [ text "Dodges:" ]


makeDodge : Dodge -> Int -> Element msg
makeDodge dodgeEntry index =
    column
        (paragraphAlignLeft
            ++ [ spacing 8
               , width fill
               ]
        )
        [ row
            [ width fill
            , paddingEach
                { top = 0
                , right = 0
                , bottom = 0
                , left = 35
                }
            ]
            [ column
                (paragraphFormat
                    ++ [ F.size 18
                       , alignTop
                       , alignRight
                       , F.alignRight
                       ]
                )
                [ text (String.fromInt index ++ ". ") ]
            , column
                [ spacing 8
                , width fill
                ]
                [ circumstanceMaker dodgeEntry
                , column
                    [ spacing 8
                    , width fill
                    ]
                    [ propositionMaker dodgeEntry
                    , reductioMaker dodgeEntry
                    , attitudeMaker dodgeEntry
                    , reasonMaker dodgeEntry
                    ]
                ]
            ]
        ]


dodgeWidth =
    width <| px 93


formatProposition : String -> String
formatProposition proposition =
    if proposition == "N/A" then
        proposition

    else
        "\"" ++ proposition ++ "\""


dodgeCounter : Int -> Element msg
dodgeCounter index =
    column
        (paragraphFormat
            ++ [ F.size 18
               ]
        )
        [ text (String.fromInt index ++ ". ") ]


circumstanceMaker : Dodge -> Element msg
circumstanceMaker dodgeEntry =
    column
        [ width fill
        ]
        [ 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.textLightGrey ]
                    , row [ alignTop, alignLeft ]
                        (List.indexedMap
                            (\index2 link ->
                                newTabLink
                                    [ paddingEach
                                        { top = 0
                                        , right = 15
                                        , bottom = 0
                                        , left = 5
                                        }
                                    , F.size 13
                                    ]
                                    { url = link
                                    , label =
                                        row []
                                            [ transitionHighlightedLinkHover <| (text (String.fromInt (index2 + 1)) |> el [ F.size 13 ])
                                            , text ", " |> el [ F.color colourTheme.textLightGrey ]
                                            ]
                                    }
                            )
                            dodgeEntry.dodgeReceipts
                        )
                    ]
            }
        ]


propositionMaker : Dodge -> Element msg
propositionMaker dodgeEntry =
    row paragraphBoldFormat
        [ column
            [ alignTop
            , dodgeWidth
            ]
            [ text "Proposition:"
            ]
        , column
            [ E.width fill
            , alignLeft
            ]
            [ paragraph [ F.regular ] [ text (formatProposition dodgeEntry.dodgeProposition) ]
            ]
        ]


attitudeMaker : Dodge -> Element msg
attitudeMaker dodgeEntry =
    row (paragraphBoldFormat ++ [ width fill ])
        [ column
            [ alignTop
            , dodgeWidth
            ]
            [ text "Attitude:"
            ]
        , column
            [ E.width fill
            , 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.")
            ]
        ]


reductioMaker : Dodge -> Element msg
reductioMaker dodgeEntry =
    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"


reasonMaker : Dodge -> Element msg
reasonMaker dodgeEntry =
    row (paragraphBoldFormat ++ [ width fill ])
        [ column
            [ alignTop
            , dodgeWidth
            ]
            [ text "Reason:"
            ]
        , column
            [ E.width fill
            , 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
                ]
            ]
        ]


displayFallacy : String -> Element msg
displayFallacy fallacyText =
    row paragraphBoldFormat
        [ column
            [ alignTop
            , dodgeWidth
            ]
            [ text "Fallacy:"
            ]
        , column
            [ E.width fill
            , alignLeft
            ]
            [ paragraph [ F.regular ]
                [ text fallacyText ]
            ]
        ]