instance childReceiverBuilder2 :: ReceiverBuilder ChildStreamReceiverBuilder (Observable (VDomBuilder e)) e  where

instance childrenStreamReceiverBuilder2 :: (Traversable t) => ReceiverBuilder ChildrenStreamReceiverBuilder (Observable (t (VDomBuilder e))) e where

module Main where

-- import OutWatch
import Prelude
import OutWatch.Sink as Sink
import RxJS.Observable as Observable
import Builder (class AttributeBuilder, class ReceiverBuilder)
import Control.Alt (map)
import Control.Monad.Aff.Console (CONSOLE)
import Control.Monad.Eff (Eff)
import Control.Monad.Eff.Console (log, logShow)
import Control.Monad.RWS.Trans (lift)
import Control.Monad.State (class MonadState, State, StateT(..), execState, execStateT, modify)
import DOM.Node.Types (Element)
import Data.Array (cons, snoc, replicate)
import Data.Array.Partial (head)
import Data.CommutativeRing ((+))
import Data.EuclideanRing ((/))
import Data.Int (round)
import Data.Monoid ((<>))
import Data.Unit (Unit)
import EmitterBuilder (class EmitterBuilder, emitFrom)
import OutWatch (children, createHandler, li, render, src, ul, valueShow, (==>))
import OutWatch (childShow, createNumberHandler, div, img, (:=))
import OutWatch.Attributes (inputNumber, insert, max, text, tpe, (<==))
import OutWatch.Sink (Handler, Observer(..), SinkLike, create)
import OutWatch.Tags (br, hr, input)
import Partial.Unsafe (unsafePartial)
import R.Yolo (x)
import RxJS.Observable (Observable, combineLatest, interval, startWith)
import VDomModifier (VDom)


main :: Eff _ Unit
main = do 
    log "start"
    -- render "#app" app
    (unsafeFirst <$> build test) >>= render "#app"
    log "done"


test2 :: forall e. Number -> VDomBuilder e Unit
test2 max = do
    let def = 0.0
    h <- createHandlerE [def]
    let imageLists = h.src # map (\n -> replicate (round n) (img[src := "img.svg"]))        
    ul_ do
        input_ do
            type_ "range"
            inputNumber_ h
            valueShow_ def
            max_ max
        div_ (children_ imageLists)
        div_ (childShow_ h.src)

test :: forall e. VDomBuilder e Unit
test = ul_ do
    h <- createHandlerE [2.0]
    input_ do
        type_ "number"
        inputNumber_ h
            
    hr_ (pure unit)
    li_ do
        text_ "the cat is  "
        text_ "nice"
    li_ (text_ "yay")
    li_ do 
        text_ "sub elements"
        ul_ do
            li_ (text_ "ok")
            li_ (text_ "ok")
            li_ (test2 1.0)
            li_ (test2 3.0)
        
----------------------------------------------------------------------------
---- types -----------------------------------------------------------------

foreign import data H :: !
type VDomBuilder e a = StateT (Array (VDom e)) (Eff (h::H|e)) a
type NodeBuilder e = VDomBuilder e Unit -> VDomBuilder e Unit

----------------------------------------------------------------------------
-- Handlers, Observables, Sinks --------------------------------------------

createHandlerE :: forall a e. Array a -> VDomBuilder e (Handler e a)
createHandlerE a = lift $ pure (createHandler a)

----------------------------------------------------------------------------
-- Elements ----------------------------------------------------------------

wrapElem :: forall e. (Array (VDom e) -> (VDom e)) -> VDomBuilder e Unit -> VDomBuilder e Unit
wrapElem e b = lift (e <$> execStateT b []) >>= push 

ul_ :: forall e. NodeBuilder e
ul_ = wrapElem ul

li_ :: forall e. NodeBuilder e
li_ = wrapElem li

div_ :: forall e. NodeBuilder e
div_ = wrapElem div

br_ = wrapElem br
hr_ = wrapElem hr

input_ :: forall e. NodeBuilder e
input_ = wrapElem input

text_ :: forall e. String -> VDomBuilder e Unit
text_ t =  push (text t)

-- ul_1 :: forall e. VDomBuilder e Unit -> VDomBuilder e Unit
-- ul_1 b = lift (ul <$> execStateT b []) >>= push

----------------------------------------------------------------------------
-- Attributes --------------------------------------------------------------

wrapAttribyte :: 
    forall builder value e. 
    AttributeBuilder builder value =>  
    builder ->
    value ->
    VDomBuilder e Unit
wrapAttribyte b v = push (b := v)

type_ :: forall e. String -> VDomBuilder e Unit
type_ = wrapAttribyte tpe

valueShow_ :: forall s e. Show s => s -> VDomBuilder e Unit
valueShow_ = wrapAttribyte valueShow

max_ :: forall e. Number -> VDomBuilder e Unit
max_ = wrapAttribyte max

----------------------------------------------------------------------------
-- Emitter -----------------------------------------------------------------

wrapEmitter :: forall builder a e r.       
  EmitterBuilder builder a e => 
  builder -> 
  SinkLike e a r ->
  VDomBuilder e Unit
wrapEmitter b s = push (b ==> s)

-- inputNumber_ :: forall e. Number -> VDomBuilder e Unit
inputNumber_ = wrapEmitter inputNumber

----------------------------------------------------------------------------
-- Receiver ----------------------------------------------------------------

wrapReceiver :: forall builder stream e.
  ReceiverBuilder builder stream e => 
  builder -> 
  stream ->
  VDomBuilder e Unit
wrapReceiver b s = push (b <== s)

children_ :: forall e. Observable (Array (VDom e)) -> VDomBuilder e Unit
children_ s = push (children <== s)

-- instance childReceiverBuilder :: ReceiverBuilder ChildStreamReceiverBuilder (Observable (VDom e)) e  where
--   bindFrom builder obs =
--     let valueStream = map modifierToVNode obs
--     in Receiver (ChildStreamReceiver valueStream)

-- children_2 :: forall e. Observable (VDomBuilder e Unit) -> VDomBuilder e Unit
-- children_2 = do 
--     children

childShow_ :: forall a e. Show a => Observable a -> VDomBuilder e Unit
childShow_ = wrapReceiver childShow
-- ReceiverBuilder builder stream eff | stream -> eff, builder -> stream where
--   bindFrom :: builder -> stream -> VDom eff

----------------------------------------------------------------------------
-- Helpers -----------------------------------------------------------------

push :: forall vdom m. (MonadState (Array vdom) m) => vdom -> m Unit
push = (\e l -> snoc l e) >>> modify

unsafeFirst :: forall a. Array a -> a 
unsafeFirst a = unsafePartial (head a)

build :: forall e a. VDomBuilder e a -> Eff (h::H|e) (Array (VDom e))
build b = execStateT b []

        
------------------------------------------------------------------------------
---- old ---------------------------------------------------------------------


app :: forall e. VDom ( console :: CONSOLE | e )
app = div 
    [ root 1.0
    , root 12.0
    , root 100.0
    ]

root :: forall e. Number -> VDom (console :: CONSOLE |e)
root a = ul
    [ input
        [ tpe := "range"
        , inputNumber ==> sliderEvents
        , valueShow := 0
        , max := a
        ]
    , div [children <== imageLists]
    , div [childShow <== sliderEvents.src]
    , div [childShow <== sliderEvents.src]
    , div [childShow <== sliderEvents.src]
    ]
    where
        imageLists = sliderEvents.src
            # map round
            # map (\n -> replicate n (img[src := "img.svg"]))

sliderEvents :: forall e. Handler e Number
sliderEvents = createHandler [0.0]