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

import java.io.IOException;
import java.net.MalformedURLException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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.LogEnabled;
import org.apache.avalon.framework.logger.Logger;
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.Constants;
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.SourceNotFoundException;
import org.apache.excalibur.source.impl.FileSource;
import org.apache.excalibur.source.impl.FileSourceFactory;

import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.skin.Skin;
import org.ametys.web.skin.SkinsManager;

/**
 * Resolve the protocol skin:// seekingg file in skins/{siteConfiguration:skin}/
 */
public class SkinSourceFactory extends FileSourceFactory implements Contextualizable, LogEnabled, Serviceable
{
    /** The regexp for a protocol */
    protected static final Pattern __SOURCE_PATTERN = Pattern.compile("^[\\w]+(:([^:#]+)?(#([^:]+))?)?://(.*)$");
    /** The skins manager */
    protected SkinsManager _skinsManager;
    /** The site manager */
    protected SiteManager _siteManager;
    /** Logger  */
    protected Logger _logger;
    /** Avalon context */
    protected Context _context;
    /** Cocoon context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    
    private ServiceManager _manager;
    
    @Override
    public void enableLogging(Logger logger)
    {
        _logger = logger;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
    }
    
    /**
     * Lookup {@link SiteManager} and {@link SkinsManager} for lazy initialization.
     */
    protected void initializeComponents()
    {
        try
        {
            if (_siteManager == null)
            {
                _siteManager = (SiteManager) _manager.lookup(SiteManager.ROLE);
            }
            
            if (_skinsManager == null)
            {
                _skinsManager = (SkinsManager) _manager.lookup(SkinsManager.ROLE);
            }
        }
        catch (ServiceException e)
        {
            throw new IllegalStateException("Exception while getting components", e);
        }
    }

    /**
     * Return the current skin
     * @param name the skin name. Can be null or empty
     * @param defaultValue switch to this value if skin cannot be determined, or if the determined skin does not exist. Can be null
     * @return the skin. Cannot be null.
     * @throws SourceNotFoundException If the skin do not exist
     */
    protected Skin getSkin(String name, String defaultValue) throws SourceNotFoundException
    {
        String skinName = name;
        Request request = ContextHelper.getRequest(_context);
        
        if (StringUtils.isEmpty(skinName))
        {
            skinName = _skinsManager.getSkinNameFromRequest(request);
        }
        
        // Then, try the default value.
        if (StringUtils.isEmpty(skinName))
        {
            skinName = defaultValue;
        }
        
        if (StringUtils.isEmpty(skinName))
        {
            String message = "The current skin name has to be set in current request to use this protocol.";
            _logger.info(message);
            throw new SourceNotFoundException(message);
        }
        
        Skin skin = _skinsManager.getSkin(skinName); 
        if (skin == null)
        {
            skin = _skinsManager.getSkin(defaultValue);
        }
        
        if (skin == null)
        {
            String message = "The skin '" + skinName + "' currently setup for this site does not exist.";
            _logger.info(message);
            throw new SourceNotFoundException(message);
        }
        
        return skin;
    }

    @Override
    public Source getSource(String location, Map parameters) throws IOException
    {
        // lazy initialization to prevent chicken/egg scenario on startup
        initializeComponents();
        
        Matcher m = __SOURCE_PATTERN.matcher(location);
        if (!m.matches())
        {
            throw new MalformedURLException("URI must be like protocol:<name>://path/to/resource. Location was '" + location + "'");
        }
        
        Skin skin = getSkin(m.group(2), m.group(4));
        
        String fileLocation = m.group(5);

        return new FileSource("file://" + skin.getLocation() + "/" + fileLocation);
    }
    
    @Override
    public String absolutize(String baseURI, String location)
    {
        return location;
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
}