/*
    * Copyright (C) 2003-2007 eXo Platform SAS.
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Affero General Public License
    * as published by the Free Software Foundation; either version 3
    * of the License, or (at your option) any later version.
    *
    * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, see<http://www.gnu.org/licenses/>.
   */
  package org.exoplatform.services.cms.queries.impl;
  
  import org.exoplatform.commons.utils.ISO8601;
  import org.exoplatform.container.xml.InitParams;
  import org.exoplatform.container.xml.PortalContainerInfo;
  import org.exoplatform.services.cache.CacheService;
  import org.exoplatform.services.cache.ExoCache;
  import org.exoplatform.services.cms.BasePath;
  import org.exoplatform.services.cms.impl.DMSConfiguration;
  import org.exoplatform.services.cms.impl.DMSRepositoryConfiguration;
  import org.exoplatform.services.cms.queries.QueryService;
  import org.exoplatform.services.jcr.RepositoryService;
  import org.exoplatform.services.jcr.access.PermissionType;
  import org.exoplatform.services.jcr.core.ExtendedNode;
  import org.exoplatform.services.jcr.core.ManageableRepository;
  import org.exoplatform.services.jcr.ext.common.SessionProvider;
  import org.exoplatform.services.jcr.ext.hierarchy.NodeHierarchyCreator;
  import org.exoplatform.services.log.ExoLogger;
  import org.exoplatform.services.log.Log;
  import org.exoplatform.services.organization.MembershipHandler;
  import org.exoplatform.services.organization.OrganizationService;
  import org.exoplatform.services.security.ConversationState;
  import org.exoplatform.services.security.IdentityConstants;
  import org.exoplatform.services.security.Identity;
  import org.exoplatform.services.wcm.utils.WCMCoreUtils;
  import org.exoplatform.web.application.RequestContext;
  import org.picocontainer.Startable;
  
  import javax.jcr.*;
  import javax.jcr.query.Query;
  import javax.jcr.query.QueryManager;
  import javax.jcr.query.QueryResult;
  
  import java.util.*;
  
  public class QueryServiceImpl implements QueryService, Startable{
    private static final String[] perms = {PermissionType.READ, PermissionType.ADD_NODE,
      PermissionType.SET_PROPERTY, PermissionType.REMOVE };
    private String relativePath_;
    private List<QueryPlugin> queryPlugins_ = new ArrayList<QueryPlugin> ();
    private RepositoryService repositoryService_;
    private ExoCache<String, QueryResult> cache_;
    private PortalContainerInfo containerInfo_;
    private OrganizationService organizationService_;
    private String baseUserPath_;
    private String baseQueriesPath_;
    private String group_;
    private DMSConfiguration dmsConfiguration_;
    private Set<String> configuredQueries_;
    
    private NodeHierarchyCreator nodeHierarchyCreator_;
  
    private static final Log LOG = ExoLogger.getLogger(QueryServiceImpl.class.getName());
  
    /**
     * Constructor method
     * @param repositoryService
     * @param nodeHierarchyCreator
     * @param params
     * @param containerInfo
     * @param cacheService
     * @param organizationService
     * @param dmsConfiguration
     * @throws Exception
     */
    public QueryServiceImpl(RepositoryService repositoryService, NodeHierarchyCreator nodeHierarchyCreator,
        InitParams params, PortalContainerInfo containerInfo, CacheService cacheService,
        OrganizationService organizationService, DMSConfiguration dmsConfiguration) throws Exception {
      relativePath_ = params.getValueParam("relativePath").getValue();
      group_ = params.getValueParam("group").getValue();
      repositoryService_ = repositoryService;
      containerInfo_ = containerInfo;
      cache_ = cacheService.getCacheInstance(CACHE_NAME);
      organizationService_ = organizationService;
      nodeHierarchyCreator_ = nodeHierarchyCreator;
      baseUserPath_ = nodeHierarchyCreator.getJcrPath(BasePath.CMS_USERS_PATH);
      baseQueriesPath_ = nodeHierarchyCreator.getJcrPath(BasePath.QUERIES_PATH);
      dmsConfiguration_ = dmsConfiguration;
    }
  
    /**
     * Implemented method from Startable class
     * init all ManageDrivePlugin
    * @see QueryPlugin
    */
   public void start() {
     configuredQueries_ = new HashSet<String>();
     for(QueryPlugin queryPlugin : queryPlugins_){
       try{
         queryPlugin.init(baseQueriesPath_);
         configuredQueries_.addAll(queryPlugin.getAllConfiguredQueries());
       }catch (Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("Can not start query plugin '" + queryPlugin.getName() + "'", e);
         }
       }
     }
   }
 
   /**
    * Implemented method from Startable class
    */
   public void stop() {
   }
   
   /**
    * Init query node with current repository
    */
   public void init() throws Exception {
     configuredQueries_ = new HashSet<String>();
     for(QueryPlugin queryPlugin : queryPlugins_){
       try{
         queryPlugin.init(baseQueriesPath_);
         configuredQueries_.addAll(queryPlugin.getAllConfiguredQueries());
       }catch (Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("Can not init query plugin '" + queryPlugin.getName() + "'", e);
         }
       }
     }
   }  
 
   /**
    * Add new QueryPlugin to queryPlugins_
    * @see                   QueryPlugin
    * @param queryPlugin     QueryPlugin
    */
   public void setQueryPlugin(QueryPlugin queryPlugin) {
     queryPlugins_.add(queryPlugin);
   }
 
   /**
    * {@inheritDoc}
    */
   public String getRelativePath() { return relativePath_; }
   
   /**
    * {@inheritDoc}
    */
   public List<Query> getQueries(String userName, SessionProvider provider) throws Exception {
     List<Query> queries = new ArrayList<Query>();
     if (userName == null) return queries;
     Session session = getSession(provider, true);
     QueryManager manager = session.getWorkspace().getQueryManager();
     Node usersHome;
     try {
       usersHome = (Node)session.getItem(baseUserPath_);
     } catch (PathNotFoundException e) {
       usersHome = (Node)getSession(provider, false).getItem(baseUserPath_);
     }
     Node userHome = null;
     try {
       userHome = nodeHierarchyCreator_.getUserNode(provider, userName);
     } catch(Exception e) {
       if (LOG.isWarnEnabled()) {
         LOG.warn(e.getMessage());
       }
     }
     if (userHome == null) {
       if(usersHome.hasNode(userName)) {
         userHome = usersHome.getNode(userName);
       } else{
         userHome = usersHome.addNode(userName);
         if(userHome.canAddMixin("exo:privilegeable")){
           userHome.addMixin("exo:privilegeable");
           
         }
         ((ExtendedNode)userHome).setPermissions(getPermissions(userName));
         Node query = null;
         if(userHome.hasNode(relativePath_)) {
           query = userHome.getNode(relativePath_);
         } else {
           query = getNodeByRelativePath(userHome, relativePath_);
         }
         if (query.canAddMixin("exo:privilegeable")){
           query.addMixin("exo:privilegeable");
         }
         ((ExtendedNode)query).setPermissions(getPermissions(userName));
         usersHome.save();
       }
     }
     Node queriesHome = null;
     if(userHome.hasNode(relativePath_)) {
       queriesHome = userHome.getNode(relativePath_);
     } else {
       queriesHome = getNodeByRelativePath(userHome, relativePath_);
     }
     NodeIterator iter = queriesHome.getNodes();
     while (iter.hasNext()) {
       Node node = iter.nextNode();
       if(node.isNodeType("nt:query")) queries.add(manager.getQuery(node));
     }
     return queries;
   }  
 
   /**
    * Get node by giving the node user and the relative path to its
    * @param userHome      Node user
    * @param relativePath  The relative path to its
    * @return
    * @throws Exception
    */
   private Node getNodeByRelativePath(Node userHome, String relativePath) throws Exception {
     String[] paths = relativePath.split("/");
     StringBuffer relPath = null;
     Node queriesHome = null;
     for (String path : paths) {
       if (relPath == null)
         relPath = new StringBuffer(path);
       else
         relPath.append("/").append(path);
       if (!userHome.hasNode(relPath.toString()))
         queriesHome = userHome.addNode(relPath.toString());
     }
     return queriesHome;
   }
 
   /**
    * Get all permission of the giving owner
    * @param owner
    * @return
    */
   private Map<String,String[]> getPermissions(String owner) {
     Map<String, String[]> permissions = new HashMap<String, String[]>();
     permissions.put(owner, perms);
     permissions.put(group_, perms);
     return permissions;
   }
   
   /**
    * {@inheritDoc}
    */
   public void addQuery(String queryName, String statement, String language, String userName) throws Exception {
     if (userName == null)
       return;
     Session session = getSession();
     QueryManager manager = session.getWorkspace().getQueryManager();
     Query query = manager.createQuery(statement, language);
     SessionProvider sessionProvider = WCMCoreUtils.getSystemSessionProvider();
     Node userNode = nodeHierarchyCreator_.getUserNode(sessionProvider, userName);
     if (!userNode.hasNode(getRelativePath())) {
       getNodeByRelativePath(userNode, relativePath_);
       session.save();
     }
     String absPath = userNode.getPath() + "/" + relativePath_ + "/" + queryName;
     query.storeAsNode(absPath);
     session.save();  
   }
   
   /**
    * {@inheritDoc}
    */
   public void removeQuery(String queryPath, String userName) throws Exception {
     if (userName == null)
       return;
     Session session = getSession();
     
     Node queryNode = null;
     try {
       queryNode = (Node) session.getItem(queryPath);
     } catch (PathNotFoundException pe) {
       queryNode = (Node) getSession(WCMCoreUtils.getSystemSessionProvider(), true).getItem(queryPath);
     }
     Node queriesHome = queryNode.getParent();
     queryNode.remove();
     queriesHome.save();
     removeFromCache(queryPath);
   }  
 
   /**
    * {@inheritDoc}
    */
   public void addSharedQuery(String queryName,
                              String statement,
                              String language,
                              String[] permissions,
                              boolean cachedResult) throws Exception {
     addSharedQuery(queryName,
                    statement,
                    language,
                    permissions,
                    cachedResult,
                    WCMCoreUtils.getUserSessionProvider());
   }
   
   public void addSharedQuery(String queryName,
                              String statement,
                              String language,
                              String[] permissions,
                              boolean cachedResult,
                              SessionProvider provider) throws Exception {
     Session session = getSession(provider, true);
     ValueFactory vt = session.getValueFactory();
     String queryPath;
     List<Value> perm = new ArrayList<Value>();
     for (String permission : permissions) {
       Value vl = vt.createValue(permission);
       perm.add(vl);
     }
     Value[] vls = perm.toArray(new Value[] {});
 
     String queriesPath = baseQueriesPath_;
     Node queryHome = (Node)session.getItem(baseQueriesPath_);
     QueryManager queryManager = session.getWorkspace().getQueryManager();
     queryManager.createQuery(statement, language);
     if (queryHome.hasNode(queryName)) {
       Node query = queryHome.getNode(queryName);
       query.setProperty("jcr:language", language);
       query.setProperty("jcr:statement", statement);
       query.setProperty("exo:accessPermissions", vls);
       query.setProperty("exo:cachedResult", cachedResult);
       query.save();
       session.save();
       queryPath = query.getPath();
     } else {
       QueryManager manager = session.getWorkspace().getQueryManager();
       Query query = manager.createQuery(statement, language);
       Node newQuery = query.storeAsNode(baseQueriesPath_ + "/" + queryName);
       newQuery.addMixin("mix:sharedQuery");
       newQuery.setProperty("exo:accessPermissions", vls);
       newQuery.setProperty("exo:cachedResult", cachedResult);
       session.getItem(queriesPath).save();
       queryPath = queriesPath;
     }
     removeFromCache(queryPath);
   }  
   
   /**
    * {@inheritDoc}
    */
   public Node getSharedQuery(String queryName, SessionProvider provider) throws Exception {
     Session session = getSession(provider, true);
     try {
       Node sharedQueryNode = (Node) session.getItem(baseQueriesPath_ + "/" + queryName);
       return sharedQueryNode;
     } catch (PathNotFoundException e) {
       return null;
     }
   }  
 
   /**
    * {@inheritDoc}
    */
   public List<Node> getSharedQueries(SessionProvider provider) throws Exception {
     Session session = getSession(provider, true);
     List<Node> queries = new ArrayList<Node>();
     Node sharedQueryHome = (Node) session.getItem(baseQueriesPath_);
     NodeIterator iter = sharedQueryHome.getNodes();
     while (iter.hasNext()) {
       Node node = iter.nextNode();
       if(node.isNodeType("nt:query")) {
         queries.add(node);
       }
     }
     return queries;
   }
   
   /**
    * {@inheritDoc}
    */
   public List<Node> getSharedQueries(String userId, SessionProvider provider) throws Exception {
     List<Node> sharedQueries = new ArrayList<Node>();
     for(Node query : getSharedQueries(provider)) {
       if (canUseQuery(userId, query)) {
         sharedQueries.add(query);
       }
     }
     return sharedQueries;
   }  
   
   /**
    * {@inheritDoc}
    */
   public List<Node> getSharedQueries(String queryType,
                                      String userId,
                                      SessionProvider provider) throws Exception {
     List<Node> resultList = new ArrayList<Node>();
     String language = null;
     for (Node queryNode: getSharedQueries(provider)) {
       language = queryNode.getProperty("jcr:language").getString();
       if (!queryType.equalsIgnoreCase(language)) continue;
       if (canUseQuery(userId,queryNode)) {
         resultList.add(queryNode);
       }
     }
     return resultList;
   }  
   
   /**
    * {@inheritDoc}
    */
   public Query getQueryByPath(String queryPath, String userName, SessionProvider provider) throws Exception {
     List<Query> queries = getQueries(userName, provider);
     for (Query query : queries) {
       if (query.getStoredQueryPath().equals(queryPath)) return query;
     }
     return null;
   }  
   
   /**
    * {@inheritDoc}
    */
   public void removeSharedQuery(String queryName, SessionProvider provider) throws Exception {
     Session session = getSession(provider, true);
     session.getItem(baseQueriesPath_ + "/" + queryName).remove();
     session.save();
   }  
   
   /**
    * {@inheritDoc}
    */
   public QueryResult execute(String queryPath,
                              String workspace,
                              SessionProvider provider,
                              String userId) throws Exception {
     Session session = getSession(provider, true);
     Session querySession = getSession(workspace, provider);
     Node queryNode = null;
     try {
       queryNode = (Node) session.getItem(queryPath);
     } catch (PathNotFoundException e) {
       if (LOG.isWarnEnabled()) {
         LOG.warn("Can not find node by path " + queryPath + " in dms-system workspace");
       }
       queryNode = (Node) querySession.getItem(queryPath);
     }
     if (queryNode != null && queryNode.hasProperty("exo:cachedResult")
         && queryNode.getProperty("exo:cachedResult").getBoolean()) {
       String portalName = containerInfo_.getContainerName();
       String key = portalName + queryPath;
       QueryResult result = cache_.get(key);
       if (result != null) return result;
       result = execute(querySession, queryNode, userId);
       cache_.put(key, result);
       return result;
     }
     QueryResult queryResult = execute(querySession, queryNode, userId);
     return queryResult;
   }  
 
   /**
    * Execute the query by giving the session, query node and userid
    * @param session     The Session
    * @param queryNode   The node of query
    * @param userId      The userid
    * @return
    * @throws Exception
    */
   private QueryResult execute(Session session, Node queryNode, String userId) throws Exception {
     return createQuery(session, queryNode, userId).execute();
   }
 
   /**
    * This method replaces tokens in the statement by their actual values
    * Current supported tokens are :
    * ${UserId}$ corresponds to the current user
    * ${Date}$   corresponds to the current date
    * That way, predefined queries can be equipped with dynamic values. This is
    * useful when querying for documents made by the current user, or documents
    * in publication state.
    *
    * @return the processed String, with replaced tokens
    */
   private String computeStatement(String statement, String userId) {
 
     // The returned computed statement
     String ret = statement;
 
     // Replace ${UserId}$
     ret = ret.replace("${UserId}$",userId);
 
     // Replace ${Date}$
     String currentDate = ISO8601.format(new GregorianCalendar());
     ret = ret.replace("${Date}$",currentDate);
 
     return ret;
   }
 
   /**
    * Remove query from cache by giving the query path
    * @param queryPath   The path to query
    * @throws Exception
    */
   private void removeFromCache(String queryPath) throws Exception {
     String portalName = containerInfo_.getContainerName();
     String key = portalName + queryPath;
     QueryResult result = cache_.get(key);
     if (result != null) cache_.remove(key);
   }
 
   /**
    * Get the session with curent repository
    * @return
    * @throws Exception
    */
   private Session getSession() throws Exception {
     ManageableRepository manageableRepository = repositoryService_.getCurrentRepository();
     SessionProvider sessionProvider = WCMCoreUtils.getSystemSessionProvider();
     return sessionProvider.getSession(manageableRepository.getConfiguration().getDefaultWorkspaceName(), 
         manageableRepository);
 
   }
 
   /**
    * Get the session by specify the repository, sessionprovider and flag params
    * @param provider      The SessionProvider
    * @param flag          The boolean to decide which session will be chosen
    * @return
    * @throws Exception
    */
   private Session getSession(SessionProvider provider, boolean flag) throws Exception {
     ManageableRepository manageableRepository = repositoryService_.getCurrentRepository();
     if (!flag) {
       String workspace = manageableRepository.getConfiguration().getDefaultWorkspaceName();
       return provider.getSession(workspace, manageableRepository);
     }
     DMSRepositoryConfiguration dmsRepoConfig = dmsConfiguration_.getConfig();
     return provider.getSession(dmsRepoConfig.getSystemWorkspace(), manageableRepository);
   }
 
   /**
    * Get the session by specify the repository, workspace and sessionprovider
    * @param workspace     The workspace name
    * @param provider      The SessionProvider
    * @return
    * @throws Exception
    */
   private Session getSession(String workspace, SessionProvider provider) throws Exception {
     ManageableRepository manageableRepository = repositoryService_.getCurrentRepository();
     return provider.getSession(workspace,manageableRepository);
   }
 
   /**
    * Check the given user can use this query
    * @param userId      The user id
    * @param queryNode   The node of query
    * @return
    * @throws Exception
    */
   private boolean canUseQuery(String userId, Node queryNode) throws Exception{
     Value[] values = queryNode.getProperty("exo:accessPermissions").getValues();
     for(Value value : values) {
       String accessPermission = value.getString();
       if (hasMembership(userId,accessPermission)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Check the user which has a given membership
    * @param userId          The user id
    * @param roleExpression  The expression of membership
    * @return
    */
   private boolean hasMembership(String userId, String roleExpression) {
     if (userId == null || userId.length() == 0) {
       return false;
     }
     if(roleExpression.equals("*") || roleExpression.equals(IdentityConstants.ANY))
       return true;
     ConversationState conversationState = ConversationState.getCurrent();
     Identity identity = conversationState.getIdentity();
     String membershipType = roleExpression.substring(0, roleExpression.indexOf(":"));
     String groupName = roleExpression.substring(roleExpression.indexOf(":") + 1);
     try {
       MembershipHandler membershipHandler = organizationService_.getMembershipHandler();
       if ("*".equals(membershipType)) {
     	// Determine if there exists at least one membership
         if (userId.equals(ConversationState.getCurrent().getIdentity().getUserId())) {
           return identity.isMemberOf(groupName);
         } else {
           return !membershipHandler.findMembershipsByUserAndGroup( userId,groupName).isEmpty();
         }
       }
       if (userId.equals(ConversationState.getCurrent().getIdentity().getUserId())) {
     	  return identity.isMemberOf(groupName, membershipType);
       } else {
         // Determine if there exists the membership of specified type
         return membershipHandler.findMembershipByUserGroupAndType(userId,groupName,membershipType) != null;
       }
     }
     catch(Exception e) {
       return false;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public Query getQuery(String queryPath, String workspace, SessionProvider provider, String userId) throws Exception {
     Session session = getSession(provider, true);
     Session querySession = getSession(workspace, provider);
     Node queryNode = null;
     try {
       queryNode = (Node) session.getItem(queryPath);
     } catch (PathNotFoundException e) {
       if (LOG.isWarnEnabled()) {
         LOG.warn("Can not find node by path " + queryPath + " in dms-system workspace");
       }
       queryNode = (Node) querySession.getItem(queryPath);
     }
     return createQuery(querySession, queryNode, userId);
   }
   
   /**
    * Creates the Query object by giving the session, query node and userid
    * @param session     The Session
    * @param queryNode   The node of query
    * @param userId      The userid
    * @return
    * @throws Exception
    */
   private Query createQuery(Session session, Node queryNode, String userId) throws Exception {
     String statement = this.computeStatement(queryNode.getProperty("jcr:statement").getString(), userId);
     String language = queryNode.getProperty("jcr:language").getString();
     Query query = session.getWorkspace().getQueryManager().createQuery(statement,language);
     return query;
   }
 
   @Override
   public Set<String> getAllConfiguredQueries() {
     return configuredQueries_;
   }
   
 }