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

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.SAXParserFactory;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.xml.sax.XMLReader;

import org.ametys.core.ui.Callable;
import org.ametys.plugins.core.ui.glyph.CssFontHelper;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;

/**
 * Manager for skin glyph sources
 */
public class SkinGlyphSourceManager extends AbstractLogEnabled implements Serviceable, Component, Contextualizable
{
    /** The Avalon Role */
    public static final String ROLE = SkinGlyphSourceManager.class.getName();

    private CssFontHelper _cssFontHelper;
    private SourceResolver _resolver;
    private SiteManager _siteManager;
    private Context _context;
    
    private long _lastUpdate;
    private Map<String, List<String>> _cssFiles = new HashMap<>();
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _cssFontHelper = (CssFontHelper) smanager.lookup(CssFontHelper.ROLE);
        _siteManager = (SiteManager) smanager.lookup(SiteManager.ROLE);
        _resolver = (SourceResolver) smanager.lookup(SourceResolver.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }

    /**
     * Determines if the skin has available glyphesIde
     * @param siteName The site name
     * @return true if the skin has available glyphes
     * @throws Exception if failed to read skin files
     */
    @Callable
    public boolean hasGlyphs(String siteName) throws Exception
    {
        Site site = _siteManager.getSite(siteName);
        String skinName = site.getSkinId();
        
        return !getGlyphs(skinName).isEmpty();
    }
    
    /**
     * Get the glyphs provided by the skin
     * @param skinName The skin name
     * @return The CSS class names for glyphs
     * @throws Exception if failed to read skin files
     */
    @Callable
    public List<Map<String, String>> getGlyphsStore(String skinName) throws Exception
    {
        List<Map<String, String>> glyphs = new ArrayList<>();

        Set<String> glyphClassNames = getGlyphs(skinName);
        for (String glyphClassName : glyphClassNames)
        {
            Map<String, String> glyph = new HashMap<>();
            glyph.put("cssClassName", glyphClassName);
            glyphs.add(glyph);
        }
        
        return glyphs;
    }
    
    /**
     * Get the CSS class names for glyphes contained in the skin
     * @param skinName The skin name
     * @return The CSS class names for glyphes
     * @throws Exception if failed to read skin files
     */
    public Set<String> getGlyphs(String skinName) throws Exception
    {
        Set<String> glyphes = new LinkedHashSet<>();

        List<String> relativePathsWithFontFace = getRelativeCssFilesWithFontFace(skinName);
        for (String relativePath : relativePathsWithFontFace)
        {
            String sourceUri = "skin://resources/" + relativePath;
            glyphes.addAll(_cssFontHelper.getGlyphClassNames(sourceUri, null));
        }
        
        return glyphes;
    }
    
    /**
     * Get the CSS files with 'font-face' rule in the skin
     * @param siteName The site name
     * @return The CSS files with font
     * @throws Exception If failed to get the list of CSS files with 'font-face' rule
     */
    @Callable
    public Map<String, Object> getCSSFiles(String siteName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);

        Site site = _siteManager.getSite(siteName);
        String skinName = site.getSkinId();

        String resourcePath = request.getContextPath() + "/skins/" + skinName + "/resources/";

        Map<String, Object> result = new HashMap<>();

        if (StringUtils.isNotBlank(skinName))
        {
            List<String> relativePathsWithFontFace = getRelativeCssFilesWithFontFace(skinName);

            List<String> cssPaths = new ArrayList<>();
            for (String relativePath : relativePathsWithFontFace)
            {
                cssPaths.add(resourcePath + relativePath);
            }
            result.put("cssFiles", cssPaths);
        }
        return result;
    }

    /**
     * Get the URI of CSS files with the 'font-face' rule 
     * @param skinName The skin name
     * @return the URI of CSS files with the 'font-face' rule 
     * @throws Exception if fails to read conf/glyph.xml file
     */
    public List<String> getRelativeCssFilesWithFontFace(String skinName) throws Exception
    {
        List<String> relativeCssFiles = _getRelativeCssFiles(skinName);

        List<String> relativeCssFilesWithFontFace = new ArrayList<>();
        for (String relativeCssFile : relativeCssFiles)
        {
            String cssURI = "skin://resources/" + relativeCssFile;
            if (_cssFontHelper.hasFontFaceRule(cssURI))
            {
                relativeCssFilesWithFontFace.add(relativeCssFile);
            }
            else
            {
                getLogger().warn("Font-face rule was not found in CSS style sheet '" + cssURI + "'. It will be ignored");
            }
        }
        
        return relativeCssFilesWithFontFace;
    }

    /**
     * Get the URI of CSS files listed in conf/glyph.xml file
     * @param skinName The skin name
     * @return The list of css files
     * @throws Exception if fails to read conf/glyph.xml file
     */
    private List<String> _getRelativeCssFiles(String skinName) throws Exception
    {
        Source src = null;
        try
        {
            SAXParserFactory factory = SAXParserFactory.newInstance();

            XMLReader reader = factory.newSAXParser().getXMLReader();

            DefaultConfigurationBuilder confBuilder = new DefaultConfigurationBuilder(reader);

            String confFileUri = "context://skins/" + skinName + "/conf/fonts.xml";
            
            src = _resolver.resolveURI(confFileUri);

            if (src.exists())
            {
                if (_lastUpdate < src.getLastModified())
                {
                    List<String> files = new ArrayList<>();
                    
                    try (InputStream is = src.getInputStream())
                    {

                        Configuration configuration = confBuilder.build(is, src.getURI());
                        Configuration[] filesConfiguration = configuration.getChildren("file");

                        for (Configuration fileConfiguration : filesConfiguration)
                        {
                            String file = fileConfiguration.getValue();
                            files.add(file);
                        }
                    }
                    
                    _cssFiles.put(skinName, files);
                    _lastUpdate = src.getLastModified();
                }
                
                return _cssFiles.get(skinName);
            }
        }
        finally
        {
            _resolver.release(src);
        }
        
        return Collections.EMPTY_LIST;
    }
}