//TODO add ListLiteral
//TODO ExprTyped:  assign default(none) type

#include "ast.h"
#include "ExternLayer.h"
#include <string>

#define wprintf(format, ...) \
                char __buffer[100];    \
                wcstombs(__buffer, format, 100);   \
                fprintf(stderr, __buffer, __VA_ARGS__)
                
using namespace xreate;
using namespace std;
COMPILER Xreate

 xreate::AST root;  // current program unit 

int skipIdent()
{
  int kind = 0;
  scanner->ResetPeek();
  while ((kind = scanner->Peek()->kind) == _colon)
    if (scanner->Peek()->kind != _ident)
      return 0;
    
  return kind;  
}

bool checkParametersList()
{
  return la->kind == _ident && skipIdent() == _lparen;
}

bool checkInfix()
{
  return la->kind == _ident && skipIdent() == _ident;
}

bool checkIndex()
{
  return la->kind == _ident && skipIdent()  == _lbrack;
}

bool checkFuncDecl()
{
  if (la->kind != _ident) return false;
  
  int xkind = skipIdent();
  Token* y = scanner->Peek();
  return  xkind  == _assign && y->kind == _function;
}

bool checkAssignment()
{
  scanner->ResetPeek();
  Token* x = scanner->Peek();
  return la->kind == _ident && x->kind  == _assign;
}

CHARACTERS
  letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
  any = ANY - '"'.
  digit = "0123456789".
  cr  = '\r'.
  lf  = '\n'.
  tab = '\t'.

TOKENS
  ident = (letter | '_') {letter | digit | '_'}.
  number = digit {digit}.
  string = '"' { any } '"'.
  function = "function".
  lparen = '('. 
  rparen = ')'.
  lbrack = '['.
  rbrack = ']'.
  equal = "==".
  assign = '='.
  implic = '-' '>'.
  colon = ':'.
  tagcolon   = "::".

COMMENTS FROM "/*" TO "*/" NESTED
COMMENTS FROM "//" TO lf

IGNORE cr + lf + tab

PRODUCTIONS

Xreate = { ( RuleDecl | InterfaceData | Imprt | IF(checkFuncDecl()) FDecl | TDecl ) }.

Ident<std::wstring& name>
= ident {':' ident}               (. name = t->val; .).


FDecl<> =  							(. std::wstring fname; std::wstring varname; TypeAnnotation typIn; TypeAnnotation typOut; .)
Ident<fname> assign function 		(. Function* f = new Function(fname);  CodeScope* entry = f->getEntryScope(); .)
( Type<typOut>  					(. f->setReturnType(typOut); .)
| '(' [Ident<varname> tagcolon Type<typIn>   (. f->addArg(std::move(varname), move(typIn)); .)
{',' Ident<varname> tagcolon Type<typIn>  (. f->addArg(std::move(varname), move(typIn));.)
}] ')' tagcolon Type<typOut>				(. f->setReturnType(typOut); .)
{';' FnTag<f> }                           
) BDecl<entry>    (. entry->__body.bindType(move(typOut)); root.add(f); .)
.

  /**
   *                          TYPES  
   * 
   */
TypeTerm<TypeAtom& typ> =                       (. std::wstring tid; .)
  ("string" | "int" | "num" | "float" | "bool") (. typ = Atom<Type_t>(t->val); .)
  .

Type<TypeAnnotation& typ> =  (. TypeAnnotation typ2; TypeAtom typ3; std:wstring tid, field; .)
( 
  TList<typ>   
| TStruct<typ>
| TypeTerm<typ3> (. typ = TypeAnnotation(typ3); .) 
|IF (checkIndex()) Ident<tid> lbrack
      Ident<field>      (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
      {',' Ident<field> (.  typ.fields.push_back(Atom<Identifier_t>(field).get());  .)
      } rbrack
      
| Ident<tid>            (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
    ['(' Type<typ2>     (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .)
    {',' Type<typ2>     (. typ.__operands.push_back(typ2); .)
    } ')']
) .

TList<TypeAnnotation& typ> =      (.      TypeAnnotation ty; .)
    '[' Type<ty>                         (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .)
    {',' Type<ty>                        (. typ.__operator = TypeOperator::TUPLE; typ.__operands.push_back(ty); .)
    }']'
  .
  
TStruct<TypeAnnotation& typ> = (. TypeAnnotation t; std::wstring field; .)
  '{'
    Ident<field> tagcolon Type<t>       (. typ = TypeAnnotation(TypeOperator::STRUCT, {t}); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
    {',' Ident<field> tagcolon Type<t>} (. typ.__operands.push_back(t); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
  '}'.
  
 TDecl =  (. std::wstring ttag; TypeAnnotation t; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
  Ident<tname> assign "type"
  (
    "alias" Type<t>             (. root.add(move(t), Atom<Identifier_t>(tname)); .)
    | Ident<ttag> 
      ['('  Ident<arg>        (. args.push_back(Atom<Identifier_t>(arg));   .)
      {',' Ident<arg>         (. args.push_back(Atom<Identifier_t>(arg));   .)
      } ')']
      Type<t>                   (. t.addBindings(move(args)); root.add(move(t), Atom<Identifier_t>(tname)); .)
  ) '.' 
  .
  
VDecl<CodeScope* f> =  (. std::wstring vname; Expression e; TypeAnnotation typ;.)
Ident<vname> assign ExprTyped<e, typ>
      (. f->addDeclaration(move(vname), move(typ), move(e)); .)
.

BDecl<CodeScope* scope> =           (. Expression body; TypeAnnotation typ; .)
'{' { (
    IF(checkAssignment()) VDecl<scope> '.'
    | ExprTyped<body, typ>              (. scope->setBody(body);  .)
)}
'}'. 

IfDecl<Expression& e, TypeAnnotation typ, CodeScope* outer> =         (. Expression cond; ManagedScpPtr blockTrue = root.add(new xreate::CodeScope(outer)); ManagedScpPtr blockFalse = root.add(new xreate::CodeScope(outer)); 
                                                    TypeAnnotation typIf; .)
"if" '(' Expr<cond> ')' tagcolon Type<typIf> BDecl<&*blockTrue> "else" BDecl<&*blockFalse>
(. e = Expression(Operator::IF, {cond}); e.addBlock(blockTrue); e.addBlock(blockFalse); .)
.

LoopDecl<Expression& e, TypeAnnotation& typOut, CodeScope* f> = 
  (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc; TypeAnnotation typEl, typAcc;
    ManagedScpPtr block = root.add(new xreate::CodeScope(f)); .)
   "loop"
   ("map" '(' Expr<eIn> implic Ident<varEl> tagcolon Type<typEl> ')' tagcolon Type<typOut> BDecl<&*block>
      (. e = Expression(Operator::MAP, {eIn}); 
         e.addBindings({Atom<Identifier_t>(varEl)});
         block->addArg(Atom<Identifier_t>(varEl), move(typEl)); 
         e.addBlock(block); .)
  |"fold" '(' Expr<eIn> implic Ident<varEl> tagcolon Type<typEl> ['|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc> tagcolon Type<typAcc> ')' tagcolon Type<typOut> BDecl<&*block>
    (.  e = Expression(Operator::FOLD, {eIn, eAcc});
        e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
        block->addArg(Atom<Identifier_t>(varEl), move(typEl));
        block->addArg(Atom<Identifier_t>(varAcc), move(typAcc));
        e.addBlock(block); 
    .)
).
   
SwitchDecl<> =                  (. TypeAnnotation typ; Expression tag; .)
  ["switch" [tagcolon Type<typ> {';' MetaSimpExpr<tag>}]]
  CaseDecl {CaseDecl}
.
  
CaseDecl<> =                    (. Expression e; .)
  "case" 
  (   "default"
    | CalleeParamsNamed
  )
  
  BDecl<nullptr>
.
  
                              /*============================ INTERFACES ===============================*/
Imprt<> =                           
"import" "raw" '(' string     (. root.__rawImports.push_back(Atom<String_t>(t->val).get()); .)  
')' '.' .

InterfaceData<> = "interface" '('
  (   "dfa" ')'  InterfaceDFA
    | "extern-c" ')' InterfaceExternC
  ).
  
InterfaceExternC<>  =   (.xreate::ExternData data; .)
  '{' {IncludeExternDecl<data> | LibExternDecl<data> } '}'
      (. root.addExternData(move(data));  .)
.

LibExternDecl<xreate::ExternData& data> =       (. std:wstring pkgname, libname; .)
  Ident<libname> assign "library" tagcolon "pkgconfig" 
  '(' string            (. pkgname = t->val; .)
  ')' '.'               (. data.addLibrary(Atom<Identifier_t>(libname), Atom<String_t>(pkgname)); .)
. 

IncludeExternDecl<xreate::ExternData& data> =   (. Expression inc; .)
  "include" StructLiteral<inc> '.'              (. data.addIncludeDecl(move(inc)); .)
.
  
  
InterfaceDFA<> = '{' { InstructDecl } '}' .


InstructDecl =                        (.Operator op; Expression tag; 
                                  Expression scheme; 
                                  std::vector<Expression>& tags = scheme.operands; 
                                  tags.push_back(Expression()); /* return value */ .)
"operator" InstructAlias<op> tagcolon '('      (.scheme.setOp(op); .)
[
  MetaSimpExpr<tag>             (. tags.push_back(tag); .)
  {
      ',' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
  }
] ')' [ implic MetaSimpExpr<tag>             (. tags[0] = tag; .) 
      ]                                      (. root.addDFAData(move(scheme)); .)
'.'.

InstructAlias<Operator& op> = 
(
   "map"  (. op = Operator::MAP; .)
  | "list_range" (. op = Operator::LIST_RANGE; .)
  | "list"       (. op = Operator::LIST; .)
  | "fold"       (. op = Operator::FOLD; .)
  | "index"      (. op = Operator::INDEX; .) 
). 


                              /*============================ METAPROGRAMMING ===============================*/
// TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
// ':' { MetaSimpExpr<tag> (. /*f.addTag(std::move(tag), mod); */ .)
// }.


FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
MetaSimpExpr<tag>
['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).

TagMod<TagModifier& mod> = 
(  "assert" (. mod = TagModifier::ASSERT; .)
 | "require" (. mod = TagModifier::REQUIRE; .)
).
 
RuleDecl<> =
"rule" tagcolon         		(. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
'(' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
{',' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
} ')'
["case" RGuard<guards> {',' RGuard<guards>}]
'{' RBody<args, guards> '}' .    	

Domain<DomainAnnotation& dom> = 
(
  "function"  				(. dom = DomainAnnotation::FUNCTION; .)
  | "variable"    			(. dom = DomainAnnotation::VARIABLE; .)
).

RGuard<RuleGuards& guards>=          (. Expression e; .)
MetaExpr<e>                       (. guards.add(std::move(e)); .).

MetaExpr<Expression& e>=            (.Operator op; Expression e2; .)
MetaExpr2<e>
[MetaOp<op> MetaExpr2<e2>           (. e = Expression(op, {e, e2}); .)
].

MetaExpr2<Expression& e>=
(
'(' MetaExpr<e> ')'
| MetaSimpExpr<e>
).

MetaSimpExpr<Expression& e>=      (. std::wstring i1, infix; Expression e2; .)
( '-' MetaSimpExpr<e2>            (. e = Expression(Operator::NEG, {e2}); .)
| IF(checkParametersList()) Ident<i1>   (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))}); .)
'(' [ CalleeParams<e> ] ')'
| IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>                                       
                                        (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
                                           e.addArg(Expression(Atom<Identifier_t>(i1)));
                                           e.addArg(std::move(e2));
                                        .)
| Ident<i1>                             (. e = Expression(Atom<Identifier_t>(i1)); .)
).

RBody<const RuleArguments& args, const RuleGuards& guards> =
                                  (. Expression e; std::wstring msg; .)
 "warning" MetaExpr<e> ["message" string (. msg = t->val; .)
]                                 (. root.add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
 .

MetaOp< Operator& op> =
 implic                          (. op = Operator::IMPL; .)
.




                        /*============================ Expressions ===============================*/

ExprTyped<Expression&e, TypeAnnotation& typ> =          (. Expression tag; .)
  Expr<e> [tagcolon Type<typ>           (. e.bindType(move(typ)); .)
  {';' MetaSimpExpr<tag>                (. e.tags.emplace(tag.getValueString(), move(tag)); .)
    
  }]
.

Expr< Expression& e>         (. Operator op; Expression e2; .)
= SimExpr< e>		 
  [ RelOp< op>
SimExpr< e2>      (. e = Expression(op, {e, e2});  .)
  ].

SimExpr< Expression& e>      (. Operator op; Expression e2; .)
= Term< e>
  { AddOp< op>
    Term< e2>         (. e = Expression(op, {e, e2});.)
	}.

Term< Expression& e>         (. Operator op; Expression e2; .)
= Factor< e>
  { MulOp< op>
            Factor< e2>        (. e = Expression(op, {e, e2}); .)
  }.

Factor< Expression& e>       (. std::wstring name; TypeAnnotation typ; .)
=                        
  (IF (checkParametersList()) Ident< name> 
                                    (. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); .)
  '(' [CalleeParams<e>] ')'
  |IF (checkIndex()) Ident<name>    
    lbrack  CalleeParams<e> rbrack  (. e.setOp(Operator::INDEX); e.setValue({Atom<Identifier_t>(name)}); .)
  | Ident< name>                    (. e = Expression(Atom<Identifier_t>(name)); .)
  | ListLiteral<e>                  (. /* tuple */.)    
  | StructLiteral<e>                   (. /* struct */.)    
  | LoopDecl<e, typ, nullptr>
  | IfDecl<e, typ, nullptr>  
  | SwitchDecl

  | number                          (. e = Expression(Atom<Number_t>(t->val)); .)
  | string                          (. e = Expression(Atom<String_t>(t->val)); .)
  | '-' Factor< e>                  (. e = Expression(Operator::NEG, {e}); .)
  | '(' Expr<e> ')'  
  ).
  
StructLiteral<Expression& e> =                     (. std::wstring key; Expression val; std::list<Atom<Identifier_t>> keys; .)
  '{' Ident<key> '=' Expr<val>                    (. keys.push_back(Atom<Identifier_t>(key)); e = Expression(Operator::LIST_NAMED, {val}); .)
  {',' Ident<key> '=' Expr<val>                 (.e.addArg(move(val)); keys.push_back(Atom<Identifier_t>(key)); .)
  } '}'                                         (. e.addBindings(keys.begin(), keys.end()); .)
  .
  
ListLiteral<Expression& e> =  (. Expression eFrom, eTo; .)
'['                                                             
[ Expr<eFrom>                                                   (. e.addArg(std::move(eFrom)); .)
(".."  Expr<eTo>                                                (. e.addArg(std::move(eTo)); e.setOp(Operator::LIST_RANGE); .)
 |{',' Expr<eFrom>                                              (. e.addArg(std::move(eFrom)); .)
}                                                               (. e.setOp(Operator::LIST); .) 
) ] ']'.

CalleeParams<Expression& e> = (. Expression e2; TypeAnnotation typ; .)
  ExprTyped<e2, typ>		(. e.addArg(std::move(e2)); .)
  {',' ExprTyped<e2, typ> 		(. e.addArg(std::move(e2)); .)
  }.

CalleeParamsNamed<> = 
   CalleeParamNamed       
  {',' CalleeParamNamed
  }.
  
CalleeParamNamed<> =           (. Expression arg; TypeAnnotation argtyp; .)
  (
    IF(checkAssignment()) VDecl<new CodeScope()>
   | ExprTyped<arg, argtyp>  
  ).

AddOp< Operator& op>
=                        (. op = Operator::ADD; .)
  ( '+'
  | '-'                  (. op = Operator::SUB; .)
  ).

MulOp< Operator& op>
=                        (. op = Operator::MUL; .)
  ( '*'
  | '/'                  (. op = Operator::DIV; .)
  ).

RelOp< Operator& op>
=                        (. op = Operator::EQU; .)
  ( equal
  | '<'                  (. op = Operator::LSS; .)
  | '>'                  (. op = Operator::GTR; .)
  ).
  
END Xreate.
