/*
 *  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.odf.workflow;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.ui.Callable;
import org.ametys.odf.ODFHelper;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.course.Course;
import org.ametys.odf.orgunit.OrgUnit;
import org.ametys.odf.program.AbstractProgram;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.opensymphony.workflow.spi.Step;

/**
 * Helper for ODF contents on their workflow
 *
 */
public class ODFWorkflowHelper extends AbstractLogEnabled implements Component, Serviceable
{
    /** The component role. */
    public static final String ROLE = ODFWorkflowHelper.class.getName();
    
    /** The validate step id */
    public static final int VALIDATED_STEP_ID = 3;
    
    /** The Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    /** The workflow provider */
    protected WorkflowProvider _workflowProvider;
    /** The ODF helper */
    protected ODFHelper _odfHelper;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _odfHelper = (ODFHelper) manager.lookup(ODFHelper.ROLE);
    }
    
    /**
     * Check if the contents can be validated. A content can be validated only if all its referenced contents are already validated.
     * @param contentIds The id of contents to check
     * @return A map with success key to true if the content can be validated. A map with the invalidated contents otherwise.
     */
    @Callable
    public Map<String, Object> canValidContent(List<String> contentIds)
    {
        Map<String, Object> result = new HashMap<>();
        
        Map<String, Object> contentsInError = new HashMap<>();
        
        for (String contentId : contentIds)
        {
            WorkflowAwareContent content = _resolver.resolveById(contentId);
            
            Map<String, String> invalidatedContents = new HashMap<>();
            _checkValidateStep(content, invalidatedContents);
            
            if (!invalidatedContents.isEmpty())
            {
                contentsInError.put(content.getTitle(), invalidatedContents);
            }
        }
        result.put("contentsInError", contentsInError);
        result.put("success", contentsInError.isEmpty());
        return result;
    }
    
    /**
     * Determines if a content is already in validated step
     * @param content The content to test
     * @return true if the content is already validated
     */
    public boolean isInValidatedStep (WorkflowAwareContent content)
    {
        AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(content);
        long workflowId = content.getWorkflowId();
        
        List<Step> steps = workflow.getCurrentSteps(workflowId);
        for (Step step : steps)
        {
            if (step.getStepId() == VALIDATED_STEP_ID)
            {
                return true;
            }
        }
        
        return false;
    }
    
    private void _checkValidateStep (WorkflowAwareContent content, Map<String, String> invalidatedContent)
    {
        if (content instanceof ProgramItem)
        {
            // Check the structure recursively
            List<ProgramItem> children = _odfHelper.getChildProgramItems((ProgramItem) content);
            for (ProgramItem child : children)
            {
                WorkflowAwareContent waChild = (WorkflowAwareContent) child;
                if (!isInValidatedStep(waChild))
                {
                    if (!invalidatedContent.containsKey(waChild.getId()))
                    {
                        invalidatedContent.put(waChild.getId(), _getTitle(waChild));
                    }
                }
                else
                {
                    // The item is already validated. Continue to its own children.
                    _checkValidateStep(waChild, invalidatedContent);
                }
            }
        }
        
        // Validate others referenced contents
        if (content instanceof AbstractProgram)
        {
            _checkReferencedContents(((AbstractProgram) content).getOrgUnits(), invalidatedContent);
            _checkReferencedContents(((AbstractProgram) content).getContacts(), invalidatedContent);

            Set<String> persons = new HashSet<>();
            Map<String, String[]> personsInChargeByRole = ((AbstractProgram) content).getPersonsInCharge();
            for (String role : personsInChargeByRole.keySet())
            {
                for (String person : personsInChargeByRole.get(role))
                {
                    persons.add(person);
                }
            }
            _checkReferencedContents(persons, invalidatedContent);
        }
        else if (content instanceof Course)
        {
            _checkReferencedContents(((Course) content).getOrgUnits(), invalidatedContent);
            _checkReferencedContents(((Course) content).getContacts(), invalidatedContent);
            _checkReferencedContents(((Course) content).getPersonsInCharge(), invalidatedContent);
        }
        else if (content instanceof OrgUnit)
        {
            _checkReferencedContents(((OrgUnit) content).getContacts(), invalidatedContent);
        }
    }
    
    private String _getTitle(Content content)
    {
        String title = content.getTitle();
        if (content instanceof ProgramItem)
        {
            title += " (" + ((ProgramItem) content).getCode() + ")";
        }
        return title;
    }
    
    private void _checkReferencedContents (Collection<String> refContentIds, Map<String, String> invalidatedContent)
    {
        for (String id : refContentIds)
        {
            try
            {
                if (StringUtils.isNotEmpty(id))
                {
                    WorkflowAwareContent refContent = _resolver.resolveById(id);
                    _checkValidateStep(refContent, invalidatedContent);
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                // Nothing
            }
        }
    }
}