/*
 *  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.ivy.ant;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.ParseException;
import java.util.Arrays;
import java.util.List;

import javax.xml.transform.TransformerConfigurationException;

import org.apache.ivy.Ivy;
import org.apache.ivy.core.IvyContext;
import org.apache.ivy.core.cache.DefaultRepositoryCacheManager;
import org.apache.ivy.core.cache.RepositoryCacheManager;
import org.apache.ivy.core.settings.IvySettings;
import org.apache.ivy.osgi.obr.xml.OBRXMLWriter;
import org.apache.ivy.osgi.repo.ArtifactReportManifestIterable;
import org.apache.ivy.osgi.repo.FSManifestIterable;
import org.apache.ivy.osgi.repo.ManifestAndLocation;
import org.apache.ivy.osgi.repo.ResolverManifestIterable;
import org.apache.ivy.plugins.resolver.BasicResolver;
import org.apache.ivy.plugins.resolver.DependencyResolver;
import org.apache.ivy.util.Message;
import org.apache.tools.ant.BuildException;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

public class BuildOBRTask extends IvyCacheTask {

    private String resolverName = null;

    private File file = null;

    private String cacheName = null;

    private String encoding = "UTF-8";

    private boolean indent = true;

    private File baseDir;

    private boolean quiet;

    private List<String> sourceTypes = Arrays.asList("source", "sources", "src");

    public void setResolver(String resolverName) {
        this.resolverName = resolverName;
    }

    public void setCache(String cacheName) {
        this.cacheName = cacheName;
    }

    public void setOut(File file) {
        this.file = file;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public void setIndent(boolean indent) {
        this.indent = indent;
    }

    public void setBaseDir(File dir) {
        this.baseDir = dir;
    }

    public void setQuiet(boolean quiet) {
        this.quiet = quiet;
    }

    public void setSourceType(String sourceType) {
        this.sourceTypes = Arrays.asList(sourceType.split(","));
    }

    protected void prepareTask() {
        // if browsing a folder, not need for an Ivy instance
        if (baseDir == null) {
            super.prepareTask();
        }
        // ensure the configured source type get also resolved
        if (getType() != null && !getType().equals("*") && sourceTypes != null
                && !sourceTypes.isEmpty()) {
            StringBuilder buffer = new StringBuilder(getType());
            for (String sourceType : sourceTypes) {
                buffer.append(",");
                buffer.append(sourceType);
            }
            setType(buffer.toString());
        }
    }

    public void doExecute() throws BuildException {
        if (file == null) {
            throw new BuildException("No output file specified: use the attribute 'out'");
        }

        Iterable<ManifestAndLocation> it;
        if (resolverName != null) {
            if (baseDir != null) {
                throw new BuildException("specify only one of 'resolver' or 'baseDir'");
            }
            if (cacheName != null) {
                throw new BuildException("specify only one of 'resolver' or 'cache'");
            }
            Ivy ivy = getIvyInstance();
            IvySettings settings = ivy.getSettings();
            DependencyResolver resolver = settings.getResolver(resolverName);
            if (resolver == null) {
                throw new BuildException("the resolver '" + resolverName + "' was not found");
            }
            if (!(resolver instanceof BasicResolver)) {
                throw new BuildException("the type of resolver '" + resolver.getClass().getName()
                        + "' is not supported.");
            }
            it = new ResolverManifestIterable((BasicResolver) resolver);
        } else if (baseDir != null) {
            if (cacheName != null) {
                throw new BuildException("specify only one of 'baseDir' or 'cache'");
            }
            if (!baseDir.isDirectory()) {
                throw new BuildException(baseDir + " is not a directory");
            }
            it = new FSManifestIterable(baseDir);
        } else if (cacheName != null) {
            Ivy ivy = getIvyInstance();
            RepositoryCacheManager cacheManager = ivy.getSettings().getRepositoryCacheManager(
                cacheName);
            if (!(cacheManager instanceof DefaultRepositoryCacheManager)) {
                throw new BuildException("the type of cache '" + cacheManager.getClass().getName()
                        + "' is not supported.");
            }
            File basedir = ((DefaultRepositoryCacheManager) cacheManager).getBasedir();
            it = new FSManifestIterable(basedir);
        } else {
            prepareAndCheck();
            try {
                it = new ArtifactReportManifestIterable(getArtifactReports(), sourceTypes);
            } catch (ParseException e) {
                throw new BuildException("Impossible to parse the artifact reports: "
                        + e.getMessage(), e);
            } catch (IOException e) {
                throw new BuildException("Impossible to read the artifact reports: "
                        + e.getMessage(), e);
            }
        }

        OutputStream out;
        try {
            out = new FileOutputStream(file);
        } catch (FileNotFoundException e) {
            throw new BuildException(file + " was not found", e);
        }

        ContentHandler hd;
        try {
            hd = OBRXMLWriter.newHandler(out, encoding, indent);
        } catch (TransformerConfigurationException e) {
            throw new BuildException("Sax configuration error: " + e.getMessage(), e);
        }

        class AntMessageLogger2 extends AntMessageLogger {
            AntMessageLogger2() {
                super(BuildOBRTask.this);
            }
        }
        IvyContext.getContext().getMessageLogger();
        Message.setDefaultLogger(new AntMessageLogger2());

        try {
            OBRXMLWriter.writeManifests(it, hd, quiet);
        } catch (SAXException e) {
            throw new BuildException("Sax serialisation error: " + e.getMessage(), e);
        }

        try {
            out.flush();
            out.close();
        } catch (IOException e) {
            // don't care
        }

        Message.sumupProblems();
    }

}