,("/:id",run Paste.handle)

           ,("/raw/:id",run Raw.handle)

           ,("/report/:id",run Report.handle)

           ,("/reported",run Reported.handle)

           ,("/new",run New.handle)

           ,("/new/:channel",run New.handle)

           ,("/browse",run Browse.handle)

           ,("/activity",run Activity.handle)

           ,("/diff/:this/:that",run Diff.handle)

           ]

                                  ppLangs

                                  (zip ppAnnotations ppAnnotationHints)

  , pageName = "paste"

  }

pasteFormlet :: PasteFormlet -> (Formlet PasteSubmit,Html)

pasteFormlet pf@PasteFormlet{..} =

  let form = postForm ! A.action (toValue action) $ do

        when pfSubmitted $

          when (not (null pfErrors)) $

              mapM_ (p . toHtml) pfErrors

        formletHtml (pasteSubmit pf) pfParams

        submitInput "submit" "Submit"

  in (pasteSubmit pf,form)

                   Nothing        -> "/new"

-- | The paste submitting formlet itself.

pasteSubmit :: PasteFormlet -> Formlet PasteSubmit

pasteSubmit pf@PasteFormlet{..} =

  PasteSubmit

    <$> pure (getPasteId pf)

    <*> defaulting "Anonymous Coward" (textInput "author" "Author" Nothing)

    <*> parse (traverse lookupLang)

              (opt (dropInput languages "language" "Language" (snd defChan)))

    <*> parse (traverse lookupChan)

              (opt (dropInput channels "channel" "Channel" (fst defChan)))

    <*> opt (wrap (H.div ! aClass "spam") (textInput "email" "Email" Nothing))

    where defaulting def = fmap swap where

    	    swap "" = def

	    swap x  = x

          languages = options languageName languageTitle pfLanguages

          lookupLang slug = findOption ((==slug).languageName) pfLanguages languageId

          lookupChan slug = findOption ((==slug).channelName) pfChannels channelId

                          (channelName &&& trim.channelName)

                          (pfDefChan >>= findChan)

          findChan name = find ((==name).trim.channelName) pfChannels

          trim = T.dropWhile (=='#')

          findChanById id = channelName <$> find ((==id).channelId) pfChannels

          findLangById id = languageName <$> find ((==id).languageId) pfLanguages

-- | Get the paste id.

pasteNav :: [Language] -> [Paste] -> Paste -> Html

pasteNav langs pastes paste =

  H.div ! aClass "paste-nav" $ do

    diffLink

    stepsLink

    " - "

    href ("/report/" ++ pack (show pid) ++ "") ("Report/Delete" :: Text)

    where pid = pasteId paste

          pairs = zip (drop 1 pastes) pastes

pasteContent :: Text -> Html

pasteContent paste =

  lightNoTitleSection $

    highlightHaskell paste

reportFormlet :: ReportFormlet -> (Formlet Text,Html)

reportFormlet ReportFormlet{..} =

  let frm = form $ do

        formletHtml reportSubmit rfParams

        submitInput "submit" "Submit"

stepsForm form =

  lightNoTitleSection $

    div ! aClass "steps-expr" $

      form

exprFormlet :: ExprFormlet -> (Formlet Text,Html)

exprFormlet ExprFormlet{..} =

  let frm = form $ do

        formletHtml exprSubmit efParams

        submitInput "submit" "Submit"

  ,pastePaste    :: Text

  ,pasteViews    :: Integer 

  ,pasteParent   :: Maybe PasteId

} deriving Show

data PasteSubmit = PasteSubmit {

   pasteSubmitId       :: Maybe PasteId

  ,pasteSubmitTitle    :: Text

  ,pasteSubmitAuthor   :: Text

  ,pasteSubmitLanguage :: Maybe LanguageId

 , pfErrors    :: [Text]

 , pfParams    :: Params

 , pfLanguages :: [Language]

 , pfChannels  :: [Channel]

 , pfDefChan   :: Maybe Text

}

data ExprFormlet = ExprFormlet {

   efSubmitted :: Bool

 , efParams    :: Params

-- | Paste model.

module Amelie.Model.Paste

  (getLatestPastes

  ,getPasteById

  ,createPaste

  ,getAnnotations

  ,getSomePastes

  ,countPublicPastes

  ,generateHints

        ,"WHERE annotation_of = ?"

        ,"ORDER BY id ASC"]

        (Only pid)

-- | Create a paste, or update an existing one.

  case pasteSubmitId of

    Nothing  -> createPaste langs chans paste

    Just pid -> do updatePaste pid paste

                   return $ Just pid

createPaste :: [Language] -> [Channel] -> PasteSubmit -> Model (Maybe PasteId)

createPaste langs chans ps@PasteSubmit{..} = do

  res <- single ["INSERT INTO paste"

                ,"(title,author,content,channel,language,annotation_of)"

                ,"VALUES"

import Amelie.Controller.Paste (pasteForm,getPasteId)

import Amelie.Model

import Amelie.Model.Channel    (getChannels)

import Amelie.Model.Language   (getLanguages)

import Amelie.Model.Paste      (getPasteById)

import Amelie.View.New         as New (page)

import Control.Applicative

import Data.Text.Encoding      (decodeUtf8)

import Snap.Core

  case pid of

    Just pid -> do

      paste <- model $ getPasteById (fromIntegral pid)

      form <- pasteForm chans langs defChan paste

      justOrGoHome paste $ \paste -> do

    Nothing -> do

      form <- pasteForm chans langs defChan Nothing

      output $ New.page form

            , ppPaste       = paste

            , ppAnnotationHints = ahints

            }

      justOrGoHome html outputText

pasteForm :: [Channel] -> [Language] -> Maybe Text -> Maybe Paste -> Controller Html

  params <- getParams

  submitted <- isJust <$> getParam "submit"

  let formlet = PasteFormlet {

          pfSubmitted = submitted

        , pfErrors    = []

        , pfParams    = params

        , pfChannels  = channels

        , pfLanguages = languages

        , pfDefChan   = defChan

        }

      (getValue,_) = pasteFormlet formlet

      value = formletValue getValue params

      errors = either id (const []) value

      (_,html) = pasteFormlet formlet { pfErrors = errors }