, "uri"

"use strict"

module Aftok.Navigation where
import Prelude
import Data.Either (Either)
import Data.Lens (view)
import Data.Maybe (Maybe)
import URI.URI 
  ( HierPath
  , Host
  , Path
  , Port
  , URIOptions
  , UserInfo
  , parser
  , _query
  )
import URI.Extra.QueryPairs (QueryPairs, Key, Value)
import URI.Extra.QueryPairs as QueryPairs
import URI.Fragment (Fragment)
import URI.HostPortPair as HostPortPair
import URI.HostPortPair (HostPortPair)
import Text.Parsing.Parser (runParser, ParseError)
parseURIQuery :: String -> Either ParseError (Maybe (QueryPairs Key Value))
parseURIQuery uriStr =
  view _query <$> runParser uriStr (parser options)
options ∷ Record (URIOptions UserInfo (HostPortPair Host Port) Path HierPath (QueryPairs Key Value) Fragment)
options =
  { parseUserInfo: pure
  , printUserInfo: identity
  , parseHosts: HostPortPair.parser pure pure
  , printHosts: HostPortPair.print identity identity
  , parsePath: pure
  , printPath: identity
  , parseHierPath: pure
  , printHierPath: identity
  , parseQuery: QueryPairs.parse pure pure
  , printQuery: QueryPairs.print identity identity
  , parseFragment: pure
  , printFragment: identity
  }

import Data.Foldable (any)

import Data.Bifunctor (bimap)
import Data.Either (Either(..), note, fromRight)
import Data.Foldable (any, intercalate)

import Data.Either (Either(..), note)
import Data.Validation.Semigroup (V(..), toEither, andThen, invalid)

import Data.String.Regex (regex, split)
import Data.String.Regex.Flags (global)

import Data.Traversable (traverse_)
import Data.Validation.Semigroup (V(..), toEither, andThen, invalid)

import Partial.Unsafe (unsafePartial)

import URI.Extra.QueryPairs (QueryPairs(..), keyToString, valueToString)

import Aftok.Navigation (parseURIQuery)

  | CodesParseFailure

  | InvCodesField

    , invitationCodes :: Array String

  | SetInvitationCodes String

    , invitationCodes: []

                      , HH.div
                        [ P.classes (ClassName <$> [ "form-group" ]) ] $
                        [ HH.label [ P.for "invitationCodes" ] [ HH.text "Invitation Codes" ]
                          , HH.input
                            [ P.type_ P.InputText
                            , P.classes (ClassName <$> [ "form-control" ])
                            , P.id_ "invitationCodes"
                            , P.placeholder "abcdefgh, ..."
                            , P.value (intercalate ", " st.invitationCodes)
                            , E.onValueInput (Just <<< SetInvitationCodes)
                            ]
                        ] <> signupErrors InvCodesField st

  setZAddr addr = do
    zres <- lift $ caps.checkZAddr addr
    H.modify_ (_ { recoveryZAddr = Just addr })
    case zres of
      Acc.ZAddrCheckValid -> 
        H.modify_ (\st -> st { signupErrors = M.delete ZAddrField st.signupErrors, recoveryType = RecoveryZAddr })
      Acc.ZAddrCheckInvalid -> 
        H.modify_ (\st -> st { signupErrors = M.insert ZAddrField ZAddrInvalid st.signupErrors })

      lift $ system.log "Initializing signup page..."
      loc <- lift system.href
      case parseURIQuery loc of
        (Right (Just (QueryPairs q))) -> do
          let pairsMap = M.fromFoldable $ (bimap keyToString (map valueToString)) <$> q
          traverse_ (\c -> H.modify_ (_ { invitationCodes = [c] })) (join $ M.lookup "invcode" pairsMap) 
          traverse_ setZAddr (join $ M.lookup "zaddr" pairsMap) 
        (Right Nothing) -> pure unit
        (Left err) ->
          lift $ system.error ("Parsing failed for location string " <> loc)

      --lift $ system.log "Switching to signin..."
      when (addr /= "")
        $ do
            zres <- lift $ caps.checkZAddr addr
            H.modify_ (_ { recoveryZAddr = Just addr })
            case zres of
              Acc.ZAddrCheckValid -> 
                H.modify_ (\st -> st { signupErrors = M.delete ZAddrField st.signupErrors })
              Acc.ZAddrCheckInvalid -> 
                H.modify_ (\st -> st { signupErrors = M.insert ZAddrField ZAddrInvalid st.signupErrors })

      when (addr /= "") (setZAddr addr)
    SetInvitationCodes codeStr -> do
      let r = unsafePartial (fromRight $ regex "\\s*,\\s*" global)
      H.modify_ (_ { invitationCodes = split r codeStr })

  CodesParseFailure -> InvCodesField

                , P.checked (rt == RecoveryZAddr)

import Web.HTML (HTMLElement)

import Web.HTML (HTMLElement, window)
import Web.HTML.Window (location)
import Web.HTML.Location (href)

  = { log :: String -> m Unit

  = { href :: m String
    , log :: String -> m Unit

  { log: liftEffect <<< C.log

  { href: liftEffect $ href =<< location =<< window
  , log: liftEffect <<< C.log

                  "billing" -> VBilling