/*
 *  Copyright 2013 Anyware Services
 *
 *  Licensed 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.
 */
package org.ametys.plugins.queriesdirectory;

import java.util.Optional;
import java.util.Set;

import javax.jcr.RepositoryException;

import org.apache.jackrabbit.util.ISO9075;

import org.ametys.core.group.GroupIdentity;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.repository.AmetysRepositoryException;

/**
 * Helper for manipulating {@link Query}
 *
 */
public final class QueryHelper
{
    private QueryHelper()
    {
        // Private
    }
    
    /**
     * Creates the XPath query to get all query containers
     * @param queryContainer The {@link QueryContainer}, defining the context from which getting children 
     * @return The XPath query
     */
    static String getXPathForQueryContainers(QueryContainer queryContainer)
    {
        return _getXPathQuery(queryContainer, true, ObjectToReturn.QUERY_CONTAINER, Optional.empty(), Optional.empty(), null);
    }
    
    /**
     * Creates the XPath query to get all queries for administrator
     * @param queryContainer The {@link QueryContainer}, defining the context from which getting children 
     * @param onlyDirectChildren <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param type The query type
     * @return The XPath query
     */
    static String getXPathForQueriesForAdministrator(QueryContainer queryContainer, boolean onlyDirectChildren, Optional<String> type)
    {
        return _getXPathQuery(queryContainer, onlyDirectChildren, ObjectToReturn.QUERY, Optional.empty(), type, null);
    }
    
    /**
     * Creates the XPath query to get all queries in READ access
     * @param queryContainer The {@link QueryContainer}, defining the context from which getting children 
     * @param onlyDirectChildren <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param visibility The user and its groups for checking visibility
     * @param type The query type
     * @return The XPath query
     */
    static String getXPathForQueriesInReadAccess(QueryContainer queryContainer, boolean onlyDirectChildren, Visibility visibility, Optional<String> type)
    {
        return _getXPathQuery(queryContainer, onlyDirectChildren, ObjectToReturn.QUERY, Optional.of(visibility), type, true);
    }
    
    /**
     * Creates the XPath query to get all queries in WRITE access
     * @param queryContainer The {@link QueryContainer}, defining the context from which getting children 
     * @param onlyDirectChildren <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param visibility The user and its groups for checking visibility
     * @param type The query type
     * @return The XPath query
     */
    static String getXPathForQueriesInWriteAccess(QueryContainer queryContainer, boolean onlyDirectChildren, Visibility visibility, Optional<String> type)
    {
        return _getXPathQuery(queryContainer, onlyDirectChildren, ObjectToReturn.QUERY, Optional.of(visibility), type, false);
    }
    
    private static StringBuilder _getParentPath(QueryContainer queryContainer)
    {
        try
        {
            StringBuilder parentPath = new StringBuilder("/jcr:root")
                    .append(ISO9075.encodePath(queryContainer.getNode().getPath()));
            return parentPath;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    private static String _getXPathQuery(QueryContainer queryContainer, boolean onlyDirectChildren, ObjectToReturn objectToReturn, Optional<Visibility> visibility, Optional<String> type, Boolean readAccess)
    {
        StringBuilder parentPath = _getParentPath(queryContainer);
        
        final String slashOrDoubleSlash = onlyDirectChildren ? "/" : "//";
        StringBuilder query = parentPath
                .append(slashOrDoubleSlash)
                .append("element(*, ")
                .append(objectToReturn.toNodetype())
                .append(")");
        
        if (visibility.isPresent() || type.isPresent())
        {
            query.append('[');
        }
        
        type.ifPresent(t -> query.append("@").append(Query.TYPE).append("='").append(t).append("'"));
        
        if (visibility.isPresent())
        {
            type.ifPresent(t -> query.append(" and ("));
            
            _appendPublicPredicate(query);
            
            UserIdentity user = visibility.get().getUser();
            String login = user.getLogin();
            String populationId = user.getPopulationId();
            _appendPrivatePredicate(query, login, populationId);
            
            Set<GroupIdentity> groups = visibility.get().getGroups();
            _appendSharedPredicate(query, login, populationId, groups, readAccess);
            
            type.ifPresent(t -> query.append(')'));
        }
        
        
        if (visibility.isPresent() || type.isPresent())
        {
            query.append(']');
        }
        
        return query.toString();
    }
    
    private static void _appendPublicPredicate(StringBuilder query)
    {
        query.append("(@").append(Query.VISIBILITY).append("='").append(Query.Visibility.PUBLIC.name())
             .append("') or ");
    }
    
    private static void _appendPrivatePredicate(StringBuilder query, String login, String populationId)
    {
        query.append("(@").append(Query.VISIBILITY).append("='").append(Query.Visibility.PRIVATE.name())
             .append("' and ");
        _appendUserCondition(query, login, populationId);
        query.append(") or ");
    }
    
    private static void _appendSharedPredicate(StringBuilder query, String login, String populationId, Set<GroupIdentity> groups, boolean readAccess)
    {
        query.append("(@").append(Query.VISIBILITY).append("='").append(Query.Visibility.SHARED.name())
             .append("' and (");
        query.append("(");
        _appendUserCondition(query, login, populationId);
        query.append(") or ");
        
        if (readAccess)
        {
            _appendUserAccessCondition(query, login, populationId, Query.PROFILE_READ_ACCESS);
            query.append(" or ");
        }
        _appendUserAccessCondition(query, login, populationId, Query.PROFILE_WRITE_ACCESS);
        
        _appendGroupsCondition(query, groups, readAccess);
        query.append("))");
    }
    
    private static void _appendUserCondition(StringBuilder query, String login, String populationId)
    {
        query.append('@').append(Query.AUTHOR).append("/ametys:login='").append(login)
             .append("' and @").append(Query.AUTHOR).append("/ametys:population='").append(populationId)
             .append('\'');
    }
    
    private static void _appendGroupsCondition(StringBuilder query, Set<GroupIdentity> groups, boolean readAccess)
    {
        for (GroupIdentity group : groups)
        {
            String groupId = group.getId();
            String groupDirectory = group.getDirectoryId();
            
            if (readAccess)
            {
                query.append(" or ");
                _appendGroupAccessCondition(query, groupId, groupDirectory, Query.PROFILE_READ_ACCESS);
            }
            query.append(" or ");
            _appendGroupAccessCondition(query, groupId, groupDirectory, Query.PROFILE_WRITE_ACCESS);
        }
    }
    
    private static void _appendUserAccessCondition(StringBuilder query, String login, String populationId, String accessNodeName)
    {
        query.append("(").append(accessNodeName).append("/").append(Query.USERS).append("/ametys:login='").append(login)
             .append("' and ").append(accessNodeName).append("/").append(Query.USERS).append("/ametys:population='").append(populationId)
             .append("')");
    }
    
    private static void _appendGroupAccessCondition(StringBuilder query, String groupId, String groupDirectory, String accessNodeName)
    {
        query.append("(").append(accessNodeName).append("/").append(Query.GROUPS).append("/ametys:groupId='").append(groupId)
             .append("' and ").append(accessNodeName).append("/").append(Query.GROUPS).append("/ametys:groupDirectory='").append(groupDirectory)
             .append("')");
    }
    
    /**
     * The user and its groups for checking visibility
     */
    public static final class Visibility
    {
        private UserIdentity _user;
        private Set<GroupIdentity> _groups;
        
        private Visibility(UserIdentity user, Set<GroupIdentity> groups)
        {
            _user = user;
            _groups = groups;
        }
        
        /**
         * Creates a new {@link Visibility}
         * @param user The user
         * @param groups The user groups
         * @return the {@link Visibility} wrapper
         */
        public static Visibility of(UserIdentity user, Set<GroupIdentity> groups)
        {
            return new Visibility(user, groups);
        }
        
        UserIdentity getUser()
        {
            return _user;
        }
        
        Set<GroupIdentity> getGroups()
        {
            return _groups;
        }
    }
    
    private static enum ObjectToReturn
    {
        QUERY,
        QUERY_CONTAINER;
        
        private String _nodetype;
        
        static
        {
            QUERY._nodetype = QueryFactory.QUERY_NODETYPE;
            QUERY_CONTAINER._nodetype = QueryContainerFactory.QUERY_CONTAINER_NODETYPE;
        }
        
        String toNodetype()
        {
            return _nodetype;
        }
    }
}