/*
 * 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.cauldron.bld.config;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeSet;

import org.cauldron.bld.bnd.BundleBuilder;
import org.cauldron.bld.core.internal.model.osgi.BundleModelElement;
import org.cauldron.bld.core.internal.model.osgi.PackageExport;
import org.cauldron.bld.core.internal.model.osgi.PackageImport;
import org.cauldron.bld.core.internal.model.osgi.RequiredBundle;
import org.cauldron.sigil.model.IModelElement;
import org.cauldron.sigil.model.common.VersionRange;
import org.cauldron.sigil.model.eclipse.ISigilBundle;
import org.cauldron.sigil.model.osgi.IBundleModelElement;
import org.cauldron.sigil.model.osgi.IPackageExport;
import org.cauldron.sigil.model.osgi.IPackageImport;
import org.cauldron.sigil.model.osgi.IRequiredBundle;
import org.cauldron.sigil.model.osgi.IPackageImport.OSGiImport;
import org.osgi.framework.Version;

public class BldProject implements IBldProject, IRepositoryConfig {
    private static final String OVERRIDE_PREFIX = "sigil.";
    private static final int MAX_HEADER = 10240;
    // cache to avoid loading the same default config for each project
    private static Map<URL, BldConfig> defaultsCache = new HashMap<URL, BldConfig>();
    private static Properties overrides;

    private List<String> sourcePkgs;
    private BldConfig config;
    private BldConverter convert;
    private BundleModelElement requirements;
    private File baseDir;
    private URI loc;
    private Properties packageDefaults;
    private TreeSet<String> packageWildDefaults;
    private long lastModified;

    /* package */BldProject(URI relLoc) {
        config = new BldConfig();
        convert = new BldConverter(config);
        loc = new File(".").toURI().resolve(relLoc).normalize();
        File f = new File(loc);
        lastModified = f.lastModified();
        baseDir = f.getParentFile();
    }

    /* package */void load() throws IOException {
        // allow System property overrides, e.g.
        // ANT_OPTS='-Dsigil.option\;addMissingImports=false' ant
        config.merge(getOverrides());

        InputStream in = null;
        try {
        	in = loc.toURL().openStream();
	        BufferedInputStream bis = new BufferedInputStream(in);
	        bis.mark(MAX_HEADER);
	        readHeader(bis);
	        bis.reset();
	
	        Properties p = new Properties();
	        p.load(bis);
	        config.merge(p);
	
	        Properties unknown = config.getUnknown();
	        if (!unknown.isEmpty())
	            System.err.println("WARN: unknown keys " + unknown.keySet() + " in " + loc);
	
	        loadDefaults(p);
	        requirements = parseRequirements();
        }
        finally {
        	if ( in != null ) {
        		in.close();
        	}
        }
    }

    /* package */void loadDefaults(Properties p) throws IOException {
        BldConfig c = loadDefaults(p, baseDir, null);
        config.setDefault(c);

        Properties options = config.getProps(null, BldConfig.P_OPTION);

        if (!options.containsKey(BldAttr.OPTION_ADD_IMPORTS))
            c.setProp(null, BldConfig.P_OPTION, BldAttr.OPTION_ADD_IMPORTS, "true");

        // default omitUnusedImports option depends on number of bundles...
        // we set it here to avoid it being written by save(),
        // but as this may alter cached defaults, once set we have to reset it
        // for each project.

        boolean omitSet = options.containsKey("__omit_set__");
        boolean multiple = getBundleIds().size() > 1;

        if (multiple || omitSet) {
            if (!options.containsKey(BldAttr.OPTION_OMIT_IMPORTS) || omitSet) {
                c.setProp(null, BldConfig.P_OPTION, BldAttr.OPTION_OMIT_IMPORTS, multiple + "");
                c.setProp(null, BldConfig.P_OPTION, "__omit_set__", "true");
            }
        }
    }

    private synchronized BldConfig loadDefaults(Properties props, File base, BldConfig dflt)
            throws IOException {
        boolean cached = false;
        String defaults = props.getProperty(BldConfig.S_DEFAULTS, "-"
                + IBldProject.PROJECT_DEFAULTS);

        if (base != null && defaults.length() > 0) {
            boolean ignore = defaults.startsWith("-");

            if (ignore)
                defaults = defaults.substring(1);

            try {
                File file = new File(base, defaults).getCanonicalFile();
                URL url = file.toURL();

                if (dflt == null) {
                    dflt = defaultsCache.get(url);
                    if (dflt != null)
                        return dflt;

                    dflt = new BldConfig();
                    defaultsCache.put(url, dflt);
                    cached = true;
                }

                Properties p = new Properties();
                p.load(url.openStream());
                dflt.merge(p);

                ignore = false;
                loadDefaults(p, file.getParentFile(), dflt);
            } catch (IOException e) {
                if (!ignore)
                    throw e;
            }
        }

        if (dflt == null)
            return new BldConfig();

        if (cached) {
            Properties unknown = dflt.getUnknown();
            if (!unknown.isEmpty())
                System.err.println("WARN: unknown keys " + unknown.keySet() + " in defaults for "
                        + loc);
        }

        return dflt;
    }

    private static Properties getOverrides() {
        if (overrides == null) {
            overrides = new Properties();
            Properties sysProps = System.getProperties();

            for (Object okey : sysProps.keySet()) {
                String key = (String) okey;
                if (key.startsWith(OVERRIDE_PREFIX)) {
                    overrides.setProperty(key.substring(OVERRIDE_PREFIX.length()), sysProps
                            .getProperty(key));
                }
            }
        }

        return overrides;
    }

    private void readHeader(InputStream in) throws IOException {
        BufferedReader r = new BufferedReader(new InputStreamReader(in));
        StringBuffer header = new StringBuffer();
        String line;
        while ((line = r.readLine()) != null) {
            if (line.startsWith("#")) {
                header.append(line);
                header.append("\n");
            } else {
                config.setComment(header.toString());
                break;
            }
        }
    }

    public File resolve(String path) {
        File file = new File(path);
        if (!file.isAbsolute()) {
            // can't use loc.resolve(value), as value may not be valid URI.
            file = new File(baseDir, path);
        }
        return file;
    }

    public String getVersion() {
        String version = config.getString(null, BldConfig.S_VERSION);
        return version == null ? "0" : version;
    }

    public IBundleModelElement getDependencies() {
        IBundleModelElement dependencies = new BundleModelElement();

        for (IModelElement element : getRequirements().children()) {
            if (element instanceof IPackageImport) {
                IPackageImport import1 = (IPackageImport) element;
                if (!import1.isDependency())
                    continue;

                IPackageImport pi = (IPackageImport) (element.clone());
                pi.setParent(null);
                dependencies.addImport(pi);
            } else {
                IRequiredBundle rb = (IRequiredBundle) (element.clone());
                rb.setParent(null);
                dependencies.addRequiredBundle(rb);
            }
        }

        boolean containsComposite = false;

        for (IBldBundle bundle : getBundles()) {
            if (!bundle.getComposites().isEmpty()) {
                containsComposite = true;
                break;
            }
        }

        // add dependency on component activator
        if (containsComposite) {
            PackageImport pi = new PackageImport();
            pi.setPackageName(BundleBuilder.COMPONENT_ACTIVATOR_PKG);
            pi.setOSGiImport(OSGiImport.NEVER);
            dependencies.addImport(pi);
        }

        return dependencies;
    }

    private IBundleModelElement getRequirements() {
        return requirements;
    }

    /*
     * private boolean globMatch(String pkg, Set<String> set) { // exact match
     * if (set.contains(pkg)) return true;
     * 
     * // org.foo.bar matches org.foo. for (String glob : set) { if
     * (glob.matches(pkg)) { return true; } }
     * 
     * return false; }
     */

    /**
     * set internal OSGiImport and isDependency flags, based on external
     * resolution= attribute.
     * 
     * OSGiImport: AUTO ALWAYS NEVER dependency: default - compile !dependency:
     * auto runtime ignore
     * 
     */
    private void setResolve(IPackageImport pi, String resolve) throws IOException {
        if (pi.isOptional())
            pi.setDependency(false);

        if (BldAttr.RESOLVE_COMPILE.equals(resolve)) {
            if (pi.isOptional())
                pi.setDependency(true);
            else
                pi.setOSGiImport(OSGiImport.NEVER);
        } else if (BldAttr.RESOLVE_RUNTIME.equals(resolve)) {
            pi.setDependency(false);
            pi.setOSGiImport(OSGiImport.ALWAYS);
        } else if (BldAttr.RESOLVE_AUTO.equals(resolve)) {
            pi.setDependency(false);
        } else if (BldAttr.RESOLVE_IGNORE.equals(resolve)) {
            pi.setDependency(false);
            pi.setOSGiImport(OSGiImport.NEVER);
        } else if (resolve != null) {
            throw new IOException("Bad attribute value: " + BldAttr.RESOLVE_ATTRIBUTE + "="
                    + resolve);
        }
    }

    /**
     * get external resolve= attribute from internal PackageImport flags. This
     * is called from BldConverter.setBundle().
     */
    public static String getResolve(IPackageImport pi, boolean isDependency) {
        OSGiImport osgiImport = pi.getOSGiImport();
        String resolve = null;

        if (isDependency) {
            if (osgiImport.equals(OSGiImport.NEVER) || pi.isOptional())
                resolve = BldAttr.RESOLVE_COMPILE;
        } else {
            switch (osgiImport) {
            case ALWAYS:
                resolve = BldAttr.RESOLVE_RUNTIME;
                break;
            case AUTO:
                resolve = BldAttr.RESOLVE_AUTO;
                break;
            case NEVER:
                resolve = BldAttr.RESOLVE_IGNORE;
                break;
            }
        }
        return resolve;
    }

    public String getDefaultPackageVersion(String name) {
        if (packageDefaults == null) {
            packageDefaults = config.getProps(null, BldConfig.P_PACKAGE_VERSION);
            packageWildDefaults = new TreeSet<String>();

            for (Object key : packageDefaults.keySet()) {
                String pkg = (String) key;
                if (pkg.endsWith("*")) {
                    packageWildDefaults.add(pkg.substring(0, pkg.length() - 1));
                }
            }
        }

        String version = packageDefaults.getProperty(name);

        if (version == null) {
            for (String pkg : packageWildDefaults) {
                if (name.startsWith(pkg)) {
                    version = packageDefaults.getProperty(pkg + "*");
                    // break; -- don't break, as we want the longest match
                }
            }
        }

        return version;
    }

    private synchronized BundleModelElement parseRequirements() throws IOException {
        BundleModelElement reqs = new BundleModelElement();

        List<String> sourceContents = getSourcePkgs();
        HashSet<String> exports = new HashSet<String>();

        for (IBldBundle bundle : getBundles()) {
            for (IPackageExport export : bundle.getExports()) {
                exports.add(export.getPackageName());
            }
        }

        Map<String, Map<String, String>> imports = config.getMap(null, BldConfig.M_IMPORTS);

        for (String name : imports.keySet()) {
            Map<String, String> attr = imports.get(name);

            String resolve = attr.get(BldAttr.RESOLVE_ATTRIBUTE);
            String resolution = attr.get(BldAttr.RESOLUTION_ATTRIBUTE);
            String versions = attr.containsKey(BldAttr.VERSION_ATTRIBUTE) ? attr
                    .get(BldAttr.VERSION_ATTRIBUTE) : getDefaultPackageVersion(name);

            PackageImport pi = new PackageImport();
            pi.setPackageName(name);

            // avoid dependency on self-exports
            // XXX: BldConverter.setBundle contains similar logic
            if (exports.contains(name)
                    && (sourceContents.contains(name) || sourceContents.isEmpty())) {
                pi.setDependency(false);
                if (versions == null)
                    versions = getVersion();
            }

            if (!checkVersionRange(versions)) {
                throw new IOException("Failed to parse version range for " + resolve
                        + " missing \"'s around version range?");
            }

            pi.setVersions(VersionRange.parseVersionRange(versions));

            if (BldAttr.RESOLUTION_OPTIONAL.equals(resolution)) {
                pi.setOptional(true);
            } else if (resolution != null) {
                throw new IOException("Bad attribute value: " + BldAttr.RESOLUTION_ATTRIBUTE + "="
                        + resolution);
            }

            setResolve(pi, resolve);

            reqs.addImport(pi);
        }

        Map<String, Map<String, String>> requires = config.getMap(null, BldConfig.M_REQUIRES);
        Properties bundleDefaults = config.getProps(null, BldConfig.P_BUNDLE_VERSION);

        if (requires != null) {
            for (String name : requires.keySet()) {
                Map<String, String> attr = requires.get(name);
                String versions = attr.containsKey(BldAttr.VERSION_ATTRIBUTE) ? attr
                        .get(BldAttr.VERSION_ATTRIBUTE) : bundleDefaults.getProperty(name);

                RequiredBundle rb = new RequiredBundle();
                rb.setSymbolicName(name);
                rb.setVersions(VersionRange.parseVersionRange(versions));

                reqs.addRequiredBundle(rb);
            }
        }

        for (IBldBundle bundle : getBundles()) {
            IRequiredBundle fh = bundle.getFragmentHost();
            if (fh != null)
                reqs.addRequiredBundle(fh);
        }

        return reqs;
    }

    private boolean checkVersionRange(String versions) {
        if (versions == null || versions.length() == 0) {
            return true;
        } else {
            switch (versions.charAt(0)) {
            case '(':
            case '[':
                switch (versions.charAt(versions.length() - 1)) {
                case ')':
                case ']':
                    return true;
                default:
                    return false;
                }
            default:
                return true;
            }
        }
    }

    public List<String> getBundleIds() {
        List<String> ids = config.getList(null, BldConfig.C_BUNDLES);
        if (ids == null)
            return Collections.emptyList();
        return ids;
    }

    public List<IBldBundle> getBundles() {
        ArrayList<IBldBundle> list = new ArrayList<IBldBundle>();

        for (String id : getBundleIds()) {
            list.add(new BldBundle(id));
        }

        return list;
    }

    // Implement IBldConfig: getRepositoryConfig

    public Map<String, Properties> getRepositoryConfig() {
        HashMap<String, Properties> map = new HashMap<String, Properties>();

        final Map<String, String> env = System.getenv();
        final Properties props = new Properties();
        try {
            // supports ${.} and ${..} expansions
            props.setProperty(".", resolve(".").getCanonicalPath());
            props.setProperty("..", resolve("..").getCanonicalPath());
        } catch (IOException e) {
        }

        for (String name : config.getList(null, BldConfig.C_REPOSITORIES)) {
            Properties repo = config.getProps(null, name);

            for (Object k : repo.keySet()) {
                String key = (String) k;
                String value = repo.getProperty(key);

                String expand = BldUtil.expand(value, new Properties() {
                    public String getProperty(String name) {
                        return props.getProperty(name, env.get(name));
                    }
                });

                if (!value.equals(expand)) {
                    value = expand;
                    repo.setProperty(key, value);
                }

                // backwards compatible support before ${.} and ${..} was added
                if (value.startsWith("./") || value.startsWith("../")) {
                    try {
                        // need canonical path, to normalise
                        value = resolve(value).getCanonicalPath();
                    } catch (IOException e) {
                    }
                    repo.setProperty(key, value);
                }
            }

            map.put(name, repo);
        }
        return map;
    }

    public Properties getOptions() {
        return config.getProps(null, BldConfig.P_OPTION);
    }

    public Properties getDefaultPackageVersions() {
        return config.getProps(null, BldConfig.P_PACKAGE_VERSION);
    }

    public ISigilBundle getDefaultBundle() {
        List<String> bundles = getBundleIds();
        if (bundles.isEmpty())
            return null;

        String id = bundles.get(0);
        return getSigilBundle(id);
    }

    public ISigilBundle getSigilBundle(String id) {
        BldBundle bundle = new BldBundle(id);
        return convert.getBundle(id, bundle);
    }

    public void setDefaultBundle(ISigilBundle bundle) {
        setSigilBundle(null, bundle);
    }

    public void setSigilBundle(String id, ISigilBundle bundle) {
        List<String> ids = getBundleIds();

        if (ids.isEmpty()) {
            ArrayList<String> list = new ArrayList<String>();
            list.add(id == null ? bundle.getBundleInfo().getSymbolicName() : id);
            config.setList(null, BldConfig.C_BUNDLES, list);
        } else if (id == null) {
            id = ids.get(0);
        } else if (!ids.contains(id)) {
            List<String> list = config.getList(null, BldConfig.C_BUNDLES);
            list.add(id);
            config.setList(null, BldConfig.C_BUNDLES, list);
        }

        if (ids.size() == 1)
            id = null; // don't prefix default bundle with id

        convert.setBundle(id, bundle);
    }

    public void save() throws IOException {
        saveAs(new File(loc));
    }

    public void saveAs(File path) throws IOException {
        File part = new File(path.getPath() + ".part");
        saveTo(new FileOutputStream((part)));

        path.delete();
        if (!part.renameTo(path))
            throw new IOException("failed to rename " + part + " to " + path);
    }

    public void saveTo(OutputStream out) {
        PrintWriter writer = new PrintWriter(new OutputStreamWriter(out));
        config.write(writer);
        writer.close();
    }

    public List<String> getSourceDirs() {
        List<String> list = config.getList(null, BldConfig.L_SRC_CONTENTS);
        return list != null ? list : Collections.<String> emptyList();
    }

    public List<String> getSourcePkgs() {
        if (sourcePkgs == null) {
            sourcePkgs = new ArrayList<String>();
            for (String src : getSourceDirs()) {
                File dir = resolve(src);
                if (!dir.isDirectory()) {
                    System.err.println("WARN: sourcedir does not exist: " + dir);
                    continue;
                    // throw new RuntimeException("sourcedir: " + dir +
                    // " : is not a directory.");
                }
                findSrcPkgs(dir, null, sourcePkgs);
            }
        }

        return sourcePkgs;
    }

    private void findSrcPkgs(File dir, String pkg, List<String> result) {
        ArrayList<File> dirs = new ArrayList<File>();
        boolean found = false;

        for (String name : dir.list()) {
            if (name.endsWith(".java")) {
                found = true;
            } else if (!name.equals(".svn")) {
                File d = new File(dir, name);
                if (d.isDirectory())
                    dirs.add(d);
            }
        }

        if (pkg == null) {
            pkg = "";
        } else if (pkg.equals("")) {
            pkg = dir.getName();
        } else {
            pkg = pkg + "." + dir.getName();
        }

        if (found)
            result.add(pkg);

        for (File d : dirs)
            findSrcPkgs(d, pkg, result);
    }

    /**
     * BldBundle
     * 
     */
    class BldBundle implements IBldBundle {
        private String id;

        public BldBundle(String id) {
            this.id = id;
        }

        public File resolve(String path) {
            return BldProject.this.resolve(path);
        }

        private String getString(String key) {
            return config.getString(id, key);
        }

        private List<String> getList(String key) {
            List<String> list = config.getList(id, key);
            return list != null ? list : Collections.<String> emptyList();
        }

        private Map<String, Map<String, String>> getMap(String key) {
            Map<String, Map<String, String>> map = config.getMap(id, key);
            return map != null ? map : Collections.<String, Map<String, String>> emptyMap();
        }

        public String getActivator() {
            return getString(BldConfig.S_ACTIVATOR);
        }

        public String getId() {
            String name = getString("id");
            return name != null ? name : id;
        }

        public String getVersion() {
            String ver = getString(BldConfig.S_VERSION);
            if (ver == null) {
                ver = BldProject.this.getVersion();
            }
            return ver;
        }

        public String getSymbolicName() {
            String name = getString(BldConfig.S_SYM_NAME);
            return name != null ? name : getId();
        }

        public List<IPackageExport> getExports() {
            ArrayList<IPackageExport> list = new ArrayList<IPackageExport>();
            Map<String, Map<String, String>> exports = getMap(BldConfig.M_EXPORTS);

            if (exports != null) {
                for (String name : exports.keySet()) {
                    Map<String, String> attrs = exports.get(name);
                    PackageExport pkgExport = new PackageExport();
                    pkgExport.setPackageName(name);

                    String version = attrs.get(BldAttr.VERSION_ATTRIBUTE);
                    // only default export version from local packages
                    if (version == null
                            && (getSourcePkgs().isEmpty() || getSourcePkgs().contains(name))) {
                        version = getVersion();
                    }

                    if (version != null)
                        pkgExport.setVersion(new Version(version));

                    list.add(pkgExport);
                }
            }

            return list;
        }

        public List<IPackageImport> getImports() {
            ArrayList<IPackageImport> list = new ArrayList<IPackageImport>();

            for (IPackageImport import1 : getRequirements().childrenOfType(IPackageImport.class)) {
                list.add(import1);
            }

            return list;
        }

        public List<IRequiredBundle> getRequires() {
            ArrayList<IRequiredBundle> list = new ArrayList<IRequiredBundle>();
            list.addAll(Arrays.asList(getRequirements().childrenOfType(IRequiredBundle.class)));

            for (IBldBundle bundle : getBundles()) {
                IRequiredBundle fh = bundle.getFragmentHost();
                if (fh != null)
                    list.remove(fh);
            }

            return list;
        }

        public IRequiredBundle getFragmentHost() {
            IRequiredBundle fragment = null;
            Map<String, Map<String, String>> fragments = getMap(BldConfig.M_FRAGMENT);
            if (fragments != null) {
                for (String name : fragments.keySet()) {
                    Map<String, String> attr = fragments.get(name);
                    String versions = attr.isEmpty() ? null : attr.get(BldAttr.VERSION_ATTRIBUTE);
                    fragment = new RequiredBundle();
                    fragment.setSymbolicName(name);
                    fragment.setVersions(VersionRange.parseVersionRange(versions));
                    break;
                }
            }

            return fragment;
        }

        public Map<String, Map<String, String>> getLibs() {
            Map<String, Map<String, String>> libs = getMap(BldConfig.M_LIBS);
            return (libs != null) ? libs : Collections.<String, Map<String, String>> emptyMap();
        }

        public List<String> getContents() {
            return getList(BldConfig.L_CONTENTS);
        }

        public List<String> getDownloadContents() {
            return getList(BldConfig.L_DL_CONTENTS);
        }

        public List<String> getComposites() {
            ArrayList<String> list = new ArrayList<String>();
            for (String composite : getList(BldConfig.L_COMPOSITES)) {
                list.add(composite);
            }

            return list;
        }

        public Map<String, String> getResources() {
            HashMap<String, String> map = new HashMap<String, String>();
            List<String> resources = getList(BldConfig.L_RESOURCES);

            if (resources != null) {
                for (String resource : resources) {
                    String[] paths = resource.split("=", 2);
                    String fsPath = (paths.length > 1 ? paths[1] : "");
                    map.put(paths[0], fsPath);
                }
            }
            return map;
        }

        public Properties getHeaders() {
            Properties headers = config.getProps(id, BldConfig.P_HEADER);
            return headers;
        }

    }

    public long getLastModified() {
        return lastModified;
    }

}