/*
 *  Copyright 2011 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.sitemap;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;

import org.ametys.web.repository.page.Page.PageType;


/**
 * A icon for page in sitemap
 * 
 */
public class SitemapIcon
{
    /** The tag condition. */
    public enum Condition
    {
        /** Or condition */
        OR,
        /** And condition. */
        AND
    }
    
    private String _iconGlyph;
    private String _iconDecorator;
    private String _iconPath;
    private boolean _live;
    private boolean _restricted;
    private List<String> _tags;
    private PageType _pageType;
    private Map<String, String> _metadata;
    private Map<String, String> _properties;
    private Condition _tagsCondition;
    private Condition _metadataCondition;
    private Condition _propertiesCondition;
    
    /**
     * Constructor
     */
    public SitemapIcon ()
    {
        // nothing
    }
    
    /**
     * Configure decoration
     * @param configuration the configuration
     * @throws ConfigurationException if configuration is invalid
     */
    public void configure (Configuration configuration) throws ConfigurationException
    {
        this._iconGlyph = configuration.getChild("glyph").getValue(null);
        this._iconDecorator = configuration.getChild("decorator").getValue(null);
        this._iconPath = _configureIcon (configuration.getChild("image", false));
        this._tags = _configureTags(configuration.getChild("conditions").getChild("tags"));
        this._pageType = _configurePageType(configuration.getChild("conditions").getChild("type"));
        this._metadata = _configureMetadata(configuration.getChild("conditions").getChild("metadata"));
        this._properties = _configureProperties(configuration.getChild("conditions").getChild("properties"));
        this._live = configuration.getChild("conditions").getChild("live", false) != null;
        this._restricted = configuration.getChild("conditions").getChild("restricted", false) != null;
    }
    
    /**
     * The icon path
     * @return The icon path. Can be null.
     */
    public String getIcon()
    {
        return _iconPath;
    }
    
    /**
     * The icon glyph
     * @return The icon glyph. Can be null.
     */
    public String getIconGlyph()
    {
        return _iconGlyph;
    }
    
    /**
     * The icon decorator
     * @return The icon decorator
     */
    public String getIconDecorator()
    {
        return _iconDecorator;
    }
    
    /**
     * Get the metadata condition
     * @return the metadata condition
     */
    public Condition getMetadataCondition ()
    {
        return _metadataCondition;
    }
    
    /**
     * The tags condition
     * @return The tags condition
     */
    public Condition getTagsCondition ()
    {
        return _tagsCondition;
    }
    
    /**
     * Get the metadata condition
     * @return the metadata condition
     */
    public Condition getPropertiesCondition ()
    {
        return _propertiesCondition;
    }
    
    /**
     * The tags
     * @return The tags
     */
    public List<String> getTags ()
    {
        return _tags;
    }
    
    /**
     * The page type
     * @return The page type
     */
    public PageType getPageType ()
    {
        return _pageType;
    }
    
    /**
     * Determines the live version
     * @return true if this icon is for live version
     */
    public boolean isLive ()
    {
        return _live;
    }
    
    /**
     * Determines the limited access
     * @return true if this icon is for page with limited access
     */
    public boolean isRestricted ()
    {
        return _restricted;
    }
    
    /**
     * Get metadata
     * @return the metadata
     */
    public Map<String, String> getMetadata ()
    {
        return this._metadata;
    }
    
    /**
     * Get properties
     * @return the properties
     */
    public Map<String, String> getProperties ()
    {
        return this._properties;
    }

    private String _configureIcon (Configuration iconConf) throws ConfigurationException
    {
        if (iconConf == null)
        {
            return null;
        }
        
        String pluginName = iconConf.getAttribute("plugin");
        String path = iconConf.getValue();
        
        return "/plugins/" + pluginName + "/resources/" + path;
    }
    
    private List<String> _configureTags (Configuration tagsConf) throws ConfigurationException
    {
        List<String> tags = new ArrayList<>();
        
        this._tagsCondition = Condition.valueOf(tagsConf.getAttribute("type", "AND").toUpperCase());
        
        Configuration[] children = tagsConf.getChildren("tag");
        for (Configuration child : children)
        {
            tags.add(child.getValue());
        }
        return tags;
    }
    
    private PageType _configurePageType (Configuration child)
    {
        String value = child.getValue(null);
        return value != null ? PageType.valueOf(value.toUpperCase()) : null;
    }
    
    private Map<String, String> _configureMetadata (Configuration metadataConf) throws ConfigurationException
    {
        Map<String, String> metadata = new HashMap<>();
        
        this._metadataCondition = Condition.valueOf(metadataConf.getAttribute("type", "AND").toUpperCase());
        
        Configuration[] children = metadataConf.getChildren("metadata");
        for (Configuration child : children)
        {
            metadata.put(child.getAttribute("name"), child.getValue(""));
        }
        return metadata;
    }
    
    private Map<String, String> _configureProperties (Configuration propConf) throws ConfigurationException
    {
        Map<String, String> properties = new HashMap<>();
        
        this._propertiesCondition = Condition.valueOf(propConf.getAttribute("type", "AND").toUpperCase());
        
        Configuration[] children = propConf.getChildren("property");
        for (Configuration child : children)
        {
            properties.put(child.getAttribute("name"), child.getValue(""));
        }
        return properties;
    }
}