/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.impl.fileutils;

/**

 * FileURL manages URL/Path handling. It is responsible to manage paths which

 * have path separators specific to the platform. It will also manage

 * differences between URL and Absolute path and make it transparent to use

 * from.

 */

{

    private static String FILE_PREFIX = "file://";

    private static String FILE_VALID_START_1 = "file:///";

    private static String FILE_VALID_START_2 = "file://localhost/";

    public static final String S60_FILE_SEPARATOR = "\\";

    public static final String LINUX_FILE_SEPARATOR = "/";

    private boolean iIsS60Path;

    // Contains the unescaped path.

    private String iUnescapedPath;

    // Contains the absolute path to the current target.

    private String iTargetPath;

    // Contains the name of the target.

    private String iTargetName;

    private String iSeparatorUsed;

    /**

     * Constructor for FileURL.

     *

     * @param aName

     *            Can contain either an Absolute path name or a File URL.

     *            <p>

     *            Path separator in Absolute path can be either "/" or platform

     *            specific path separator. This is specified in file.separator

     *            system property.

     *            <p>

     *            In case of file URL being passed as parameter, it must follow

     *            the format of a fully-qualified, absolute path file name as

     *            described by the file URL format in IETF RFCs 1738 & 2396.

     */

    public FileURL(String aName)

    {

        iIsS60Path = false;

        String initialPath  = aName;

        String path = "";

        if (aName.trim().length() <= 0)

        {

            throw new IllegalArgumentException();

        }

        if (aName.startsWith(FILE_PREFIX))

        {

            validateUrlStart(aName);

            // aName is a url of the form file://<host>/<path>

            // We need just the absolute path. So we extract it.

            path = initialPath.substring(initialPath.indexOf('/', FILE_PREFIX

                                         .length()) + 1);

            // A file URL should have only "/" as file separator.

            if (initialPath.indexOf(S60_FILE_SEPARATOR) != -1)

            {

                throw new IllegalArgumentException();

            }

        }

        else

        {

            path = aName;

        }

        int endIndex = 0;

        String tempName = path;

        while (tempName.indexOf("//")!=-1)

        {

            endIndex = path.indexOf("//");

            tempName = path.substring(0, endIndex);

            if (endIndex < path.length())

            {

                tempName += path.substring(endIndex+1);

            }

        };

        path = tempName;

        // Check the sanity of path specified

        checkPathValidity(path);

        iUnescapedPath = path;

        iIsS60Path = (iUnescapedPath.indexOf("\\") != -1);

        int index = 0;

        if (iIsS60Path)

        {

            iSeparatorUsed = "\\";

            index = iUnescapedPath.lastIndexOf('\\',

                                               iUnescapedPath.length() - 2);

        }

        else

        {

            iSeparatorUsed = "/";

            index = iUnescapedPath

                    .lastIndexOf('/', iUnescapedPath.length() - 2);

        }

        iTargetName = iUnescapedPath.substring(index + 1);

        iTargetPath = iUnescapedPath.substring(0, index + 1);

    }

    /**

     * checks to see if URL begins with valid urls starts.<br/> It can either

     * be file:/// or file://localhost/.

     *

     * @param url

     *            contains url passed to the constructor

     */

    private void validateUrlStart(String url)

    {

        if (url.startsWith(FILE_VALID_START_1)

                || url.startsWith(FILE_VALID_START_2))

        {

            return;

        }

        throw new IllegalArgumentException();

    }

    /**

     * Getter method to retrieve path to the parent directory of the current

     * target.

     *

     * @return string containing absloute path to the target's parent.

     */

    public String getPath()

    {

        return iTargetPath;

    }

    /**

     * Getter method to retrieve name of the target.

     *

     * @return string containing the name of the target currently pointed to.

     *         This is derived from the url.

     */

    public String getName()

    {

        return iTargetName;

    }

    /**

     * Getter method to retrieve the full path of the target. It will contain

     * path to the target and the target too as a complete url.

     *

     * @return the full path of the target

     */

    public String getFullPath()

    {

        return iTargetPath + iTargetName;

    }

    protected String getSeparatorUsed()

    {

        return iSeparatorUsed;

    }

    /**

     * Getter method to retrieve the file URL that can be passed as a parameter

     * to FileConnection url. It will conform to File URL format in IETF RFCs

     * 1738 & 2396.

     *

     * @return fully qualified File URL

     */

    public String getUrl()

    {

        // Get URL must return escaped url.

        String aUrl = FILE_VALID_START_1 + iTargetPath + iTargetName;

        String value = "";

        for (int i = 0; i < aUrl.length(); i++)

        {

            char ch = aUrl.charAt(i);

            // Also replace "\\" with "/"

            if (ch == '\\')

            {

                value += "/";

                continue;

            }

            boolean isLetter = (ch >= 'a' && ch <= 'z')

                               || (ch >= 'A' && ch <= 'Z');

            boolean isDigit = (ch >= '0' && ch <= '9');

            if (isLetter || isDigit)

            {

                value += ch;

            }

            else

            {

                value += stringToHex("" + ch);

            }

        }

        return value;

    }

    /**

     * Checks to see if the path passed is valid. Simple sanity checks for the

     * path to point to a valid target.

     *

     * @param name

     *            contains an absolute path to a target.

     */

    private static final void checkPathValidity(String name)

    {

        // Only in S60 file system, we have the concept of drives.

        // So, ":" should only appear in File systems that have

        // file.separator as '\\'

        String separator = System.getProperty("file.separator");

        // If platform is S60 like.

        if (separator.equals(S60_FILE_SEPARATOR))

        {

            makeS60SpecificChecks(name);

        }

        else

        {

            makeLinuxSpecificChecks(name);

        }

        if ((name.indexOf('*') != -1) || (name.indexOf('?') != -1)

                || (name.indexOf('<') != -1) || (name.indexOf('>') != -1)

                || (name.indexOf("//") != -1) || name.endsWith("/."))

        {

            throw new IllegalArgumentException(name);

        }

    }

    /**

     * Makes checks that are specific to S60 like File System. This should be

     * called only in case file.separator is "\\"

     *

     * @param name

     *            contians the path that needs to be checked for sanity.

     */

    private static final void makeS60SpecificChecks(String name)

    {

        // First index of colon

        int firstIndexOfColon = name.indexOf(':');

        int indexOfColon = name.indexOf(':', firstIndexOfColon + 1);

        if (indexOfColon != -1)

        {

            throw new IllegalArgumentException(name);

        }

        // In S60 like file system, it is possible to have "/" as the file

        // separator as file url accepts it. But then, once there is "\\" as

        // file separator, the entire url should follow the same convention.

        if (name.indexOf(S60_FILE_SEPARATOR) != -1)

        {

            if (name.indexOf(LINUX_FILE_SEPARATOR) != -1)

            {

                // We must be having only one kind of separator

                throw new IllegalArgumentException(name);

            }

            if (firstIndexOfColon > name.indexOf(S60_FILE_SEPARATOR))

            {

                throw new IllegalArgumentException(name);

            }

        }

        else

        {

            if ((firstIndexOfColon > name.indexOf(LINUX_FILE_SEPARATOR)))

            {

                throw new IllegalArgumentException(name);

            }

        }

    }

    /**

     * Makes checks that are specific to Linux like File System. This should be

     * called only in case file.separator is "/"

     *

     * @param name

     *            contians the path that needs to be checked for sanity.

     */

    private static final void makeLinuxSpecificChecks(String name)

    {

        if (name.indexOf(':') != -1)

        {

            throw new IllegalArgumentException(name);

        }

        if (name.indexOf(S60_FILE_SEPARATOR) != -1)

        {

            throw new IllegalArgumentException(name);

        }

    }

    /**

     * encodes a unicode string to a string of 4-digit hex numbers <br />

     * Note: this method is slower than stringToHex(String,StringBuffer)

     *

     * @param java

     *            normal java string

     * @return string of 4-digit hex numbers

     */

    public static final String stringToHex(String str)

    {

        if (str == null)

            return "";

        int length = str.length();

        StringBuffer result = new StringBuffer(length * 4);

        stringToHex(str, result);

        return result.toString();

    }

    /**

     * encodes a unicode string to a string of 4-digit hex numbers.

     *

     * @param str

     *            normal java string

     * @param out

     *            string of 4-digit hex numbers

     */

    public static final void stringToHex(String str, StringBuffer out)

    {

        // To improve performance, implement a table-lookup instead of if/then cases.

        if (str == null)

            return;

        int length = str.length();

        for (int pos = 0; pos < length; pos++)

        {

            char cur_char = str.charAt(pos);

            int this_char = (int) cur_char;

            if (this_char < 127 && cur_char != ' ')

            {

                out.append((char) this_char);

                continue;

            }

            for (int digit = 0; digit < 4; digit++)

            {

                int this_digit = this_char & 0xf000;

                this_char = this_char << 4;

                this_digit = (this_digit >> 12);

                // We get 4 digits, so on 2nd we insert a % sign and then value

                if (digit == 2)

                    out.append('%');

                if (digit < 2)

                    continue;

                if (this_digit >= 10)

                    out.append((char)(this_digit + 87));

                else

                    out.append((char)(this_digit + 48));

            }

        }

    }

}