module Main exposing (main)

import Browser
import Sort.Set as Set exposing (Set)
import Html exposing (Html, button, div, h2, h3, input, label, p, section, text, span, h3)
import Html.Events exposing (onCheck, onClick)
import Html.Attributes exposing (class, type_, id)
import Html.Attributes exposing (attribute)

import License exposing (License, DownloadType (..))
import License.Hippocratic as Hippocratic
import License.NPL as NPL

main: Program () Model Msg
main =
  Browser.element
    { init = init
    , update = update
    , view = view
    , subscriptions = subscriptions
    }

subscriptions : Model -> Sub Msg
subscriptions _ = Sub.none

-- INIT + Model

type SelectedLicense
  = Hippocratic
  | NPL
availableLicenses : List SelectedLicense
availableLicenses = [ Hippocratic, NPL ]

type alias Model =
  { selected : SelectedLicense
  , hippocratic : License Hippocratic.Module
  , npl : License NPL.Module
  }

selectedInfo : SelectedLicense -> License.LicenseDescriptors
selectedInfo selected =
  case selected of
    Hippocratic -> Hippocratic.info.descriptors
    NPL -> NPL.info.descriptors

init : () -> (Model, Cmd Msg)
init () =
  (
    { selected = Hippocratic
    , hippocratic = License.empty Hippocratic.info
    , npl = License.empty NPL.info
    }
  , Cmd.none
  )

-- UPDATE

type Msg
  = SwitchLicense SelectedLicense
  | ToggleModule AnyModule Bool
  | Download License.DownloadType

type AnyModule
  = HippocraticMod Hippocratic.Module
  | NPLMod NPL.Module

type alias ModuleWrapper mtype = mtype -> AnyModule

update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
  case msg of
    SwitchLicense newLicense ->
      ( { model | selected = newLicense }
      , Cmd.none
      )
    ToggleModule mod enabled ->
      ( case mod of
          HippocraticMod modu ->
            { model | hippocratic = License.toggleModule enabled modu model.hippocratic }
          NPLMod modu ->
            { model | npl = License.toggleModule enabled modu model.npl }
      , Cmd.none
      )
    Download dtype ->
      ( model
      , case model.selected of
          Hippocratic -> License.download dtype model.hippocratic
          NPL -> License.download dtype model.npl
      )

-- VIEW

view_module_button : ModuleWrapper moduleType -> (moduleType -> License.ModuleInfo) -> Set moduleType -> moduleType -> Html Msg
view_module_button wrapModule moduleInfo enabled mod =
  label
    (class "module-button"
      :: (if Set.memberOf enabled mod then [class "active"] else [])
      )
    [ div []
      [ div [class "cooler-checkbox"]
        [ input
          [ type_ "checkbox"
          , onCheck (ToggleModule (wrapModule mod))
          ] []
        ]
      , h3 [] [ text (.name (moduleInfo mod)) ]
      , Html.map never (p [] (.desc (moduleInfo mod)))
      ]
    ]

viewLicenseChooser : SelectedLicense -> Html Msg
viewLicenseChooser selected =
  div
    [ id "license-chooser" ]
    [ selected
      |> selectedInfo
      |> viewLicenseInfo
      |> Html.map never
    , div [ id "available-licenses" ]
      ( availableLicenses
        |> List.map (selectableLicense selected)
      )
    ]

viewLicenseInfo : License.LicenseDescriptors -> Html Never
viewLicenseInfo info =
  div [ id "selected-license" ]
    [ h2 [] [text info.name]
    , p [] [text info.desc]
    ]

selectableLicense : SelectedLicense -> SelectedLicense -> Html Msg
selectableLicense currentlySelected license =
  button
    ( [ onClick (SwitchLicense license)
      , class "selectable-license"
      ]
        ++ if currentlySelected == license then [class "active"] else []
    )
    [ span []
      [ text (.slug (selectedInfo license))
      ]
    ]

view_modules : ModuleWrapper moduleType -> License moduleType -> Html Msg
view_modules wrap license =
  section [id "modules"] (
      license.info.availableModules
        |> List.map (view_module_button wrap license.info.moduleInfo license.activeModules)
  )

view_cooler_button : String -> msg -> Html msg
view_cooler_button name message =
  button
    [ class "cool-button"
    , onClick message
    ]
    [ div
      [ class "bevel"
      , class "tr"
      , attribute "aria-hidden" "true"
      ] []
    , div [] [ text name ]
    , div
      [ class "bevel"
      , class "bl"
      , attribute "aria-hidden" "true"
      ] []
    ]

view_download_button : (String, DownloadType) -> Html Msg
view_download_button (name, dtype) =
  view_cooler_button name (Download dtype)

downloads : Html Msg
downloads =
  section [id "downloads"]
    ( List.map view_download_button
      [ ("Markdown", Markdown)
      --, ("Plaintext", Plain)
      --, ("HTML", Html)
      ]
    )

divider : String -> Html Never
divider sectionName =
  div [class "divider"]
    [ div [] []
    , h3 [] [text sectionName]
    , div [] []
    ]

view : Model -> Html Msg
view model =
  div [id "elm-area"]
    [ viewLicenseChooser model.selected
    , Html.map never (divider "Customize")
    , case model.selected of
        Hippocratic -> view_modules HippocraticMod model.hippocratic
        NPL -> view_modules NPLMod model.npl
    , Html.map never (divider "Download")
    , downloads
    ]