//
//  ========================================================================
//  Copyright (c) 1995-2017 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.quickstart;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.resource.Resource;

/**
 * Normalize Attribute to String.
 * <p>
 * Replaces and expands:
 * <ul>
 * <li>${WAR}</li>
 * <li>${WAR.path}</li>
 * <li>${WAR.uri}</li>
 * <li>${jetty.base}</li>
 * <li>${jetty.base.uri}</li>
 * <li>${jetty.home}</li>
 * <li>${jetty.home.uri}</li>
 * <li>${user.home}</li>
 * <li>${user.home.uri}</li>
 * <li>${user.dir}</li>
 * <li>${user.dir.uri}</li>
 * </ul>
 */
public class AttributeNormalizer
{
    private static final Logger LOG = Log.getLogger(AttributeNormalizer.class);
    private static final Pattern __propertyPattern = Pattern.compile("(?<=[^$]|^)\\$\\{([^}]*)\\}");
    
    private static class Attribute
    {
        final String key;
        final String value;
        final int weight;
        
        public Attribute(String key, String value, int weight)
        {
            this.key = key;
            this.value = value;
            this.weight = weight;
        }
    }

    private static URI toCanonicalURI(URI uri)
    {
        uri = uri.normalize();
        String ascii = uri.toASCIIString();
        if (ascii.endsWith("/"))
        {
            try
            {
                uri = new URI(ascii.substring(0,ascii.length()-1));
            }
            catch(URISyntaxException e)
            {
                throw new IllegalArgumentException(e);
            }
        }
        return uri;
    }
    
    private static Path toCanonicalPath(String path)
    {
        if (path == null)
            return null;
        if (path.length()>1 && path.endsWith("/"))
            path = path.substring(0,path.length()-1);
        return toCanonicalPath(FileSystems.getDefault().getPath(path));
    }
    
    private static Path toCanonicalPath(Path path)
    {
        if (path == null)
        {
            return null;
        }
        if (Files.exists(path))
        {
            try
            {
                return path.toRealPath();
            }
            catch (IOException e)
            {
                throw new IllegalArgumentException(e);
            }
        }
        return path.toAbsolutePath();
    }
    
    private static class PathAttribute extends Attribute
    {
        public final Path path;
        
        public PathAttribute(String key, Path path, int weight)
        {
            super(key,path.toString(),weight);
            this.path = path;
        }
        
        @Override
        public String toString()
        {
            return String.format("PathAttribute[%s=>%s]",key,path);
        }
    }
    
    private static class URIAttribute extends Attribute
    {
        public final URI uri;
        
        public URIAttribute(String key, URI uri, int weight)
        {
            super(key,uri.toASCIIString(),weight);
            this.uri = uri;
        }
        
        @Override
        public String toString()
        {
            return String.format("URIAttribute[%s=>%s]",key,uri);
        }
    }
    
    private static Comparator<Attribute> attrComparator = new Comparator<Attribute>()
    {
        @Override
        public int compare(Attribute o1, Attribute o2)
        {
            if( (o1.value == null) && (o2.value != null) )
            {
                return -1;
            }
            
            if( (o1.value != null) && (o2.value == null) )
            {
                return 1;
            }
            
            if( (o1.value == null) && (o2.value == null) )
            {
                return 0;
            }
            
            // Different lengths?
            int diff = o2.value.length() - o1.value.length();
            if(diff != 0)
            {
                return diff;
            }
            
            // Different names?
            diff = o2.value.compareTo(o1.value);
            if(diff != 0)
            {
                return diff;
            }
            
            // The paths are the same, base now on weight
            return o2.weight - o1.weight;
        }
    };

    private static void add(List<PathAttribute>paths,List<URIAttribute> uris,String key,int weight)
    {
        String value = System.getProperty(key);
        if (value!=null)
        {
            Path path = toCanonicalPath(value);
            paths.add(new PathAttribute(key,path,weight));
            uris.add(new URIAttribute(key+".uri",toCanonicalURI(path.toUri()),weight));
        }
    }

    private URI warURI;
    private Map<String,Attribute> attributes = new HashMap<>();
    private List<PathAttribute> paths = new ArrayList<>();
    private List<URIAttribute> uris = new ArrayList<>();
    
    public AttributeNormalizer(Resource baseResource)
    {
        if (baseResource==null)
            throw new IllegalArgumentException("No base resource!");
            
        warURI = toCanonicalURI(baseResource.getURI());
        if (!warURI.isAbsolute())
            throw new IllegalArgumentException("WAR URI is not absolute: " + warURI);
        
        add(paths,uris,"jetty.base",9);
        add(paths,uris,"jetty.home",8);
        add(paths,uris,"user.home",7);
        add(paths,uris,"user.dir",6);

        if (warURI.getScheme().equalsIgnoreCase("file"))
            paths.add(new PathAttribute("WAR.path",toCanonicalPath(new File(warURI).toString()),10));
        uris.add(new URIAttribute("WAR.uri", warURI,9)); // preferred encoding
        uris.add(new URIAttribute("WAR", warURI,8)); // legacy encoding
        
        Collections.sort(paths,attrComparator);
        Collections.sort(uris,attrComparator);
        
        Stream.concat(paths.stream(),uris.stream()).forEach(a->attributes.put(a.key,a));        
        
        if (LOG.isDebugEnabled())
        {
            for (Attribute attr : attributes.values())
            {
                LOG.debug(attr.toString());
            }
        }
    }

    /**
     * Normalize a URI, URL, or File reference by replacing known attributes with ${key} attributes.
     *
     * @param o the object to normalize into a string
     * @return the string representation of the object, with expansion keys.
     */
    public String normalize(Object o)
    {
        try
        {
            // Find a URI
            URI uri = null;
            Path path = null;
            if (o instanceof URI)
                uri = toCanonicalURI(((URI)o));
            else if (o instanceof Resource)
                uri = toCanonicalURI(((Resource)o).getURI());
            else if (o instanceof URL)
                uri = toCanonicalURI(((URL)o).toURI());
            else if (o instanceof File)
                path = ((File)o).getAbsoluteFile().getCanonicalFile().toPath();
            else if (o instanceof Path)
                path = (Path)o;
            else
            {
                String s = o.toString();
                try
                {
                    uri = new URI(s);
                    if (uri.getScheme() == null)
                    {
                        // Unknown scheme? not relevant to normalize
                        return s;
                    }
                }
                catch(URISyntaxException e)
                {
                    // This path occurs for many reasons, but most common is when this
                    // is executed on MS Windows, on a string like "D:\jetty"
                    // and the new URI() fails for
                    // java.net.URISyntaxException: Illegal character in opaque part at index 2: D:\jetty
                    return s;
                }
            }

            if (uri!=null)
            {
                if ("jar".equalsIgnoreCase(uri.getScheme()))
                {
                    String raw = uri.getRawSchemeSpecificPart();
                    int bang = raw.indexOf("!/");
                    String normal = normalize(raw.substring(0,bang));
                    String suffix = raw.substring(bang);
                    return "jar:" + normal + suffix;
                }
                else
                {
                    if(uri.isAbsolute())
                    {
                        return normalizeUri(uri);
                    }
                }
            }
            else if (path!=null)
                return normalizePath(path);
        }
        catch (Exception e)
        {
            LOG.warn(e);
        }
        return String.valueOf(o);
    }
    
    protected String normalizeUri(URI uri)
    {
        for (URIAttribute a : uris)
        {
            try
            {
                if (uri.compareTo(a.uri)==0)
                    return String.format("${%s}",a.key);

                if (!a.uri.getScheme().equalsIgnoreCase(uri.getScheme()))
                    continue;
                if (a.uri.getHost()==null && uri.getHost()!=null)
                    continue;
                if (a.uri.getHost()!=null && !a.uri.getHost().equals(uri.getHost()))
                    continue;

                if (a.uri.getPath().equals(uri.getPath()))
                    return a.value;

                if (!uri.getPath().startsWith(a.uri.getPath()))
                    continue;

                String s = uri.getPath().substring(a.uri.getPath().length());

                if (s.charAt(0)!='/')
                    continue;

                return String.format("${%s}%s",a.key,new URI(s).toASCIIString());
            }
            catch(URISyntaxException e)
            {
                LOG.ignore(e);
            }
        }
        return uri.toASCIIString();
    }

    protected String normalizePath(Path path)
    {
        for (PathAttribute a : paths)
        {
            try
            {
                if (path.equals(a.path) || Files.isSameFile(path,a.path))
                    return String.format("${%s}",a.key);
            }
            catch (IOException ignore)
            {
                LOG.ignore(ignore);
            }

            if (path.startsWith(a.path))
                return String.format("${%s}%c%s",a.key,File.separatorChar,a.path.relativize(path).toString());
        }

        return path.toString();
    }

    public String expand(String str)
    {
        return expand(str,new Stack<String>());
    }

    public String expand(String str, Stack<String> seenStack)
    {
        if (str == null)
        {
            return str;
        }

        if (str.indexOf("${") < 0)
        {
            // Contains no potential expressions.
            return str;
        }

        Matcher mat = __propertyPattern.matcher(str);
        StringBuilder expanded = new StringBuilder();
        int offset = 0;
        String property;
        String value;

        while (mat.find(offset))
        {
            property = mat.group(1);

            // Loop detection
            if (seenStack.contains(property))
            {
                StringBuilder err = new StringBuilder();
                err.append("Property expansion loop detected: ");
                int idx = seenStack.lastIndexOf(property);
                for (int i = idx; i < seenStack.size(); i++)
                {
                    err.append(seenStack.get(i));
                    err.append(" -> ");
                }
                err.append(property);
                throw new RuntimeException(err.toString());
            }

            seenStack.push(property);

            // find property name
            expanded.append(str.subSequence(offset,mat.start()));
            // get property value
            value = getString(property);
            if (value == null)
            {
                if(LOG.isDebugEnabled())
                    LOG.debug("Unable to expand: {}",property);
                expanded.append(mat.group());
            }
            else
            {
                // recursively expand
                value = expand(value,seenStack);
                expanded.append(value);
            }
            // update offset
            offset = mat.end();
        }

        // leftover
        expanded.append(str.substring(offset));

        // special case for "$$"
        if (expanded.indexOf("$$") >= 0)
        {
            return expanded.toString().replaceAll("\\$\\$","\\$");
        }

        return expanded.toString();
    }

    private String getString(String property)
    {
        if(property==null)
        {
            return null;
        }

        Attribute a = attributes.get(property);
        if (a!=null)
            return a.value;

        // Use system properties next
        return System.getProperty(property);
    }
}