/*
 *  Copyright 2010 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.skin;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.file.FileSystem;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;

import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
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.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.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.Constants;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.util.JarFSManager;
import org.ametys.runtime.servlet.RuntimeConfig;
import org.ametys.runtime.servlet.RuntimeServlet;
import org.ametys.web.WebConstants;
import org.ametys.web.WebHelper;
import org.ametys.web.data.type.ModelItemTypeExtensionPoint;
import org.ametys.web.parameters.ViewAndParametersParser;
import org.ametys.web.parameters.view.ViewParametersManager;
import org.ametys.web.repository.site.SiteManager;

/**
 * Manages the skins
 */
public class SkinsManager extends AbstractLogEnabled implements ThreadSafe, Serviceable, Component, Contextualizable, Initializable, Disposable
{
    /** The avalon role name */
    public static final String ROLE = SkinsManager.class.getName();

    /** A cache of skins objects classified by absolute path */
    protected Map<Path, Skin> _skins = new HashMap<>();
    
    /** The skins declared as external: name of the skin and file location */
    protected Map<String, Path> _externalSkins = new HashMap<>();
    
    /** The skins declared in jar files */
    protected Map<String, Path> _resourcesSkins = new HashMap<>();
    
    /** Versions for bundled skins */
    protected Map<String, String> _versions = new HashMap<>();
    
    /** The avalon service manager */
    protected ServiceManager _manager;
    /** The excalibur source resolver */
    protected SourceResolver _sourceResolver;
    /** Avalon context */
    protected Context _context;
    /** Cocoon context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    /** The site manager */
    protected SiteManager _siteManager;
    /** The view parameters manager */
    protected ViewParametersManager _viewParametersManager;
    /** The view and parameters parser */
    protected ViewAndParametersParser _viewAndParametersParser;
    /** The extension point for type of view parameter */
    protected ModelItemTypeExtensionPoint _viewParametersEP;
    /** The skin configuration helper */
    protected SkinConfigurationHelper _skinConfigurationHelper;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _skinConfigurationHelper = (SkinConfigurationHelper) manager.lookup(SkinConfigurationHelper.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    ServiceManager getServiceManager()
    {
        return _manager;
    }
    
    Context getContext()
    {
        return _context;
    }
    
    SourceResolver getSourceResolver()
    {
        return _sourceResolver;
    }
    
    ViewParametersManager getViewParametersManager()
    {
        if (_viewParametersManager == null)
        {
            try 
            {
                _viewParametersManager = (ViewParametersManager) _manager.lookup(ViewParametersManager.ROLE);
            } 
            catch (ServiceException e) 
            {
                throw new RuntimeException(e);
            }
        }
        return _viewParametersManager;
    }
    
    ViewAndParametersParser getViewAndParametersParser()
    {
        if (_viewAndParametersParser == null)
        {
            try 
            {
                _viewAndParametersParser = (ViewAndParametersParser) _manager.lookup(ViewAndParametersParser.ROLE);
            } 
            catch (ServiceException e) 
            {
                throw new RuntimeException(e);
            }
        }
        return _viewAndParametersParser;
    }
    
    ModelItemTypeExtensionPoint getViewParameterTypeExtensionPoint()
    {
        if (_viewParametersEP == null)
        {
            try 
            {
                _viewParametersEP = (ModelItemTypeExtensionPoint) _manager.lookup(ModelItemTypeExtensionPoint.ROLE_VIEW_PARAM);
            } 
            catch (ServiceException e) 
            {
                throw new RuntimeException(e);
            }
        }
        return _viewParametersEP;
    }
    
    public void initialize() throws Exception
    {
        // Skins can be in external locations
        _listExternalSkins("context://" + RuntimeServlet.EXTERNAL_LOCATIONS);
        
        // Skins can be in jars
        _listResourcesSkins();
    }
    
    public void dispose()
    {
        for (Skin skin : _skins.values())
        {
            skin.dispose();
        }
        _skins.clear();
    }
    
    private void _listResourcesSkins() throws IOException
    {
        Enumeration<URL> skinResources = getClass().getClassLoader().getResources("META-INF/ametys-skins");
        
        while (skinResources.hasMoreElements())
        {
            URL skinResource = skinResources.nextElement();
            
            try (InputStream is = skinResource.openStream();
                 BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8")))
            {
                String skin;
                while ((skin = br.readLine()) != null)
                {
                    String skinNameAndVersion = StringUtils.substringBefore(skin, ':');  
                    String skinName = StringUtils.substringBefore(skinNameAndVersion, '@');
                    String version = StringUtils.trimToNull(StringUtils.substringAfter(skinNameAndVersion, '@'));
                    String skinResourceURI = StringUtils.substringAfter(skin, ':');  
                    
                    FileSystem skinFileSystem = JarFSManager.getInstance().getFileSystemByResource(skinResourceURI);
                    Path skinPath = skinFileSystem.getPath(skinResourceURI);
                    
                    if (_isASkinPath(skinPath))
                    {
                        _resourcesSkins.put(skinName, skinPath);
                        _versions.put(skinName, version);
                    }
                    else
                    {
                        getLogger().error("The skin '" + skinName + "' declared in a JAR file will be ignored as it is not a true skin");
                    }
                }
            }
        }        
    }

    private void _listExternalSkins(String uri) throws Exception
    {
        Configuration externalConf;
        
        // Read file
        Source externalLocation = null;
        try
        {
            externalLocation = _sourceResolver.resolveURI(uri);
            if (!externalLocation.exists())
            {
                throw new SourceNotFoundException("No file at " + uri);
            }
            
            DefaultConfigurationBuilder externalConfBuilder = new DefaultConfigurationBuilder();
            try (InputStream external = externalLocation.getInputStream())
            {
                externalConf = externalConfBuilder.build(external, uri);
            }
        }
        catch (SourceNotFoundException e)
        {
            getLogger().debug("No external location file");
            return;
        }
        finally
        {
            _sourceResolver.release(externalLocation);
        }
        
        // Apply file
        for (Configuration skinConf : externalConf.getChild("skins").getChildren("skin"))
        {
            String name = skinConf.getAttribute("name", null);
            String location = skinConf.getValue(null);
            
            if (name != null && location != null)
            {
                Path skinDir = _getPath(location);
                // Do not check at this time, since it is not read-only, this can change
                _externalSkins.put(name, skinDir);
            }
        }
    }
    
    /*
     * Returns the corresponding file, either absolute or relative to the context path
     */
    private Path _getPath(String path)
    {
        if (path == null)
        {
            return null;
        }
        
        Path directory = Path.of(path);
        if (directory.isAbsolute())
        {
            return directory;
        }
        else
        {
            return Path.of(_cocoonContext.getRealPath("/" + path));
        }
    }

    /**
     * Get the list of existing skins from JARs
     * @return A set of skin names. Can be null if there is an error.
     */
    public Set<String> getResourceSkins()
    {
        return _resourcesSkins.keySet();
    }
    /**
     * Get the list of existing skins
     * @return A set of skin names. Can be null if there is an error.
     */
    public Set<String> getSkins()
    {
        try
        {
            Set<String> skins = new HashSet<>();
            
            // JAR skins
            skins.addAll(_resourcesSkins.keySet());
            
            // External skins
            _externalSkins.entrySet().stream()
                          .filter(e -> _isASkinPath(e.getValue()))
                          .map(Map.Entry::getKey)
                          .forEach(skins::add);
            
            // Skins at location
            Path skinsDir = getLocalSkinsLocation();
            if (Files.exists(skinsDir) && Files.isDirectory(skinsDir))
            {
                try (Stream<Path> files = Files.list(skinsDir))
                {
                    files.filter(this::_isASkinPath)
                        .map(p -> p.getFileName().toString())
                        .forEach(skins::add);
                }
            }
            
            return skins;
        }
        catch (Exception e)
        {
            getLogger().error("Can not determine the list of skins available", e);
            return null;
        }
    }
    
    /**
     * Get the skin version or null if unknown. Only available for bundled skins.
     * @param skinName the skin name
     * @return the skin version if known.
     */
    public String getVersion(String skinName)
    {
        return _versions.get(skinName);
    }
    
    /**
     * Get a skin
     * @param id The id of the skin
     * @return The skin or null if the skin does not exist
     */
    public Skin getSkin(String id)
    {
        if (id == null)
        {
            return null;
        }
        
        Path skinPath;
        boolean modifiable = false;
        
        skinPath = _resourcesSkins.get(id);
        if (skinPath == null)
        {
            skinPath = _externalSkins.get(id);
            if (skinPath == null)
            {
                skinPath = getLocalSkinsLocation().resolve(id);
                if (Files.exists(skinPath) && Files.isDirectory(skinPath))
                {
                    modifiable = true;
                }
                else
                {
                    // No skin with this name
                    return null;
                }
            }
        }
        
        if (!_isASkinPath(skinPath))
        {
            // A skin with this name but is not a skin
            if (_skins.containsKey(skinPath))
            {
                Skin skin = _skins.get(skinPath);
                skin.dispose();
            }
            
            _skins.put(skinPath, null);
            return null;
        }
        
        Skin skin = _skins.get(skinPath);
        if (skin == null)
        {
            skin = new Skin(id, skinPath, modifiable, this, _skinConfigurationHelper);
            _skins.put(skinPath, skin);
        }
        
        skin.refreshValues();
        return skin;
    }
    
    /**
     * Get the skin and recursively its parents skins in the right weight order
     * @param skin The non null skin to check
     * @return The list of parent skins INCLUDING the given one
     */
    public List<Skin> getSkinAndParents(Skin skin)
    {
        List<Skin> skinAndParents = new ArrayList<>();
        
        skinAndParents.add(skin);
        
        for (String parentSkinId : skin.getParents())
        {
            Skin parentSkin = getSkin(parentSkinId);
            if (parentSkin == null)
            {
                throw new IllegalStateException("The skin '" + skin.getId() + "' extends the unexisting skin '" + parentSkinId + "'");
            }
            skinAndParents.addAll(getSkinAndParents(parentSkin));
        }
        
        return skinAndParents;
    }
    
    /**
     * Compute the skin that are directly derived from the given one
     * @param skin A non null skin
     * @return A non null list of skins
     */
    public List<Skin> getDirectChildren(Skin skin)
    {
        List<Skin> children = new ArrayList<>();
        
        for (String otherSkinId : getSkins())
        {
            if (!otherSkinId.equals(skin.getId()))
            {
                Skin otherSkin = getSkin(otherSkinId);
                if (otherSkin.getParents().contains(skin.getId()))
                {
                    children.add(otherSkin);
                }
            }
        }
        
        return children;
    }
    
    /**
     * Get the skins location
     * @return the skin location
     */
    public Path getLocalSkinsLocation()
    {
        try
        {
            Request request = ContextHelper.getRequest(_context);
            String skinLocation = (String) request.getAttribute("skin-location");
            if (skinLocation != null)
            {
                return Path.of(RuntimeConfig.getInstance().getAmetysHome().getAbsolutePath(), skinLocation);
            }
        }
        catch (CascadingRuntimeException e)
        {
            // Ignore
        }
        
        return Path.of(_cocoonContext.getRealPath("/skins"));
    }

    /**
     * Get the skin name from request or <code>null</code> if not found
     * @return The skin name or <code>null</code>
     */
    public String getSkinNameFromRequest ()
    {
        Request request = null;
        try
        {
            request = ContextHelper.getRequest(_context);
            
            return getSkinNameFromRequest(request);
        }
        catch (RuntimeException e)
        {
            // No running request
            return null;
        }
    }
    
    /**
     * Get the skin name from request or <code>null</code> if not found
     * @param request The request
     * @return The skin name or <code>null</code>
     */
    public String getSkinNameFromRequest(Request request)
    {
        if (_siteManager == null)
        {
            try
            {
                _siteManager = (SiteManager) _manager.lookup(SiteManager.ROLE);
            }
            catch (ServiceException e)
            {
                throw new IllegalStateException(e);
            }
        }
        
        if (request == null)
        {
            return null;
        }
        
        // First, search the skin name in the request attributes.
        String skinName = (String) request.getAttribute(WebConstants.REQUEST_ATTR_SKIN_ID);
        
        // Then, test if the site name is present as a request attribute to deduce the skin name.
        if (StringUtils.isEmpty(skinName))
        {
            String siteName = WebHelper.getSiteName(request);
            
            if (StringUtils.isNotEmpty(siteName))
            {
                skinName = _siteManager.getSite(siteName).getSkinId();
            }
        }
        
        return skinName;
    }
    
    private boolean _isASkinPath(Path skinDir)
    {
        if (!Files.exists(skinDir) || !Files.isDirectory(skinDir))
        {
            return false;
        }
        
        Path templateDir = skinDir.resolve(Skin.TEMPLATES_PATH);
        Path confDir = skinDir.resolve(Skin.CONF_PATH);
        if ((!Files.exists(templateDir) || !Files.isDirectory(templateDir))
                && (!Files.exists(confDir) || Files.isDirectory(confDir)))
        {
            return false;
        }
        
        return true;
    }
}