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

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

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
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.cms.repository.Content;
import org.ametys.cms.repository.ModifiableDefaultContent;
import org.ametys.core.ui.Callable;
import org.ametys.core.util.AvalonLoggerAdapter;
import org.ametys.plugins.contentio.synchronize.SynchronizableContentsCollection;
import org.ametys.plugins.contentio.synchronize.SynchronizableContentsCollectionDAO;
import org.ametys.plugins.repository.AmetysObjectResolver;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;

/**
 * Helper for SCC callables.
 */
public class SCCSearchToolHelper extends AbstractLogEnabled implements Component, Serviceable
{
    /** SCC DAO */
    protected SynchronizableContentsCollectionDAO _synchronizableContentsCollectionDAO;
    
    /** The Ametys resolver */
    protected AmetysObjectResolver _resolver;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _synchronizableContentsCollectionDAO = (SynchronizableContentsCollectionDAO) manager.lookup(SynchronizableContentsCollectionDAO.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
    }

    /**
     * Get the {@link SCCSearchModelConfiguration} from the collectionId.
     * @param collectionId Collection ID
     * @return The {@link SCCSearchModelConfiguration}
     */
    @Callable
    public Map<String, Object> getSearchModelConfiguration(String collectionId)
    {
        SynchronizableContentsCollection collection = _synchronizableContentsCollectionDAO.getSynchronizableContentsCollection(collectionId);
        SCCSearchModelConfiguration searchModelConfiguration = collection.getSearchModelConfiguration();
        return searchModelConfiguration.toJSON();
    }

    /**
     * Import the content specified by the id in the specified collection.
     * @param collectionId Collection ID
     * @param id Synchonization ID of the content
     * @param additionalParameters Additional parameters
     * @return Imported contents
     */
    @Callable
    public Map<String, Object> importContent(String collectionId, String id, Map<String, Object> additionalParameters)
    {
        Logger logger = new AvalonLoggerAdapter(getLogger());
        
        Map<String, Object> result = new HashMap<>();
        
        try
        {
            Locale defaultLocale = additionalParameters.containsKey("language") ? new Locale((String) additionalParameters.get("language")) : null;
            Set<Map<String, String>> contentsList = new HashSet<>();
            
            SynchronizableContentsCollection collection = _synchronizableContentsCollectionDAO.getSynchronizableContentsCollection(collectionId);
            Content existingContent = collection.getContent(null, id);
            if (existingContent == null)
            {
                List<ModifiableDefaultContent> contents = collection.importContent(id, additionalParameters, logger);
                for (ModifiableDefaultContent content : contents)
                {
                    Map<String, String> contentMap = new HashMap<>();
                    contentMap.put("id", content.getId());
                    contentMap.put("title", content.getTitle(defaultLocale));
                    contentMap.put("lang", content.getLanguage());
                    contentsList.add(contentMap);
                }
                result.put("contents", contentsList);
                result.put("total", contents.size());
            }
            else
            {
                result.put("contents", ImmutableList.of(ImmutableMap.of("id", existingContent.getId(), "title", existingContent.getTitle(defaultLocale), "lang", existingContent.getLanguage())));
                result.put("error", "alreadyImported");
            }
        }
        catch (Exception e)
        {
            String errorMessage = "An exception occured during import of the content '" + id + "' on SCC '" + collectionId + "'";
            logger.error(errorMessage, e);
            throw new IllegalStateException(errorMessage);
        }
        
        return result;
    }
    
    /**
     * Synchronize the content on the given collection with the given synchronization code.
     * @param collectionId Collection ID
     * @param contentId Content ID
     * @param syncCode Synchronization code
     * @return true if an error occured
     */
    @Callable
    public boolean synchronizeContent(String collectionId, String contentId, String syncCode)
    {
        Logger logger = new AvalonLoggerAdapter(getLogger());
        
        ModifiableDefaultContent content = _resolver.resolveById(contentId);
        boolean hasErrors = false;
        
        try
        {
            SynchronizableContentsCollection collection = _synchronizableContentsCollectionDAO.getSynchronizableContentsCollection(collectionId);
            
            Map<String, Object> searchParameters = new HashMap<>();
            searchParameters.put(collection.getIdField(), syncCode);
            
            if (collection.getTotalCount(searchParameters, logger) > 0)
            {
                collection.updateSyncInformations(content, syncCode, logger);
                collection.synchronizeContent(content, logger);
            }
            else
            {
                logger.warn("In the collection '{}', there is not content matching with the synchronization code '{}'.", collectionId, syncCode);
                hasErrors = true;
            }
        }
        catch (Exception e)
        {
            logger.error("An error occured while synchronizing the content '{}' with the synchronization code '{}' from the '{}' collection.", contentId, syncCode, collectionId, e);
            hasErrors = true;
        }
        
        return hasErrors;
    }
    
    /**
     * Get the value of the synchronization field.
     * @param collectionId Collection ID
     * @param contentId Content ID
     * @return The value of the synchronization field
     */
    @Callable
    public String getSyncCode(String contentId, String collectionId)
    {
        SynchronizableContentsCollection collection = _synchronizableContentsCollectionDAO.getSynchronizableContentsCollection(collectionId);
        Content content = _resolver.resolveById(contentId);
        
        String syncCode = null;
        if (content.getMetadataHolder().hasMetadata(collection.getIdField()))
        {
            syncCode = content.getMetadataHolder().getString(collection.getIdField());
        }
        return syncCode;
    }
}