/*
 *  Copyright 2024 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.odfsync.generic.scc;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.util.filereloader.FileReloader;
import org.ametys.core.util.filereloader.FileReloaderUtils;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * Abstract class for reading mapping files in ODF helpers.
 * First look for a project mapping files in WEB-INF/param/odf
 * Then look for the default mapping files in plugin.odf-sync
 */
public abstract class AbstractMappingHelper extends AbstractLogEnabled implements Component, Serviceable, Configurable, PluginAware, Initializable, FileReloader
{
    /** The source resolver */
    protected SourceResolver _srcResolver;
    
    /** The cache manager */
    protected AbstractCacheManager _cacheManager;

    /** The file reloader utils */
    protected FileReloaderUtils _fileReloaderUtils;
    
    /** The implementation name */
    protected String _implementationName;

    private String _id;
    
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _id = id;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _implementationName = configuration.getChild("name").getValue();
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _srcResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
        _fileReloaderUtils = (FileReloaderUtils) manager.lookup(FileReloaderUtils.ROLE);
    }

    public void initialize() throws Exception
    {
        _cacheManager.createMemoryCache(
            _getCacheId(),
            getCacheLabel(),
            getCacheDescription(),
            true,
            null
        );
    }
    
    /**
     * Read the mapping file to convert types.
     * @param baseUri The base uri of the file
     * @return The mapping
     * @throws Exception if an exception occurs
     */
    protected Map<String, String> _readMapping(String baseUri) throws Exception
    {
        // First, search in WEB-INF/param/odf/[implementationName]
        Map<String, String> mapping = _readMappingFrom("context://WEB-INF/param/odf/" + _implementationName + baseUri);
        
        if (mapping == null)
        {
            // Then in the ODF-sync plugin conversions folder
            mapping = _readMappingFrom("plugin:odf-sync://conversions/" + _implementationName + baseUri);
        }
        
        return Optional.ofNullable(mapping).orElseGet(Map::of);
    }
    
    private Map<String, String> _readMappingFrom(String uri) throws Exception
    {
        _fileReloaderUtils.updateFile(uri, !_getCache().hasKey(uri), this);
        return _getCache().get(uri);
    }

    /**
     * Parse the mapping file
     * @param is The source input stream
     * @return The mapping
     * @throws Exception If an error occurs
     */
    private Map<String, String> _parseMappingFile(InputStream is) throws Exception
    {
        Map<String, String> mapping = new HashMap<>();
        
        Configuration configuration = new DefaultConfigurationBuilder().build(is);
        for (Configuration itemConf : configuration.getChildren())
        {
            String remoteValue = itemConf.getAttribute("code");
            String ametysValue = itemConf.getValue();
            
            mapping.put(remoteValue, ametysValue);
        }
        
        return mapping;
    }
    
    public void updateFile(String sourceUrl, Source source, InputStream is) throws Exception
    {
        if (is != null)
        {
            _getCache().put(sourceUrl, _parseMappingFile(is));
        }
        else
        {
            _getCache().invalidate(sourceUrl);
        }
    }

    public String getId(String sourceUrl)
    {
        return sourceUrl;
    }
    
    private Cache<String, Map<String, String>> _getCache()
    {
        return _cacheManager.get(_getCacheId());
    }
    
    private String _getCacheId()
    {
        return _id + "$mapping";
    }

    /**
     * Get the cache label.
     * @return the cache label
     */
    protected abstract I18nizableText getCacheLabel();
    
    /**
     * Get the cache description.
     * @return the cache description
     */
    protected abstract I18nizableText getCacheDescription();
}