/*
 *  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.core.ui;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.MethodUtils;

import org.ametys.core.cocoon.JSonReader;
import org.ametys.core.right.RightAssignmentContext;
import org.ametys.core.right.RightAssignmentContextExtensionPoint;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.runtime.authentication.AccessDeniedException;
import org.ametys.runtime.plugin.ExtensionPoint;

/**
 * Action executing remote method calls coming from client-side elements.<br>
 * Called methods should be annotated with {@link Callable}.<br>
 */
public class ExecuteClientCallsAction extends ServiceableAction implements ThreadSafe
{
    private RightManager _rightManager;
    private CurrentUserProvider _currentUserProvider;
    private RightAssignmentContextExtensionPoint _rightCtxEP;
    
    private RightManager _getRightManager()
    {
        if (_rightManager == null)
        {
            try
            {
                _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        
        return _rightManager;
    }
    
    private CurrentUserProvider _getCurrentUserProvider()
    {
        if (_currentUserProvider == null)
        {
            try
            {
                _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        return _currentUserProvider;
    }
    
    
    private RightAssignmentContextExtensionPoint _getRightContextEP()
    {
        if (_rightCtxEP == null)
        {
            try
            {
                _rightCtxEP = (RightAssignmentContextExtensionPoint) manager.lookup(RightAssignmentContextExtensionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        return _rightCtxEP;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Map<String, Object> jsParameters = (Map<String, Object>) objectModel.get(ObjectModelHelper.PARENT_CONTEXT);

        // Find the corresponding object, either a component or an extension
        String role = (String) jsParameters.get("role");
        
        if (role == null)
        {
            throw new IllegalArgumentException("Component role should be present.");
        }
        
        Object object;
        
        if (!manager.hasService(role))
        {
            throw new IllegalArgumentException("The role '" + role + "' does not correspond to a valid component.");
        }
        
        Object component = manager.lookup(role);
        
        if (component instanceof ExtensionPoint)
        {
            ExtensionPoint extPoint = (ExtensionPoint) component;
            
            String id = (String) jsParameters.get("id");
            
            if (id == null)
            {
                object = component;
            }
            else
            {
                object = extPoint.getExtension(id);
                
                if (object == null)
                {
                    throw new IllegalArgumentException("The id '" + id + "' does not correspond to a valid extension for point " + role);
                }
            }
        }
        else
        {
            object = component;
        }
        
        // Find the corresponding method
        String methodName = (String) jsParameters.get("methodName");
        List<Object> params = (List<Object>) jsParameters.get("parameters");
        
        if (methodName == null)
        {
            throw new IllegalArgumentException("No method name present, cannot execute server side code.");
        }
        
        Class[] paramClass;
        Object[] paramValues;
        if (params == null)
        {
            paramClass = new Class[0];
            paramValues = new Object[0];
        }
        else
        {
            paramValues = params.toArray();
            paramClass = ClassUtils.toClass(paramValues);
        }
        
        Class<? extends Object> clazz = object.getClass();
        Method method = MethodUtils.getMatchingAccessibleMethod(clazz, methodName, paramClass);
        
        if (method == null)
        {
            throw new IllegalArgumentException("No method with signature " + methodName + "(" + StringUtils.join(paramClass, ", ").replaceAll("class ", "") + ") present in class " + clazz.getName() + ".");
        }
        
        Object result = _executeMethod(method, object, paramValues);
        
        Request request = ObjectModelHelper.getRequest(objectModel);
        request.setAttribute(JSonReader.OBJECT_TO_READ, result);
        
        return EMPTY_MAP;
    }
    
    /**
     * Execute the method set in the client call
     * @param method The method
     * @param object The object which has the method
     * @param paramValues The method parameters
     * @return The result
     * @throws Exception If an error occurred
     */
    protected Object _executeMethod(Method method, Object object, Object[] paramValues) throws Exception
    {
        Object result = null;
        if (method.isAnnotationPresent(Callable.class))
        {
            _checkAccess(method, paramValues);
            result = method.invoke(object, paramValues);
        }
        else
        {
            throw new IllegalArgumentException("Trying to call a non-callable method: " + method.toGenericString() + ".");
        }
        
        return result;
    }
    
    private void _checkAccess(Method method, Object[] paramValues)
    {
        Callable callable = method.getAnnotation(Callable.class);
        if (StringUtils.isNotEmpty(callable.right()))
        {
            UserIdentity currentUser = _getCurrentUserProvider().getUser();
            Object context = _getRightContext(method, callable, paramValues);
            
            if (_getRightManager().hasRight(currentUser, callable.right(), context) != RightResult.RIGHT_ALLOW)
            {
                throw new AccessDeniedException("The user " + currentUser + " tried to access the callable method [" + method.toGenericString() + "] without sufficient rights");
            }
        }
    }
    
    private Object _getRightContext(Method method, Callable callable, Object[] paramValues)
    {
        if (StringUtils.isNotEmpty(callable.rightContext()))
        {
            int index = callable.paramIndex();
            if (index < 0 || index > paramValues.length - 1)
            {
                throw new IllegalArgumentException("Callable method [" + method.toGenericString() + "] refers to a invalid 'paramIndex' " + index + ".");
            }
            
            Object jsContext = paramValues[index];
            String rightCtxId = callable.rightContext();
            
            RightAssignmentContext rightCtx = _getRightContextEP().getExtension(rightCtxId);
            if (rightCtx == null)
            {
                throw new IllegalArgumentException("Callable method [" + method.toGenericString() + "] refers to a unknown 'rightContext' of id " + rightCtxId + ".");
            }
            
            Object context = rightCtx.convertJSContext(jsContext);
            if (context == null)
            {
                throw new IllegalArgumentException("Right object context not found for value " + jsContext +  ". Unable to check right for callable method: " + method.toGenericString() + ".");
            }
            return context;
        }
        else
        {
            return callable.context();
        }
    }
}