/*
 *  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.contentio.synchronize;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.ModifiableDefaultContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.observation.Event;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;

import com.google.common.collect.ImmutableMap;

/**
 * Abstract implementation of {@link SynchronizableContentsCollection}.
 */
public abstract class AbstractSimpleSynchronizableContentsCollection extends AbstractSynchronizableContentsCollection
{
    /** The extension point for Synchronizing Content Operators */
    protected SynchronizingContentOperatorExtensionPoint _synchronizingContentOperatorEP;
    
    /** SCC helper */
    protected SynchronizableContentsCollectionHelper _sccHelper;
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    private List<String> _handledContents;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _synchronizingContentOperatorEP = (SynchronizingContentOperatorExtensionPoint) manager.lookup(SynchronizingContentOperatorExtensionPoint.ROLE);
        _sccHelper = (SynchronizableContentsCollectionHelper) manager.lookup(SynchronizableContentsCollectionHelper.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        _handledContents = new ArrayList<>();
    }

    @Override
    public List<ModifiableDefaultContent> populate(Logger logger)
    {
        _handledContents.clear();
        List<ModifiableDefaultContent> populatedContents = super.populate(logger);
        _handledContents.clear();
        return populatedContents;
    }
    
    @Override
    protected List<ModifiableDefaultContent> _internalPopulate(Logger logger)
    {
        return _importOrSynchronizeContents(new HashMap<>(), false, logger);
    }
    
    /**
     * Adds the given content as handled (i.e. will not be removed if _removalSync is true) 
     * @param id The id of the content
     */
    protected void _handleContent(String id)
    {
        _handledContents.add(id);
    }
    
    /**
     * Returns true if the given content is handled
     * @param id The content to test
     * @return true if the given content is handled
     */
    protected boolean _isHandled(String id)
    {
        return _handledContents.contains(id);
    }

    /**
     * Imports or synchronizes a content for each available language
     * @param idValue The unique identifier of the content
     * @param remoteValues The remote values
     * @param forceImport To force import and ignoring the synchronize existing contents only option
     * @param logger The logger
     * @return The list of synchronized or imported contents
     */
    protected List<ModifiableDefaultContent> _importOrSynchronizeContent(String idValue, Map<String, List<Object>> remoteValues, boolean forceImport, Logger logger)
    {
        List<ModifiableDefaultContent> contents = new ArrayList<>();

        for (String lang : getLanguages())
        {
            contents.addAll(_importOrSynchronizeContent(idValue, lang, remoteValues, forceImport, logger));
        }
        
        return contents;
    }
    
    /**
     * Imports or synchronizes a content for a given language
     * @param idValue The unique identifier of the content
     * @param lang The language of content to import or synchronize
     * @param remoteValues The remote values
     * @param forceImport To force import and ignoring the synchronize existing contents only option
     * @param logger The logger
     * @return The list of imported and synchronized contents
     */
    protected List<ModifiableDefaultContent> _importOrSynchronizeContent(String idValue, String lang, Map<String, List<Object>> remoteValues, boolean forceImport, Logger logger)
    {
        List<ModifiableDefaultContent> contents = new ArrayList<>();
        
        try
        {
            ModifiableDefaultContent content = getContent(lang, idValue);
            if (content != null)
            {
                contents.add(_synchronizeContent(content, remoteValues, logger));
            }
            else if (forceImport || !synchronizeExistingContentsOnly())
            {
                contents.add(_importContent(idValue, null, lang, remoteValues, logger));
            }
        }
        catch (Exception e)
        {
            _nbError++;
            logger.error("An error occurred while importing or synchronizing content", e);
        }
        
        return contents;
    }

    @Override
    public void synchronizeContent(ModifiableDefaultContent content, Logger logger) throws Exception
    {
        String idValue = content.getMetadataHolder().getString(getIdField());
        
        Map<String, Object> parameters = putIdParameter(idValue);
        Map<String, Map<String, List<Object>>> results = getTransformedRemoteValues(parameters, logger);
        if (!results.isEmpty())
        {
            try
            {
                _synchronizeContent(content, results.get(idValue), logger);
            }
            catch (Exception e)
            {
                _nbError++;
                logger.error("An error occurred while importing or synchronizing content", e);
                throw e;
            }
        }
    }

    /**
     * Synchronize a content with remove values.
     * @param content The content to synchronize
     * @param remoteValues Values to synchronize
     * @param logger The logger
     * @return The synchronized content
     * @throws Exception if an error occurs.
     */
    protected ModifiableDefaultContent _synchronizeContent(ModifiableDefaultContent content, Map<String, List<Object>> remoteValues, Logger logger) throws Exception
    {
        long startTime = System.currentTimeMillis();
        
        String contentTitle = content.getTitle();
        String lang = content.getLanguage();
        
        // Update content
        logger.info("Start synchronizing content '{}' for language {}", contentTitle, lang);

        _ensureTitleIsPresent(content, remoteValues, logger);
        
        boolean hasChanges = _fillContent(remoteValues, content, false, logger);
        hasChanges = additionalSynchronizeOperations(content, remoteValues, logger) || hasChanges;
        
        if (hasChanges)
        {
            boolean success = applyChanges(content, logger);
            if (success)
            {
                _nbSynchronizedContents++;
                logger.info("Some changes were detected for content '{}' and language {}", contentTitle, lang);
            }
        }
        else
        {
            _nbNotChangedContents++;
            logger.info("No changes detected for content '{}' and language {}", contentTitle, lang);
        }
        
        // Do additional operation on the content
        SynchronizingContentOperator synchronizingContentOperator = _synchronizingContentOperatorEP.getExtension(getSynchronizingContentOperator());
        if (synchronizingContentOperator != null)
        {
            synchronizingContentOperator.additionalOperation(content, remoteValues, logger);
        }
        else
        {
            logger.warn("Cannot find synchronizing content operator with id '{}'. No additional operation has been done.", getSynchronizingContentOperator());
        }
        
        long endTime = System.currentTimeMillis();
        logger.info("End synchronization of content '{}' for language {} in {} ms", contentTitle, lang, endTime - startTime);
        
        return content;
    }
    
    @Override
    public List<ModifiableDefaultContent> importContent(String idValue, Map<String, Object> importParams, Logger logger) throws Exception
    {
        List<ModifiableDefaultContent> createdContents = new ArrayList<>();
        
        Map<String, Object> parameters = putIdParameter(idValue);
        Map<String, Map<String, List<Object>>> results = getTransformedRemoteValues(parameters, logger);
        if (!results.isEmpty())
        {
            for (String lang : getLanguages())
            {
                try
                {
                    createdContents.add(_importContent(idValue, importParams, lang, results.get(idValue), logger));
                }
                catch (Exception e)
                {
                    _nbError++;
                    logger.error("An error occurred while importing or synchronizing content", e);
                }
            }
        }
        
        return createdContents;
    }
    
    /**
     * Set search parameters for the ID value.
     * @param idValue Value to search
     * @return Map with the search parameters
     */
    protected abstract Map<String, Object> putIdParameter(String idValue);

    /**
     * Import a content from remote values.
     * @param idValue Id (for import/synchronization) of the content to import
     * @param importParams Specific parameters for import
     * @param lang Lang of the content
     * @param remoteValues Values of the content
     * @param logger The logger
     * @return The content created by import, or null
     * @throws Exception if an error occurs.
     */
    protected ModifiableDefaultContent _importContent(String idValue, Map<String, Object> importParams, String lang, Map<String, List<Object>> remoteValues, Logger logger) throws Exception
    {
        ModifiableDefaultContent content = getContent(lang, idValue);
        if (content != null)
        {
            logger.warn("The content '{}' for language {} already exists and cannot be imported ", idValue, lang);
        }
        else
        {
            long startTime = System.currentTimeMillis();

            // Calculate contentTitle
            String contentTitle = idValue;
            if (remoteValues.containsKey("title"))
            {
                List<Object> remoteTitles = remoteValues.get("title");
                contentTitle = (String) remoteTitles.stream().filter(obj -> obj instanceof String && StringUtils.isNotEmpty((String) obj)).findFirst().orElse(idValue);
            }
            
            // Create new content
            logger.info("Start importing content '{}' for language {}", contentTitle, lang);
    
            content = createContentAction(lang, contentTitle, logger);
            if (content != null)
            {
                // Synchronize content metadata
                _fillContent(remoteValues, content, true, logger);
                updateSCCProperty(content);
                
                additionalImportOperations(content, remoteValues, importParams, logger);
                
                content.saveChanges();
                content.checkpoint();
                
                // Validate content if allowed
                validateContent(content, logger);
                
                _nbCreatedContents++;

                // Do additional operation on the content
                SynchronizingContentOperator synchronizingContentOperator = _synchronizingContentOperatorEP.getExtension(getSynchronizingContentOperator());
                synchronizingContentOperator.additionalOperation(content, remoteValues, logger);
                
                // Notify a content was imported
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, content);
                eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
                _observationManager.notify(new Event(org.ametys.plugins.contentio.synchronize.observation.ObservationConstants.EVENT_CONTENT_SYNCHRONIZED, _currentUserProvider.getUser(), eventParams));
                
                long endTime = System.currentTimeMillis();
                logger.info("End import of content '{}' for language {} in {} ms", content.getId(), lang, endTime - startTime);
            }
        }
        
        return content;
    }
    
    /**
     * Add specific fields to the content.
     * @param content Content to update
     * @param remoteValues Values of the content
     * @param importParams Import parameters
     * @param logger The logger
     * @return <code>true</code> if there are changes
     */
    protected boolean additionalImportOperations(ModifiableDefaultContent content, Map<String, List<Object>> remoteValues, Map<String, Object> importParams, Logger logger)
    {
        return additionalCommonOperations(content, remoteValues, importParams, logger);
    }

    /**
     * Add specific fields to the content.
     * @param content Content to update
     * @param remoteValues Values of the content
     * @param logger The logger
     * @return <code>true</code> if there are changes
     */
    protected boolean additionalSynchronizeOperations(ModifiableDefaultContent content, Map<String, List<Object>> remoteValues, Logger logger)
    {
        return additionalCommonOperations(content, remoteValues, null, logger);
    }
    
    /**
     * Add specific fields to the content during import or synchronization.
     * @param content Content to update
     * @param remoteValues Values of the content
     * @param importParams the import params
     * @param logger The logger
     * @return <code>true</code> if there are changes
     */
    protected boolean additionalCommonOperations(ModifiableDefaultContent content, Map<String, List<Object>> remoteValues, Map<String, Object> importParams, Logger logger)
    {
        // Do nothing by default
        return false;
    }
    
    private void _ensureTitleIsPresent(Content content, Map<String, List<Object>> remoteValues, Logger logger)
    {
        if (remoteValues.containsKey("title"))
        {
            List<Object> titleValues = remoteValues.get("title");
            boolean atLeastOneTitle = titleValues.stream()
                                                 .filter(String.class::isInstance)
                                                 .map(String.class::cast)
                                                 .anyMatch(StringUtils::isNotBlank);
            if (atLeastOneTitle)
            {
                return;
            }
        }
        
        // Force to current title
        logger.warn("The remote value of 'title' is empty for the content {}. The 'title' metadata is mandatory, the current title will remain.", content);
        remoteValues.put("title", Collections.singletonList(content.getTitle()));
    }

    @Override
    public ModifiableDefaultContent getContent(String lang, String idValue)
    {
        String query = _getContentPathQuery(lang, idValue, getContentType());
        AmetysObjectIterable<ModifiableDefaultContent> contents = _resolver.query(query);
        
        if (contents.getSize() > 0)
        {
            return contents.iterator().next();
        }
        return null;
    }
    
    /**
     * Creates content action with result from request
     * @param lang The language
     * @param contentTitle The content title
     * @param logger The logger
     * @return The content id, or null of a workflow error occured
     */
    protected ModifiableDefaultContent createContentAction(String lang, String contentTitle, Logger logger)
    {
        return createContentAction(getContentType(), getWorkflowName(), getInitialActionId(), lang, contentTitle, logger);
    }
    
    /**
     * Fill the content with remote values.
     * @param remoteValues The remote values
     * @param content The content to synchronize
     * @param create <code>true</code> if content is creating, false if it is updated
     * @param logger The logger
     * @return <code>true</code> if changes were made
     */
    protected boolean _fillContent(Map<String, List<Object>> remoteValues, ModifiableDefaultContent content, boolean create, Logger logger)
    {
        boolean hasChanges = false;
        
        if (content.isLocked())
        {
            logger.warn("The content '{}' ({}) is currently locked by user {}: it cannot be synchronized", content.getTitle(), content.getId(), content.getLockOwner());
        }
        else
        {
            Map<String, Object> params = ImmutableMap.of("contentType", getContentType());
            ContentType contentType = _contentTypeEP.getExtension(getContentType());
            for (String metadataPath : remoteValues.keySet())
            {
                hasChanges = _synchronizeMetadata(content, contentType, metadataPath, metadataPath, remoteValues.get(metadataPath), getLocalAndExternalFields(params).contains(metadataPath), create, logger) || hasChanges;
            }
        }
        
        return hasChanges;
    }
    
    /**
     * Validates a content after import
     * @param content The content to validate
     * @param logger The logger
     */
    protected void validateContent(WorkflowAwareContent content, Logger logger)
    {
        if (validateAfterImport())
        {
            validateContent(content, getValidateActionId(), logger);
        }
    }
    
    /**
     * Get the value of metadata holding the unique identifier of the synchronized content
     * @param content The content
     * @return The value
     */
    protected String _getIdFieldValue(DefaultContent content)
    {
        ModifiableCompositeMetadata metadataHolder = _getMetadataHolder(content.getMetadataHolder(), getIdField());
        
        String[] pathSegments = getIdField().split("/");
        String metadataName = pathSegments[pathSegments.length - 1];
        
        return metadataHolder.getString(metadataName, null);
    }
    
    @Override
    public Map<String, Map<String, Object>> search(Map<String, Object> parameters, int offset, int limit, List<Object> sort, Logger logger)
    {
        // Search
        Map<String, Map<String, Object>> results = internalSearch(_removeEmptyParameters(parameters), offset, limit, sort, logger);
                
        return results;
    }

    /**
     * Search values and return the result without any treatment.
     * @param parameters Search parameters to restrict the search
     * @param offset Begin of the search
     * @param limit Number of results
     * @param sort Sort of results (ignored for LDAP results)
     * @param logger The logger
     * @return Map of results without any treatment.
     */
    protected abstract Map<String, Map<String, Object>> internalSearch(Map<String, Object> parameters, int offset, int limit, List<Object> sort, Logger logger);

    /**
     * Search values and return the result organized by metadata and transformed by the {@link SynchronizingContentOperator} if exists.
     * @param parameters Search parameters to restrict the search
     * @param logger The logger
     * @return Map of results organized by metadata.
     */
    protected Map<String, Map<String, List<Object>>> getTransformedRemoteValues(Map<String, Object> parameters, Logger logger)
    {
        Map<String, Map<String, List<Object>>> remoteValues = getRemoteValues(parameters, logger);
        
        SynchronizingContentOperator synchronizingContentOperator = _synchronizingContentOperatorEP.getExtension(getSynchronizingContentOperator());
        if (synchronizingContentOperator != null)
        {
            Map<String, Map<String, List<Object>>> transformedRemoteValues = new LinkedHashMap<>();
            for (String key : remoteValues.keySet())
            {
                transformedRemoteValues.put(key, synchronizingContentOperator.transform(remoteValues.get(key), logger));
            }
            
            return transformedRemoteValues;
        }
        else
        {
            logger.warn("Cannot find synchronizing content operator with id '{}'. No transformation has applied on remote values", getSynchronizingContentOperator());
            return remoteValues; // no transformation
        }
    }
    
    /**
     * Search values and return the result organized by metadata
     * @param parameters Search parameters to restrict the search
     * @param logger The logger
     * @return Map of results organized by metadata.
     */
    protected abstract Map<String, Map<String, List<Object>>> getRemoteValues(Map<String, Object> parameters, Logger logger);
    
    @Override
    public void updateSyncInformations(ModifiableDefaultContent content, String syncCode, Logger logger) throws Exception
    {
        updateSCCProperty(content);
        content.getMetadataHolder().setMetadata(getIdField(), syncCode);
        content.saveChanges();
        content.checkpoint();
    }

    @Override
    public int getTotalCount(Map<String, Object> parameters, Logger logger)
    {
        return search(parameters, 0, Integer.MAX_VALUE, null, logger).size();
    }

    /**
     * Import or synchronize several contents from search params.
     * @param searchParams Search parameters
     * @param forceImport To force import and ignoring the synchronize existing contents only option
     * @param logger The logger
     * @return The {@link List} of imported or synchronized {@link ModifiableDefaultContent}
     */
    protected List<ModifiableDefaultContent> _importOrSynchronizeContents(Map<String, Object> searchParams, boolean forceImport, Logger logger)
    {
        List<ModifiableDefaultContent> contents = new ArrayList<>();
        
        Map<String, Map<String, List<Object>>> remoteValuesByContent = getTransformedRemoteValues(searchParams, logger);
        for (String idValue : remoteValuesByContent.keySet())
        {
            Map<String, List<Object>> remoteValues = remoteValuesByContent.get(idValue);
            _handleContent(idValue);
            contents.addAll(_importOrSynchronizeContent(idValue, remoteValues, forceImport, logger));
        }
        
        return contents;
    }
    
    @Override
    protected List<Content> _getContentsToRemove(AmetysObjectIterable<ModifiableDefaultContent> contents)
    {
        return contents.stream()
            .filter(content -> !_isHandled(_getIdFieldValue(content)))
            .collect(Collectors.toList());
    }
}