module Main (main) where

import Control.Monad.Eff (Eff)
import Data.Array (catMaybes) as Array
import Data.Maybe (Maybe(..))
import Data.Traversable (sequence, sequence_) as Traversable
import DOM (DOM)
import DOM.Node.ParentNode (QuerySelector(..))
import DOM.Node.Types (elementToNode) as DOM
import DOM.Node.Types (Node)
import Prelude

import Dom (selectElement, selectElements, onInput, setValue, selectElementFrom) as Dom
import EditableNumber (NumberElem)
import EditableNumber (set) as EditableNumber
import Number (format) as Number
import Parser (number) as Parser

main :: forall e. Eff (dom :: DOM | e) Unit
main = do
  tagElems <- getNumberElements
  numberElems <- Array.catMaybes <$> (Traversable.sequence $ map EditableNumber.set tagElems)
  Traversable.sequence_ $ map (onInput numberElems) numberElems

getNumberElements :: forall e. Eff (dom :: DOM | e) (Array { tag :: String, node :: Node })
getNumberElements = do
  let fromElem tag elem = { tag: tag, node: DOM.elementToNode elem }
  h1 <- map (fromElem "h1") <$> Dom.selectElement (QuerySelector "h1")
  lis <- map (fromElem "li") <$> Dom.selectElements (QuerySelector "ul > li")
  pure $ (maybeToArray h1 <> lis)

onInput :: forall e. Array NumberElem -> NumberElem -> Eff (dom :: DOM | e) Unit
onInput numberElems { elem, number } = do
  Dom.onInput elem (\value -> do
    case Parser.number value of
      Just newNumber ->
        numberElems
          # map (\ne -> do
              inputNode <- Dom.selectElementFrom ne.elem (QuerySelector "input")
              case inputNode of
                Just node -> Dom.setValue (Number.format (ne.number / number * newNumber)) node
                _ -> pure unit
            )
          # Traversable.sequence_
      _ ->
        pure unit
  )

maybeToArray :: forall a. Maybe a -> Array a
maybeToArray (Just x) = [ x ]
maybeToArray _ = []