/*
 *  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.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.avalon.framework.component.Component;
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.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.runtime.servlet.RuntimeConfig;
import org.ametys.web.repository.site.SiteManager;

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

    /** The set of templates classified by skins */
    protected Map<String, Skin> _skins = 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;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    /**
     * 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<>();

            File skinsDir = new File(getSkinsLocation());
            if (skinsDir.exists() && skinsDir.isDirectory())
            {
                for (File child : skinsDir.listFiles())
                {
                    if (_skinExists(child))
                    {
                        skins.add(child.getName());
                    }
                }
            }
            
            return skins;
        }
        catch (Exception e)
        {
            getLogger().error("Can not determine the list of skins available", e);
            return null;
        }
    }
    
    /**
     * Get a skin
     * @param id The id of the skin
     * @return The skin or null if the skin does not exist
     */
    @SuppressWarnings("null")
    public Skin getSkin(String id)
    {
        try
        {
            File skinsDir = new File (_getSkinLocation(id));
            
            boolean skinDirExists = _skinExists(skinsDir);
            Skin skin = _skins.get(skinsDir.getAbsolutePath());
            if (skin == null && skinDirExists)
            {
                skin = new Skin(id, new File (_getSkinLocation(id)));
                _skins.put(skinsDir.getAbsolutePath(), skin);
            }
            else if (!skinDirExists)
            {
                _skins.put(skinsDir.getAbsolutePath(), null);
                return null;
            }
            
            skin.refreshValues();
            return skin;
        }
        catch (Exception e)
        {
            throw new IllegalStateException("Can not create the skin DAO for skin '" + id + "'", e);
        }
    }
    
    /**
     * Get the skins location
     * @return the skin location
     */
    public String getSkinsLocation ()
    {
        try
        {
            Request request = ContextHelper.getRequest(_context);
            String skinLocation = (String) request.getAttribute("skin-location");
            if (skinLocation != null)
            {
                return new File(RuntimeConfig.getInstance().getAmetysHome(), skinLocation).getPath();
            }
        }
        catch (CascadingRuntimeException e)
        {
            // Ignore
        }
        
        return _cocoonContext.getRealPath("/skins");
    }
    
    /**
     * 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);
            }
        }
        
        // First, search the skin name in the request attributes.
        String skinName = (String) request.getAttribute("skin");
        
        // Then, test if the site name is present as a request attribute to deduce the skin name.
        if (StringUtils.isEmpty(skinName))
        {
            String siteName = (String) request.getAttribute("site");
            if (StringUtils.isEmpty(siteName))
            {
                siteName = (String) request.getAttribute("siteName");
            }
            
            if (StringUtils.isNotEmpty(siteName))
            {
                skinName = _siteManager.getSite(siteName).getSkinId();
            }
        }
        
        return skinName;
    }
    
    /**
     * Get the skin location
     * @param id The id of the skin
     * @return the skin location
     */
    private String _getSkinLocation (String id)
    {
        Request request = ContextHelper.getRequest(_context);
        String skinLocation = (String) request.getAttribute("skin-location");
        if (skinLocation != null)
        {
            return FileUtils.getFile(RuntimeConfig.getInstance().getAmetysHome(), skinLocation, id).getPath();
        }
        
        return _cocoonContext.getRealPath("/skins/" + id);
    }

    private boolean _skinExists(File skinsDir)
    {
        if (!skinsDir.exists() || !skinsDir.isDirectory())
        {
            return false;
        }
        
        File templatesDir = new File(skinsDir, "templates");
        if (!templatesDir.exists() || !templatesDir.isDirectory())
        {
            return false;
        }
        
        return true;
    }
}