/*
 *  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.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceFactory;
import org.apache.excalibur.source.SourceNotFoundException;

import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.skin.Skin;
import org.ametys.web.skin.SkinsManager;

/**
 * Resolve the protocol skin:// seeking file in skins/{siteConfiguration:skin}/
 */
public class SkinSourceFactory extends AbstractLogEnabled implements SourceFactory, Serviceable, Configurable
{
    /** The regexp for a protocol */
    protected static final Pattern __SOURCE_PATTERN = Pattern.compile("^[\\w-]+(:([^:#]+)?(#([^:]+))?)?://([^?]*)(?:\\?.*)?$");
    /** Scheme for skin */
    protected static final String __SKIN_SCHEME = "skin";
    
    /** The skins manager */
    protected SkinsManager _skinsManager;
    /** The site manager */
    protected SiteManager _siteManager;
    /** Cocoon context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    
    private ServiceManager _manager;
    
    private boolean _supportInheritance;

    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
    }
    
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _supportInheritance = configuration.getChild("inheritance").getValueAsBoolean(true);
    }
    
    /**
     * 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;
        
        if (StringUtils.isEmpty(skinName))
        {
            skinName = _skinsManager.getSkinNameFromRequest();
        }
        
        // 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.";
            getLogger().info(message);
            throw new SourceNotFoundException(message);
        }
        
        Skin skin = _skinsManager.getSkin(skinName); 
        if (skin == null && defaultValue != null)
        {
            skin = _skinsManager.getSkin(defaultValue);
        }
        
        if (skin == null)
        {
            String message = "The skin '" + skinName + "' currently setup for this site does not exist.";
            getLogger().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);

        
        List<Path> paths = new ArrayList<>();
        if (_supportInheritance)
        {
            for (Skin s :  _skinsManager.getSkinAndParents(skin))
            {
                final Path resource = s.getRawPath().resolve(fileLocation);
                paths.add(resource);
            }
        }
        else
        {
            final Path resource = skin.getRawPath().resolve(fileLocation);
            paths.add(resource);
        }
        return new SkinSource(__SKIN_SCHEME, location, paths);
    }
    
    public void release(Source source)
    {
        // Nothing to do
    }
}