/*
 *  Copyright 2017 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.workspaces.wall;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.slf4j.Logger;

import org.ametys.core.group.GroupIdentity;
import org.ametys.core.right.AccessController;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.frontedition.AmetysFrontEditionHelper;
import org.ametys.plugins.workspaces.members.JCRProjectMember;
import org.ametys.plugins.workspaces.members.JCRProjectMember.MemberType;
import org.ametys.plugins.workspaces.members.ProjectMemberManager;
import org.ametys.plugins.workspaces.project.ProjectManager;
import org.ametys.plugins.workspaces.project.objects.Project;
import org.ametys.runtime.plugin.component.LogEnabled;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PagesContainer;

/**
 * This controller is used to allowed FO edition for wall contents.
 * This controller grants the right "Front_Edition_Access_Right" on home page (only) to all project's members.
 */
public class WallContentFrontEditionAccessController implements AccessController, Serviceable, LogEnabled
{
    private ProjectManager _projectManager;
    private ProjectMemberManager _projectMemberManager;
    
    private Logger _logger;

    public void service(ServiceManager manager) throws ServiceException
    {
        _projectManager = (ProjectManager) manager.lookup(ProjectManager.ROLE);
        _projectMemberManager = (ProjectMemberManager) manager.lookup(ProjectMemberManager.ROLE);
    }
    
    public void setLogger(Logger logger)
    {
        _logger = logger;
    }
    
    public boolean isSupported(Object object)
    {
        return object instanceof Page && "index".equals(((Page) object).getPathInSitemap());
    }
    
    public AccessResult getPermission(UserIdentity user, Set<GroupIdentity> userGroups, String rightId, Object object)
    {
        if (AmetysFrontEditionHelper.FRONT_EDITION_RIGHT_ID.equals(rightId))
        {
            // User is allowed if he is a member of the project
            Project project = _getProjectFromContext(object);
            return project != null && _projectMemberManager.isProjectMember(project, user) ? AccessResult.USER_ALLOWED : AccessResult.UNKNOWN;
        }
        else
        {
            return AccessResult.UNKNOWN;
        }
    }

    public AccessResult getReadAccessPermission(UserIdentity user, Set<GroupIdentity> userGroups, Object object)
    {
        return AccessResult.UNKNOWN;
    }

    public Map<String, AccessResult> getPermissionByRight(UserIdentity user, Set<GroupIdentity> userGroups, Object object)
    {
        Project project = _getProjectFromContext(object);
        if (project != null && _projectMemberManager.isProjectMember(project, user))
        {
            Map<String, AccessResult> permissions = new HashMap<>();
            permissions.put(AmetysFrontEditionHelper.FRONT_EDITION_RIGHT_ID, AccessResult.USER_ALLOWED);
            return permissions;
        }
        
        return Collections.EMPTY_MAP;
    }

    public AccessResult getPermissionForAnonymous(String rightId, Object object)
    {
        return AccessResult.UNKNOWN;
    }

    public AccessResult getReadAccessPermissionForAnonymous(Object object)
    {
        return AccessResult.UNKNOWN;
    }

    public AccessResult getPermissionForAnyConnectedUser(String rightId, Object object)
    {
        return AccessResult.UNKNOWN;
    }

    public AccessResult getReadAccessPermissionForAnyConnectedUser(Object object)
    {
        return AccessResult.UNKNOWN;
    }

    public Map<UserIdentity, AccessResult> getPermissionByUser(String rightId, Object object)
    {
        Map<UserIdentity, AccessResult> permissionByUser = new HashMap<>();

        if (AmetysFrontEditionHelper.FRONT_EDITION_RIGHT_ID.equals(rightId))
        {
            Project project = _getProjectFromContext(object);
            if (project != null)
            {
                Set<JCRProjectMember> members = _projectMemberManager.getProjectMembers(project);
                for (JCRProjectMember member : members)
                {
                    if (MemberType.USER.toString().equals(member.getType()))
                    {
                        permissionByUser.put(member.getUser(), AccessResult.USER_ALLOWED);
                    }
                }
            }
        }

        return permissionByUser;
    }

    public Map<UserIdentity, AccessResult> getReadAccessPermissionByUser(Object object)
    {
        return Collections.EMPTY_MAP;
    }

    public Map<GroupIdentity, AccessResult> getPermissionByGroup(String rightId, Object object)
    {
        Map<GroupIdentity, AccessResult> permissionByGroup = new HashMap<>();
        
        if (AmetysFrontEditionHelper.FRONT_EDITION_RIGHT_ID.equals(rightId))
        {
            Project project = _getProjectFromContext(object);
            if (project != null)
            {
                Set<JCRProjectMember> members = _projectMemberManager.getProjectMembers(project);
                for (JCRProjectMember member : members)
                {
                    if (MemberType.GROUP.toString().equals(member.getType()))
                    {
                        permissionByGroup.put(member.getGroup(), AccessResult.USER_ALLOWED);
                    }
                }
            }
        }
        
        return permissionByGroup;
    }

    public Map<GroupIdentity, AccessResult> getReadAccessPermissionByGroup(Object object)
    {
        return Collections.EMPTY_MAP;
    }

    public boolean hasUserAnyPermissionOnWorkspace(Set<Object> workspacesContexts, UserIdentity user, Set<GroupIdentity> userGroups, String rightId)
    {
        // We do not want that this accesscontroller give access to the backoffice (even if #isSupported would not match in this case)
        return false;
    }

    public boolean hasUserAnyReadAccessPermissionOnWorkspace(Set<Object> workspacesContexts, UserIdentity user, Set<GroupIdentity> userGroups)
    {
        return false;
    }

    public boolean hasAnonymousAnyPermissionOnWorkspace(Set<Object> workspacesContexts, String rightId)
    {
        // We do not want that this accesscontroller give access to the backoffice (even if #isSupported would not match in this case)
        return false;
    }

    public boolean hasAnonymousAnyReadAccessPermissionOnWorkspace(Set<Object> workspacesContexts)
    {
        return false;
    }

    public boolean hasAnyConnectedUserAnyPermissionOnWorkspace(Set<Object> workspacesContexts, String rightId)
    {
        // We do not want that this accesscontroller give access to the backoffice (even if #isSupported would not match in this case)
        return false;
    }

    public boolean hasAnyConnectedUserAnyReadAccessPermissionOnWorkspace(Set<Object> workspacesContexts)
    {
        return false;
    }

    private Project _getProjectFromContext(Object context)
    {
        String siteName = _getSiteFromContext(context);
        if (siteName != null)
        {
            for (String projectName : _projectManager.getProjectsForSite(siteName))
            {
                Project project = _projectManager.getProject(projectName);
                if (project != null)
                {
                    return project;
                }
                else
                {
                    _logger.warn("Cannot find project '{}' associated to the site '{}'.", projectName, siteName);
                }
            }
            
            _logger.debug("There is no project associated to the site '{}'.", siteName);
        }
        
        return null;
    }
    
    private String _getSiteFromContext(Object context)
    {
        if (context instanceof PagesContainer)
        {
            return ((PagesContainer) context).getSiteName();
        }
        return null;
    }

}