module Network.HTTP.Lucu.Parser.Http
    ( isCtl       -- Char -> Bool
    , isSeparator -- Char -> Bool
    , isChar      -- Char -> Bool
    , isToken     -- Char -> Bool
    , listOf      -- Parser a -> Parser [a]
    , token       -- Parser String
    , lws         -- Parser String
    , text        -- Parser Char
    , separator   -- Parser Char
    , quotedStr   -- Parser String
    )
    where

import qualified Data.ByteString.Lazy.Char8 as B
import           Data.ByteString.Lazy.Char8 (ByteString)
import           Data.List
import           Network.HTTP.Lucu.Parser

isCtl :: Char -> Bool
isCtl c
    | c <  '\x1f' = True
    | c >= '\x7f' = True
    | otherwise  = False


isSeparator :: Char -> Bool
isSeparator c = elem c "()<>@,;:\\\"/[]?={} \t"


isChar :: Char -> Bool
isChar c
    | c <= '\x7f' = True
    | otherwise   = False


isToken :: Char -> Bool
isToken c = not (isCtl c || isSeparator c)


listOf :: Parser a -> Parser [a]
listOf p = do many lws
              sepBy p (do many lws
                          char ','
                          many lws)


token :: Parser String
token = many1 $ satisfy isToken


lws :: Parser String
lws = do s  <- option "" crlf
         xs <- many1 (sp <|> ht)
         return (s ++ xs)


text :: Parser Char
text = satisfy (\ c -> not (isCtl c))


separator :: Parser Char
separator = satisfy isSeparator


quotedStr :: Parser String
quotedStr = do char '"'
               xs <- many (qdtext <|> quotedPair)
               char '"'
               return $ foldr (++) "" xs
    where
      qdtext = do c <- satisfy (/= '"')
                  return [c]

      quotedPair = do q <- char '\\'
                      c <- satisfy isChar
                      return [c]