/* JavaCC grammar for the SLING-5449 content repository 
 * initialization language
 * See https://javacc.java.net/doc/docindex.html for the JavaCC docs
 */
 
options
{
    STATIC=false;
    LOOKAHEAD=3;
    //FORCE_LA_CHECK=true;
    //DEBUG_PARSER=true;
    //DEBUG_LOOKAHEAD=true;
}

PARSER_BEGIN(RepoInitParserImpl)

package org.apache.sling.repoinit.parser.impl;

import java.util.List;
import java.util.ArrayList;

import org.apache.sling.repoinit.parser.operations.*;

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

public class RepoInitParserImpl 
{
}
PARSER_END(RepoInitParserImpl)

SKIP :
{
    " "
|   "\r"
|   "\t"
|   < COMMENT: "#" (~["\n"])* "\n" >
}

TOKEN:
{
    < SET: "set" >
|   < ACL: "ACL" >
|   < ON: "on" >
|   < REMOVE: "remove" >
|   < ALLOW: "allow" >
|   < DENY: "deny" >
|   < FOR: "for" >
|   < CREATE: "create" >
|   < DELETE: "delete" >
|   < SERVICE: "service" >
|   < PATH: "path" >
|   < END: "end" >
|   < USER: "user" >
|   < NODETYPES: "nodetypes" >
|   < REGISTER: "register" >
|   < NAMESPACE: "namespace" >
|   < START_TEXTBLOCK: "<<===" > : TEXTBLOCK
|   < LPAREN: "(" >
|   < RPAREN: ")" >
|   < COMMA: "," >
|   < STAR: "*" >

/* The order of these fuzzy statements is important (first match wins?) */ 
|   < NAMESPACED_ITEM: (["a"-"z"] | ["A"-"Z"])+ ":" (["a"-"z"] | ["A"-"Z"])+ >
|   < PATH_STRING: "/" (["a"-"z"] | ["A"-"Z"] | ["0"-"9"] | ["-"] | ["_"] | ["."] | ["/"]) * >
|   < STRING: (["a"-"z"] | ["A"-"Z"] | ["0"-"9"] | ["-"] | ["_"] | ["."] | ["/"] | [":"]) * >
|   < EOL: "\n" >
}

<TEXTBLOCK> SKIP : 
{
    "\r"
}

<TEXTBLOCK> TOKEN :
{
    < TEXT : ~[] > 
|   < END_TEXTBLOCK: "===>>" > : DEFAULT
} 

List<Operation> parse() :
{}
{
    { final List<Operation> result = new ArrayList<Operation>(); }
    
    ( 
        serviceUserStatement(result) 
        | setAclPaths(result) 
        | setAclPrincipals(result)
        | createPathStatement(result)
        | registerNamespaceStatement(result)
        | registerNodetypesStatement(result)
        | blankLine() 
    ) * 
    <EOF>
    
    { return result; }
}

void blankLine() :
{}
{
    <EOL>
}

List<String> principalsList() :
{
    Token t = null;
    List<String> principals = new ArrayList<String>(); 
}
{
    t = <STRING> { principals.add(t.image); } 
    ( <COMMA> t = <STRING> { principals.add(t.image); } )* 
    { return principals; }
}

void serviceUserStatement(List<Operation> result) :
{
    Token t;
    List<String> principals;
}
{
    (t=<CREATE> | t=<DELETE>) 
    <SERVICE> <USER> 
    principals = principalsList() 
    (<EOL> | <EOF>)
    
    {
        for(String principal : principals) {
            if(CREATE == t.kind) {
                result.add(new CreateServiceUser(principal));
            } else {
                result.add(new DeleteServiceUser(principal));
            }
        } 
    }
}

List<String> namespacedItemsList() :
{
    Token t = null;
    List<String> priv = new ArrayList<String>(); 
    
}
{
    t = <NAMESPACED_ITEM> { priv.add(t.image); } 
    ( <COMMA> t = <NAMESPACED_ITEM> { priv.add(t.image); } )* 
    { return priv; }
}

List<String> pathsList() :
{
    Token t = null;
    List<String> paths = new ArrayList<String>();
}
{
    t = <PATH_STRING> { paths.add(t.image); } 
    ( <COMMA> t = <PATH_STRING> { paths.add(t.image); } )* 
    { return paths; }
}

void createPathStatement(List<Operation> result) :
{
    CreatePath cp = null;
    String defaultPrimaryType = null;
    Token t1 = null;
    Token t2 = null;
}
{
    <CREATE> <PATH> 
    ( <LPAREN> t1 = <NAMESPACED_ITEM> <RPAREN> { defaultPrimaryType = t1.image; } ) ?
    
    ( t1 = <PATH_STRING> ( <LPAREN> t2 = <NAMESPACED_ITEM> <RPAREN> ) ?
        {
            if(cp == null) {
                cp = new CreatePath(defaultPrimaryType);
            } 
            cp.addSegment(t1.image, t2 == null ? null : t2.image); 
            t2 = null; 
        }
    ) +
    
    (<EOL> | <EOF>)
    
    { if(cp != null) result.add(cp); }
}

void setAclPaths(List<Operation> result) :
{
    List<String> paths;
    List<AclLine> lines = new ArrayList<AclLine>();
} 
{
    <SET> <ACL> <ON> paths  = pathsList() <EOL>
    ( removeStarLine(lines) | userPrivilegesLine(lines) | blankLine() ) +
    <END> 
    ( <EOL> | <EOF> )
    
    {
        result.add(new SetAclPaths(paths, lines));
    }
}

void removeStarLine(List<AclLine> lines) : 
{
    List<String> tmp = null;
    AclLine line = new AclLine(AclLine.Action.REMOVE_ALL);
}
{
    <REMOVE> <STAR> 
    (
        <FOR> tmp = principalsList() { line.setProperty(AclLine.PROP_PRINCIPALS, tmp); }
        
        | <ON> tmp = pathsList() { line.setProperty(AclLine.PROP_PATHS, tmp); }
    )     
    <EOL>
    
    {
        lines.add(line);
    }
}

AclLine privilegesLineOperation() :
{}
{
    ( 
        <REMOVE>        { return new AclLine(AclLine.Action.REMOVE); }
        | ( <ALLOW>     { return new AclLine(AclLine.Action.ALLOW); } )
        | ( <DENY>      { return new AclLine(AclLine.Action.DENY); } )    
    ) 
}

void userPrivilegesLine(List<AclLine> lines) :
{
    AclLine line;
    List<String> tmp;
}
{
    line = privilegesLineOperation()
    tmp = namespacedItemsList() { line.setProperty(AclLine.PROP_PRIVILEGES, tmp); } 
    <FOR>
    tmp = principalsList() { line.setProperty(AclLine.PROP_PRINCIPALS, tmp); }
    <EOL>

    {   
        lines.add(line); 
    }
}

void pathPrivilegesLine(List<AclLine> lines) : 
{
    AclLine line;
    List<String> tmp;
}
{
    line = privilegesLineOperation()
    tmp = namespacedItemsList() { line.setProperty(AclLine.PROP_PRIVILEGES, tmp); } 
    <ON> tmp = pathsList() { line.setProperty(AclLine.PROP_PATHS, tmp); }
    ( <NODETYPES> tmp = namespacedItemsList() { line.setProperty(AclLine.PROP_NODETYPES, tmp); }) ?
    <EOL>
    
    {    
        lines.add(line); 
    }
}

void setAclPrincipals(List<Operation> result) :
{
    List <String> principals;
    List<AclLine> lines = new ArrayList<AclLine>();
}
{
    <SET> <ACL> <FOR> principals = principalsList() <EOL>
    ( removeStarLine(lines) | pathPrivilegesLine(lines) | blankLine() ) +
    <END> 
    ( <EOL> | <EOF> )
    
    {
        result.add(new SetAclPrincipals(principals, lines));
    }
}

void registerNamespaceStatement(List<Operation> result) :
{
    Token prefix = null;
    Token uri;
}
{
    <REGISTER> <NAMESPACE> 
    <LPAREN> prefix = <STRING> <RPAREN> 
    uri = <STRING> 

    {
        result.add(new RegisterNamespace(prefix.image, uri.image)); 
    }
    
    (<EOL> | <EOF>)
}

void textBlock(StringBuilder b) : 
{
    Token t;
}
{
    <START_TEXTBLOCK>
    ( t = <TEXT> { b.append(t.image); } )*
    <END_TEXTBLOCK>
}
     
void registerNodetypesStatement(List<Operation> result) :
{
    StringBuilder b = new StringBuilder();
}
{
    <REGISTER> <NODETYPES> <EOL> 
    textBlock(b) 
    (<EOL> | <EOF>)
    {
        result.add(new RegisterNodetypes(b.toString()));
    }
}