import Text.Parsec

import Text.Parsec.Token

import Text.Parsec.Expr

import Control.Monad

import Data.Maybe

import Data.Char

import PascalBasics

import PascalUnitSyntaxTree

knownTypes = ["shortstring", "ansistring", "char", "byte"]

pascalUnit = do

    comments

    u <- choice [program, unit, systemUnit, redoUnit]

    comments

    return u

iD = do

    i <- identifier pas

    comments

    when (i == "not") $ unexpected "'not' used as an identifier"

    return $ Identifier i BTUnknown

unit = do

    name <- iD

    comments

    int <- interface

    impl <- implementation

    comments

    return $ Unit name int impl Nothing Nothing

reference = buildExpressionParser table term <?> "reference"

    where

    term = comments >> choice [

        parens pas (liftM RefExpression expression >>= postfixes) >>= postfixes

        , try $ typeCast >>= postfixes

        , liftM SimpleReference iD >>= postfixes

        ] <?> "simple reference"

    table = [

        ]

    postfixes r = many postfix >>= return . foldl (flip ($)) r

    postfix = choice [

            parens pas (option [] parameters) >>= return . FunCall

          , (brackets pas) (commaSep1 pas $ expression) >>= return . ArrayElement

        ]

    typeCast = do

        t <- choice $ map (\s -> try $ caseInsensitiveString s >>= \i -> notFollowedBy alphaNum >> return i) knownTypes

        e <- parens pas expression

        comments

        return $ TypeCast (Identifier t BTUnknown) e

varsDecl1 = varsParser sepEndBy1

varsDecl = varsParser sepEndBy

varsParser m endsWithSemi = do

    vs <- m (aVarDecl endsWithSemi) (semi pas)

    return vs

aVarDecl endsWithSemi = do

    isVar <- liftM (== Just "var") $

        if not endsWithSemi then

            optionMaybe $ choice [

                try $ string "var"

                , try $ string "const"

                , try $ string "out"

                ]

            else

                return Nothing

    comments

    ids <- do

        i <- (commaSep1 pas) $ (try iD <?> "variable declaration")

        return i

    comments

    t <- typeDecl <?> "variable type declaration"

    comments

        comments

        e <- initExpression

        comments

        return (Just e)

constsDecl = do

    vs <- many1 (try (aConstDecl >>= \i -> semi pas >> return i) >>= \i -> comments >> return i)

    comments

    return vs

    where

    aConstDecl = do

        comments

        i <- iD

        t <- optionMaybe $ do

            comments

            t <- typeDecl

            comments

            return t

        comments

        e <- initExpression

        comments

        return $ VarDeclaration False (isNothing t) ([i], fromMaybe (DeriveType e) t) (Just e)

typeDecl = choice [

    , arrayDecl

    , recordDecl

    , setDecl

    , functionType

    , sequenceDecl >>= return . Sequence

    , try iD >>= return . SimpleType

    , rangeDecl >>= return . RangeType

    ] <?> "type declaration"

    where

    arrayDecl = do

        try $ do

        comments

        r <- option [] $ do

            r <- commaSep pas rangeDecl

            comments

            return r

        comments

        t <- typeDecl

        if null r then

            return $ ArrayDecl Nothing t

            else

            return $ foldr (\a b -> ArrayDecl (Just a) b) (ArrayDecl (Just $ head r) t) (tail r)

    recordDecl = do

        try $ do

        comments

        vs <- varsDecl True

        union <- optionMaybe $ do

            comments

            comments

            comments

            many unionCase

        return $ RecordType vs union

    setDecl = do

        comments

        comments

        liftM Set typeDecl

    unionCase = do

        comments

        u <- parens pas $ varsDecl True

        comments

        return u

    functionType = do

        fp <- try (string "function") <|> try (string "procedure")

        comments

        vs <- option [] $ parens pas $ varsDecl False

        comments

        ret <- if (fp == "function") then do

            comments

            ret <- typeDecl

            comments

            return ret

            else

            return VoidType

        comments

        return $ FunctionType ret vs

typesDecl = many (aTypeDecl >>= \t -> comments >> return t)

    where

    aTypeDecl = do

        i <- try $ do

            i <- iD <?> "type declaration"

            comments

            return i

        comments

        t <- typeDecl

        comments

        comments

        return $ TypeDeclaration i t

rangeDecl = choice [

    try $ rangeft

    , iD >>= return . Range

    ] <?> "range declaration"

    where

    rangeft = do

    e1 <- initExpression

    e2 <- initExpression

    return $ RangeFromTo e1 e2

typeVarDeclaration isImpl = (liftM concat . many . choice) [

    varSection,

    constSection,

    typeSection,

    funcDecl,

    operatorDecl

    ]

    where

    fixInit v = concat $ map (\x -> case x of

                    VarDeclaration a b (ids, t) c ->

                        let typeId = (Identifier ((\(Identifier i _) -> i) (head ids) ++ "_tt") BTUnknown) in

                        let res =  [TypeDeclaration typeId t, VarDeclaration a b (ids, (SimpleType typeId)) c] in

                        case t of

                            RecordType _ _ -> res -- create a separated type declaration

                            ArrayDecl _ _ -> res

                            _ -> [x]

                    _ -> error ("checkInit:\n" ++ (show v))) v

    varSection = do

        comments

        v <- varsDecl1 True <?> "variable declaration"

        comments

        return $ fixInit v

    constSection = do

        comments

        c <- constsDecl <?> "const declaration"

        comments

        return $ fixInit c

    typeSection = do

        comments

        t <- typesDecl <?> "type declaration"

        comments

        return t

    operatorDecl = do

        comments

        i <- manyTill anyChar space

        comments

        vs <- parens pas $ varsDecl False

        comments

        rid <- iD

        comments

        comments

        ret <- typeDecl

        comments

        comments

        inline <- liftM (any (== "inline;")) $ many functionDecorator

        b <- if isImpl && (not forward) then

                liftM Just functionBody

                else

                return Nothing

        return $ [OperatorDeclaration i rid inline ret vs b]

    funcDecl = do

        fp <- try (string "function") <|> try (string "procedure")

        comments

        i <- iD

        vs <- option [] $ parens pas $ varsDecl False

        comments

        ret <- if (fp == "function") then do

            comments

            ret <- typeDecl

            comments

            return ret

            else

            return VoidType

        comments

        forward <- liftM isJust $ optionMaybe (try (string "forward;") >> comments)

        decorators <- many functionDecorator

        let inline = any (== "inline;") decorators

            overload = any (== "overload;") decorators

        b <- if isImpl && (not forward) then

                liftM Just functionBody

                else

                return Nothing

        return $ [FunctionDeclaration i inline overload ret vs b]

    functionDecorator = do

        d <- choice [

            try $ string "inline;"

            , try $ caseInsensitiveString "cdecl;"

            , try $ string "overload;"

            , try $ string "export;"

            , try $ string "varargs;"

            ]

        comments

        return d

program = do

    comments

    name <- iD

    comments

    comments

    u <- uses

    comments

    tv <- typeVarDeclaration True

    comments

    p <- phrase

    comments

    comments

    return $ Program name (Implementation u (TypesAndVars tv)) p

interface = do

    comments

    u <- uses

    comments

    tv <- typeVarDeclaration False

    comments

    return $ Interface u (TypesAndVars tv)

implementation = do

    comments

    u <- uses

    comments

    tv <- typeVarDeclaration True

    comments

    return $ Implementation u (TypesAndVars tv)

expression = do

    buildExpressionParser table term <?> "expression"

    where

    term = comments >> choice [

        builtInFunction expression >>= \(n, e) -> return $ BuiltInFunCall e (SimpleReference (Identifier n BTUnknown))

        , brackets pas (commaSep pas iD) >>= return . SetExpression

        , float pas >>= return . FloatLiteral . show

        , try $ integer pas >>= return . NumberLiteral . show

        , stringLiteral pas >>= return . strOrChar

        , reference >>= return . Reference

        ] <?> "simple expression"

    table = [

          [  Prefix (reservedOp pas "not">> return (PrefixOp "not"))

           ,

          ]

          ]

          ]

          ]

        , [

          ]-}

        , [

          ]

        ]

    strOrChar [a] = CharCode . show . ord $ a

    strOrChar a = StringLiteral a

phrasesBlock = do

    comments

    comments

    return $ Phrases p

phrase = do

    o <- choice [

        phrasesBlock

        , ifBlock

        , whileCycle

        , repeatCycle

        , switchCase

        , withBlock

        , forCycle

        , builtInFunction expression >>= \(n, e) -> return $ BuiltInFunctionCall e (SimpleReference (Identifier n BTUnknown))

        , procCall

        ]

    comments

    return o