/*
 *  Copyright 2016 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.web.administration.welcome;

import java.util.List;
import java.util.Set;

import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.slf4j.Logger;

import org.ametys.core.right.AllowedUsers;
import org.ametys.core.right.RightManager;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.runtime.plugin.component.LogEnabled;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.site.SiteConfigurationExtensionPoint;

/**
 * This step indicates that there is at least one well configured site with a user who has right to give its rights.
 */
public class SiteWithUserStep extends AbstractWelcomeStep implements Serviceable, Contextualizable, LogEnabled
{
    private ServiceManager _manager;
    private SiteManager _siteManager;
    private SiteConfigurationExtensionPoint _siteConfiguration;
    private RightManager _rightManager;
    private PopulationContextHelper _populationContextHelper;
    private Context _context;
    private Logger _logger;
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
    }
    
    public void setLogger(Logger logger)
    {
        _logger = logger;
    }
    
    private Logger getLogger()
    {
        return _logger;
    }
    
    private SiteManager _getSiteManager()
    {
        if (_siteManager == null)
        {
            try
            {
                _siteManager = (SiteManager) _manager.lookup(SiteManager.ROLE);
            }
            catch (ServiceException e)
            {
                // The component cannot be looked up in safe mode
            }
        }
        return _siteManager;
    }
    
    private SiteConfigurationExtensionPoint _getSiteConfiguration()
    {
        if (_siteConfiguration == null)
        {
            try
            {
                _siteConfiguration = (SiteConfigurationExtensionPoint) _manager.lookup(SiteConfigurationExtensionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                // The component cannot be looked up in safe mode
            }
        }
        return _siteConfiguration;
    }
    
    private PopulationContextHelper getPopulationContextHelper()
    {
        if (_populationContextHelper == null)
        {
            try
            {
                _populationContextHelper = (PopulationContextHelper) _manager.lookup(PopulationContextHelper.ROLE);
            }
            catch (ServiceException e)
            {
                // The component cannot be looked up in safe mode
            }
        }
        return _populationContextHelper;
    }
    
    @Override
    public boolean isPerformed()
    {
        SiteManager siteManager = _getSiteManager();
        if (siteManager == null)
        {
            return false;
        }
        
        SiteConfigurationExtensionPoint siteConfiguration = _getSiteConfiguration();
        if (siteConfiguration == null)
        {
            return false;
        }
        
        long t0 = System.currentTimeMillis();
        getLogger().debug("Starting isPerformed...");
        int index = 0;

        Request request = ContextHelper.getRequest(_context);
        for (String siteName : _siteManager.getSiteNames())
        {
            long t1 = System.currentTimeMillis();
            index++;
            if (siteConfiguration.isValid(siteName))
            {
                getLogger().debug("Site {} is valid", siteName);
                try
                {
                    request.setAttribute("siteName", siteName); // Setting temporarily this attribute to check user right on '/cms' on this site
                    
                    AllowedUsers allowedUsers = _rightManager.getAllowedUsers("CMS_Rights_Delegate_Rights", "/cms");
                    Set<UserIdentity> resolveAllowedUsers = allowedUsers.resolveAllowedUsers(true);

                    long t2 = System.currentTimeMillis();
                    getLogger().debug("getUsersByContext done in {}ms for site {}", t2 - t1, siteName);
                    
                    if (_hasOneCorrectUser(siteName, resolveAllowedUsers))
                    {
                        long t3 = System.currentTimeMillis();
                        getLogger().info("isPerformed 'true' done in {}ms. Tested {} site(s)", t3 - t0, index);
                        return true;
                    }
                }
                finally
                {
                    request.setAttribute("siteName", null);
                }
            }
            else
            {
                getLogger().debug("Site {} is invalid", siteName);
            }
        }
        
        long t3 = System.currentTimeMillis();
        getLogger().info("isPerformed 'false' done in {}ms. Tested {} site(s)", t3 - t0, index);
        return false;
    }

    private boolean _hasOneCorrectUser(String siteName, Set<UserIdentity> resolveAllowedUsers)
    {
        List<String> userPopulationsOnContext = getPopulationContextHelper().getUserPopulationsOnContext("/sites/" + siteName, false);
        if (userPopulationsOnContext.isEmpty())
        {
            return false;
        }
        
        for (UserIdentity userIdentity : resolveAllowedUsers)
        {
            if (userPopulationsOnContext.contains(userIdentity.getPopulationId()))
            {
                return true;
            }
        }
        
        return false;
    }
}