package com.atlassian.plugin.url;

import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarInputStream;

/**
 */
class InnerJarURLConnection extends JarURLConnection {
    private URL baseResource;
    private String[] segments;
    private InputStream in;

    public InnerJarURLConnection(URL url) throws IOException {
        super(url = normaliseURL(url));

        String baseText = url.getPath();

        int bangLoc = baseText.indexOf("!");

        String baseResourceText = baseText.substring(0, bangLoc);

        String extraText = "";

        if (bangLoc <= (baseText.length() - 2)
                &&
                baseText.charAt(bangLoc + 1) == '/') {
            if (bangLoc + 2 == baseText.length()) {
                extraText = "";
            } else {
                extraText = baseText.substring(bangLoc + 1);
            }
        } else {
            throw new MalformedURLException("No !/ in url: " + url.toExternalForm());
        }


        List<String> segments = new ArrayList<String>();

        StringTokenizer tokens = new StringTokenizer(extraText, "!");

        while (tokens.hasMoreTokens()) {
            segments.add(tokens.nextToken());
        }

        this.segments = segments.toArray(new String[segments.size()]);
        this.baseResource = new URL(baseResourceText);
    }

    protected static URL normaliseURL(URL url) throws MalformedURLException {
        String text = normalizeUrlPath(url.toString());

        if (!text.startsWith("jar:")) {
            text = "jar:" + text;
        }

        if (text.indexOf('!') < 0) {
            text = text + "!/";
        }

        return new URL(text);
    }

    /**
     * Retrieve the nesting path segments.
     *
     * @return The segments.
     */
    protected String[] getSegments() {
        return this.segments;
    }

    /**
     * Retrieve the base resource <code>URL</code>.
     *
     * @return The base resource url.
     */
    protected URL getBaseResource() {
        return this.baseResource;
    }

    /**
     * @see java.net.URLConnection
     */
    public void connect() throws IOException {
        if (this.segments.length == 0) {
            setupBaseResourceInputStream();
        } else {
            setupPathedInputStream();
        }
    }

    /**
     * Setup the <code>InputStream</code> purely from the base resource.
     *
     * @throws java.io.IOException If an I/O error occurs.
     */
    protected void setupBaseResourceInputStream() throws IOException {
        this.in = getBaseResource().openStream();
    }

    /**
     * Setup the <code>InputStream</code> for URL with nested segments.
     *
     * @throws java.io.IOException If an I/O error occurs.
     */
    protected void setupPathedInputStream() throws IOException {
        InputStream curIn = getBaseResource().openStream();

        for (int i = 0; i < this.segments.length; ++i) {
            curIn = getSegmentInputStream(curIn, segments[i]);
        }

        this.in = curIn;
    }

    /**
     * Retrieve the <code>InputStream</code> for the nesting
     * segment relative to a base <code>InputStream</code>.
     *
     * @param baseIn  The base input-stream.
     * @param segment The nesting segment path.
     * @return The input-stream to the segment.
     * @throws java.io.IOException If an I/O error occurs.
     */
    protected InputStream getSegmentInputStream(InputStream baseIn, String segment) throws IOException {
        JarInputStream jarIn = new JarInputStream(baseIn);
        JarEntry entry = null;

        while (jarIn.available() != 0) {
            entry = jarIn.getNextJarEntry();

            if (entry == null) {
                break;
            }

            if (("/" + entry.getName()).equals(segment)) {
                return jarIn;
            }
        }

        throw new IOException("unable to locate segment: " + segment);
    }

    /**
     * @see java.net.URLConnection
     */
    public InputStream getInputStream() throws IOException {
        if (this.in == null) {
            connect();
        }
        return this.in;
    }

    /**
     * @return JarFile
     * @throws java.io.IOException
     * @see java.net.JarURLConnection#getJarFile()
     */
    public JarFile getJarFile() throws IOException {
        String url = baseResource.toExternalForm();

        if (url.startsWith("file:/")) {
            url = url.substring(6);
        }

        return new JarFile(URLDecoder.decode(url, "UTF-8"));
    }

    private static String normalizeUrlPath(String name) {
        if (name.startsWith("/")) {
            name = name.substring(1);
        }

        // Looking for org/codehaus/werkflow/personality/basic/../common/core-idioms.xml
        //                                               |    i  |
        //                                               +-------+ remove
        //
        int i = name.indexOf("/..");

        // Can't be at the beginning because we have no root to refer to so
        // we start at 1.
        if (i > 0) {
            int j = name.lastIndexOf("/", i - 1);

            name = name.substring(0, j) + name.substring(i + 3);
        }

        return name;
    }

}