/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.ode.utils;

import org.apache.commons.collections.map.MultiKeyMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.lang.StringUtils;

import javax.xml.namespace.QName;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
import java.util.Properties;
import java.util.regex.Pattern;

/**
 * This class load a list of regular property files (order matters). The main feature is that property can
 * be chained in three levels. Then when querying for a property, if it's not found in the deepest level,
 * the parent will be queryed and so on.
 * <p/>
 * A prefix must be defined to discriminate the property name and the level-1, level-2 names. The default prefix is {@link #ODE_PREFFIX}.
 * <p/>
 * Properties must respect the following pattern: [level1.[level2.]prefix.]property
 * <p/>
 * A concrete use case could be the definition of properties for wsdl services and ports.
 * <br/>Level 0 would be: values common to all services and ports.
 * <br/>Level 1: values common to a given service.
 * <br/>Level 2: values common to a given port.
 * <p/>
 * For instance, if the property file looks like this:
 * <pre>
 *alias.foo_ns=http://foo.com
 *
 * timeout=40000
 * a_namespace_with_no_alias_defined.film-service.port-of-cannes.ode.timeout=50000
 * <p/>
 * max-redirects=30
 * foo_ns.brel-service.ode.max-redirects=40
 * foo_ns.brel-service.port-of-amsterdam.ode.max-redirects=60
 * </pre>
 * The following values may be expected:
 * <pre>
 * getProperty("max-redirects")                                                         => 30
 * getProperty("http://foo.com", "brel-service", "max-redirects")                       => 40
 * getProperty("http://foo.com", "brel-service", "port-of-amsterdam", "max-redirects")  => 60
 * <p/>
 * getProperty("a_namespace_with_no_alias_defined", "film-service", "timeout")                       => 40000
 * getProperty("a_namespace_with_no_alias_defined", "film-service", "port-of-cannes", "timeout")     => 50000
 * getProperty("http://foo.com", "port-of-amsterdam", "timeout")                                     => 40000
 * </pre>
 * <p/>
 * <p>
 * Values may contain some environment variables. For instance, message=You're using ${java.version}.
 * <p/>
 * <p>
 * If a property name ends with ".file" or ".path", the assumption is made that the associated value is a path and as such is resolved against the path of the file it was loaded from.
 * </p>
 * Assigned properties must not start with 'system.' or 'env.'. These prefix are reserved to access system properties and environment variables.
 *
 * @author <a href="mailto:midon@intalio.com">Alexis Midon</a>
 */
public class HierarchicalProperties {

    private static final Log log = LogFactory.getLog(HierarchicalProperties.class);

    public static final String ODE_PREFFIX = "ode";

    private File[] files;
    private String prefix;
    private String dotted_prefix;
    /*
        This map contains ChainedMap instances chained according to the (qualified) service and/or port they are associated with.
        All ChainedMap instances has a common parent.
        The ChainedMap instances are chained to each others so that if a property is not found for [service, port],
        the ChainedMap associated to [service] will be queried, and if still not found, then the common parent.

        The ChainedMap instance common to all services and ports is associated to the [null, null] key.
        ChainedMap instance common to all ports of a given service is associated to [service, null].
        ChainedMap instance of a given service, port couple is associated to [service, port].

        The ChainedMap instances contain string values as loaded from the filesystem.
     */
    private MultiKeyMap hierarchicalMap = new MultiKeyMap();

    // map used to cache immutable versions of the maps
    private transient MultiKeyMap cacheOfImmutableMaps = new MultiKeyMap();

    /**
     * @param files  the property file to be loaded. The file may not exist.
     *               But if the file exists it has to be a file (not a directory), otherwhise an IOException is thrown. Files will be loaded in the given order.
     * @param prefix the property prefix
     * @throws IOException
     */
    public HierarchicalProperties(File[] files, String prefix) throws IOException {
        this.files = files;
        this.prefix = prefix;
        this.dotted_prefix = "." + prefix + ".";
        loadFiles();
    }

    public HierarchicalProperties(File[] files) throws IOException {
        this(files, ODE_PREFFIX);
    }

    public HierarchicalProperties(File file, String prefix) throws IOException {
        this(new File[]{file}, prefix);
    }

    public HierarchicalProperties(File file) throws IOException {
        this(new File[]{file}, ODE_PREFFIX);
    }

    public HierarchicalProperties(List<File> propFiles) throws IOException {
        this(propFiles.toArray(new File[propFiles.size()]), ODE_PREFFIX);
    }

    /**
     * Clear all existing content, then read the file and parse each property. Simply logs a message and returns if the file does not exist.
     *
     * @throws IOException if the file is a Directory
     */
    public void loadFiles() throws IOException {
        // #1. clear all existing content
        clear();

        // #3. put the root map
        initRoot();

        for (File file : files) {
            Properties props = loadFile(file);
            if(!props.isEmpty()) processProperties(props, file);
        }
        replacePlaceholders();
    }

    private ChainedMap initRoot() {
        ChainedMap root = new ChainedMap();
        hierarchicalMap.put(null, null, root);
        return root;
    }

    private void processProperties(Properties props, File file) throws IOException {

        validatePropertyNames(props, file);

        Map<String, String> nsByAlias = collectAliases(props, file);

        // #4. process each property

        for (Iterator it = props.entrySet().iterator(); it.hasNext();) {
            Map.Entry e = (Map.Entry) it.next();
            String key = (String) e.getKey();
            String value = (String) e.getValue();


            // parse the property name
            String[] info = parseProperty(key);
            String nsalias = info[0];
            String service = info[1];
            String port = info[2];
            String targetedProperty = info[3];

            QName qname = null;
            if (nsalias != null) {
                qname = new QName(nsByAlias.get(nsalias) != null ? nsByAlias.get(nsalias) : nsalias, service);
            }
            // get the map associated to this port
            ChainedMap p = (ChainedMap) hierarchicalMap.get(qname, port);
            if (p == null) {
                // create it if necessary
                // get the associated service map
                ChainedMap s = (ChainedMap) hierarchicalMap.get(qname, null);
                if (s == null) {
                    // create the service map if necessary, the parent is the root map.
                    s = new ChainedMap(getRootMap());
                    // put it in the multi-map
                    hierarchicalMap.put(qname, null, s);
                }

                // create the map itself and link it to the service map
                p = new ChainedMap(s);
                // put it in the multi-map
                hierarchicalMap.put(qname, port, p);
            }

            if(targetedProperty.endsWith(".file") || targetedProperty.endsWith(".path")){
                String absolutePath = file.toURI().resolve(value).getPath();
                if(log.isDebugEnabled()) log.debug("path: "+value+" resolved into: "+absolutePath);
                value = absolutePath;
            }

            // save the key/value in its chained map
            if(log.isDebugEnabled()) log.debug("New property: "+targetedProperty+" -> "+value);
            p.put(targetedProperty, value);
        }
    }

    private Properties loadFile(File file) throws IOException {
        Properties props = new Properties();
        if (!file.exists()) {
            if (log.isDebugEnabled()) log.debug("File does not exist [" + file + "]");
            return props;
        }
        // #2. read the file
        FileInputStream fis = new FileInputStream(file);
        try {
            if (log.isDebugEnabled()) log.debug("Loading property file: " + file);
            props.load(fis);
        } finally {
            fis.close();
        }
        return props;
    }

    private Map<String, String> collectAliases(Properties props, File file) {
        // gather all aliases
        Map<String, String> nsByAlias = new HashMap<String, String>();

        // replace env variable by their values and collect namespace aliases
        for (Iterator it = props.entrySet().iterator(); it.hasNext();) {
            Map.Entry e = (Map.Entry) it.next();
            String key = (String) e.getKey();
            String value = (String) e.getValue();

            if (key.startsWith("alias.")) {
                // we found an namespace alias
                final String alias = key.substring("alias.".length(), key.length());
                if (log.isDebugEnabled()) log.debug("Alias found: " + alias + " -> " + value);
                if (nsByAlias.containsKey(alias) && value.equals(nsByAlias.get(alias)))
                    throw new RuntimeException("Same alias used twice for 2 different namespaces! file=" + file + ", alias=" + alias);
                nsByAlias.put(alias, value);
                // remove the pair from the Properties
                it.remove();
            }
        }
        return nsByAlias;
    }

    private void validatePropertyNames(Properties props, File file) {
        List invalids = new ArrayList();
        for (Iterator<Object> it = props.keySet().iterator(); it.hasNext();) {
            String name = (String) it.next();
            if(name.startsWith("system.") || name.startsWith("env.")) invalids.add(name);
        }
        if(!invalids.isEmpty()){
            throw new IllegalArgumentException("Property files cannot define properties starting with 'system.' nor 'env.' File="+file+". Invalid names="+StringUtils.join(invalids, ","));
        }
    }


    private void replacePlaceholders() {
        Pattern systemProperty = Pattern.compile("\\$\\{system\\.([^\\}]+)\\}");
        Pattern environmentVariable = Pattern.compile("\\$\\{env\\.([^\\}]+)\\}");
        Pattern localPlaceholder = Pattern.compile("\\$\\{([^\\}]+)\\}");
        for (Iterator it = hierarchicalMap.values().iterator(); it.hasNext();) {
            Map properties = ((ChainedMap) it.next()).child;
            for (Iterator it1 = properties.entrySet().iterator(); it1.hasNext();) {
                Map.Entry e = (Map.Entry) it1.next();
                // /!\ replacement values themselves might contain placeholders. So always retrieve the value from the map entry
                e.setValue(SystemUtils.replaceProperties((String) e.getValue(), localPlaceholder, getRootMap().child));
                e.setValue(SystemUtils.replaceProperties((String) e.getValue(), systemProperty, System.getProperties()));
                e.setValue(SystemUtils.replaceProperties((String) e.getValue(), environmentVariable, System.getenv()));
            }
        }
    }

    /**
     * Clear all content. If {@link #loadFiles()} is not invoked later, all returned values will be null.
     */
    public void clear() {
        hierarchicalMap.clear();
        cacheOfImmutableMaps.clear();
    }

    protected ChainedMap getRootMap() {
        Object o = hierarchicalMap.get(null, null);
        if (o == null) {
            o = initRoot();
        }
        return (ChainedMap) o;
    }

    public Map getProperties(String serviceNamespaceURI, String serviceLocalPart) {
        return getProperties(new QName(serviceNamespaceURI, serviceLocalPart));
    }

    /**
     * @param service
     * @return a map containing all the properties for the given service.
     * @see #getProperties(String, String)
     */
    public Map getProperties(QName service) {
        return getProperties(service, null);
    }

    public Map getProperties(String serviceNamespaceURI, String serviceLocalPart, String port) {
        return getProperties(new QName(serviceNamespaceURI, serviceLocalPart), port);
    }

    /**
     * Return a map containing all the properties for the given port. The map is an immutable snapshot of the properties.
     * Meaning that futur changes to the properties will NOT be reflected in the returned map.
     *
     * @param service
     * @param port
     * @return a map containing all the properties for the given port
     */
    public Map getProperties(QName service, String port) {
        // no need to go further if no properties
        if (hierarchicalMap.isEmpty()) return Collections.EMPTY_MAP;

        // else check the cache of ChainedMap already converted into immutable maps
        Map cachedMap = (Map) this.cacheOfImmutableMaps.get(service, port);
        if (cachedMap != null) {
            return cachedMap;
        }

        // else get the corresponding ChainedMap and convert it into a Map
        ChainedMap cm = (ChainedMap) hierarchicalMap.get(service, port);
        // if this port is not explicitly mentioned in the multimap, get the default values.
        if (cm == null) {
            cm = (ChainedMap) hierarchicalMap.get(service, null);
            if (cm == null) {
                // return the cached version of the root map
                return getProperties((QName) null, null);
            }
        }
        Map snapshotMap = new HashMap(cm.size() * 15 / 10);
        for (Object key : cm.keySet()) {
            snapshotMap.put(key, cm.get(key));
        }
        snapshotMap = Collections.unmodifiableMap(snapshotMap);
        // put it in cache to avoid creating one map at each invocation
        this.cacheOfImmutableMaps.put(service, port, snapshotMap);
        return snapshotMap;
    }

    public String getProperty(String property) {
        return (String) getRootMap().get(property);
    }

    public String getProperty(String serviceNamespaceURI, String serviceLocalPart, String property) {
        return getProperty(new QName(serviceNamespaceURI, serviceLocalPart), property);
    }

    public String getProperty(QName service, String property) {
        return getProperty(service, null, property);
    }

    public String getProperty(String serviceNamespaceURI, String serviceLocalPart, String port, String property) {
        return getProperty(new QName(serviceNamespaceURI, serviceLocalPart), port, property);
    }

    public String getProperty(QName service, String port, String property) {
        return (String) getProperties(service, port).get(property);
    }

    public String getPrefix() {
        return prefix;
    }


    private String[] parseProperty(String property) {
        // aliaas ns, service, port, targeted property
        String[] res = new String[4];

        int index = property.indexOf(dotted_prefix);
        if (index <= 0) {
            // assume there is no service/port prefixed, no need to go further
            res[3] = property;
        } else {
            res[3] = property.substring(index + dotted_prefix.length()); // targeted property
            String prefix = property.substring(0, index);
            String[] t = prefix.split("\\.");
            if (t.length != 2 && t.length != 3) {
                throw new IllegalArgumentException("Invalid property name:" + property + " Expected pattern: [nsalias.service.[port.]" + prefix + ".]property");
            }
            if (t.length >= 2) {
                res[0] = t[0]; // ns alias
                res[1] = t[1]; // service name
            }
            if (t.length > 2) {
                res[2] = t[2]; // port name
            }
        }
        return res;
    }

    /**
     * Link two Maps instances in a parent-child relation. Meaning that if a key is looked up but not found on the child,
     * then the key will be looked up on the parent map.
     * <br/>The raison d'etre of this class is to the {@link #keySet()} method. This methods returns a set of <strong>all</strong> the keys contained in the child and the parent.
     * That's the main reason to not used the {@link java.util.Properties} class (which offers access to child keys only).
     * <p/>The child has an immutable view of the parent map. Methods {@link #clear()} and {@link #remove(Object)}
     * throw {@link UnsupportedOperationException}. Methods {@link #put(Object, Object)} and  {@link #putAll(java.util.Map)} impacts only the child map.
     * <br/>Methods  {@link #clearLocally()}
     * <p/>
     * This class does NOT implement the {@link java.util.Map} interface because methods {@link java.util.Map#entrySet()} },
     * {@link java.util.Map#values()} and {@link java.util.Map#keySet()} would NOT be backed by the Map itself.
     * <br/> Contributions welcome to implement that part.
     *
     * @author <a href="mailto:midon@intalio.com">Alexis Midon</a>
     */
    private static class ChainedMap {

        private ChainedMap parent;
        private Map child;

        public ChainedMap() {
            parent = null;
            child = new HashMap();
        }

        public ChainedMap(ChainedMap parent) {
            this.parent = parent;
            this.child = new HashMap();
        }

        public ChainedMap getParent() {
            return parent;
        }

        public void setParent(ChainedMap parent) {
            this.parent = parent;
        }

        /**
         * Perfom a look up on the child map only.
         */
        public Object getLocally(Object key) {
            return child.get(key);
        }

        /**
         * Clear the child map only, the parent map is not altered.
         */
        public void clearLocally() {
            child.clear();
        }

        /**
         * Perform a look up for the given key on the child map, and if not found then perform the look up on the parent map.
         *
         * @param key
         * @return
         */
        public Object get(Object key) {
            Object lv = getLocally(key);
            if (lv != null) return lv;
            else if (parent != null) return parent.get(key);
            return null;
        }

        /**
         * Put this pair in the child map.
         */
        public Object put(Object key, Object value) {
            if (key == null) throw new NullPointerException("Null keys forbidden!");
            return child.put(key, value);
        }


        /**
         * Put these pairs in the child map.
         */
        public void putAll(Map t) {
            for (Object e : t.entrySet()) {
                put(((Map.Entry) e).getKey(), ((Map.Entry) e).getValue());
            }
        }

        /**
         * @throws UnsupportedOperationException
         * @see #clearLocally()
         */
        public void clear() {
            throw new UnsupportedOperationException();
        }

        /**
         * @throws UnsupportedOperationException
         */
        public Object remove(Object key) {
            throw new UnsupportedOperationException();
        }

        /**
         * @return true if the child map is empty AND the parent map is null or empty as well.
         *         <pre>child.isEmpty() && (parent == null || parent.isEmpty());</pre>
         */
        public boolean isEmpty() {
            return child.isEmpty() && (parent == null || parent.isEmpty());
        }

        /**
         * @return true if the child map contains this key OR the parent map is not null and contains this key.
         *         <pre>child.containsKey(key) || (parent != null && parent.containsKey(key));</pre>
         */
        public boolean containsKey(Object key) {
            if (key == null) throw new NullPointerException("Null keys forbidden!");
            return child.containsKey(key) || (parent != null && parent.containsKey(key));
        }

        /**
         * @return true if the child map contains this value OR the parent is not null
         *         <pre>child.containsValue(value) || (parent != null && parent.containsValue(value));</pre>
         */
        public boolean containsValue(Object value) {
            return child.containsValue(value) || (parent != null && parent.containsValue(value));
        }

        public int size() {
            return keySet().size();
        }

        /**
         * @return a new set instance merging all keys contained in the child and parent maps. <strong>The returned set is not backed by the maps.</strong>
         *         Any references to the returned sets are hold at the holder's own risks. This breaks the general {@link java.util.Map#entrySet()} contract.
         */
        public Set keySet() {
            HashSet s = new HashSet(child.keySet());
            if (parent != null) s.addAll(parent.keySet());
            return s;
        }
    }
}