/*

* Copyright (c) 2008-2010 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.utils;

import java.io.*;

import java.util.*;

/**

 * Resource loader to get localised strings and Formatter patterns.

 * <br>

 * Usage:

 * <pre>

 *   ResourceLoader res = new ResourceLoader("javainstaller", "qtn_java_installer_");

 *   Label subjectLabel = createLabel(

 *       res.format("subject").arg(certificate.getSubject()).toString(),

 *       horizontalSpan, labelStyle);

 *

 *   Label noteLabel = createLabel(

 *       res.string("note"), horizontalSpan, labelStyle);

 * </pre>

 *

 * @author Nokia Corporation

 * @version 1.0

 */

public class ResourceLoader

{

    /** Localisation resource basepath */

    private static final String LOC_RESOURCE_BASE = "/resources/com/nokia/mj/impl/";

    /** Map for ResourceLoader instances. */

    private static Hashtable resourceLoaders = new Hashtable();

    /** Resource string map. Null if resource could not be loaded. */

    private Hashtable resourceMap = new Hashtable();

    /** Resource name prefix */

    /*** ----------------------------- PUBLIC ------------------------------ */

    /**

     * Returns a resource loader instance.

     *

     * @param resourceName name of the resource

     * @param prefix prefix added before each id when retrieving

     * @return resource loader instance

     */

    public static ResourceLoader getInstance(String resourceName, String prefix)

    {

        String key = resourceName + ":" + prefix;

        ResourceLoader result = (ResourceLoader)resourceLoaders.get(key);

        if (result == null)

        {

            result = new ResourceLoader(resourceName, prefix);

            resourceLoaders.put(key, result);

        }

        return result;

    }

    /**

     * Creates resource loader, using the current locale of the environment.

     *

     * @param resourceName name of the resource

     * @param aPrefix prefix added before each id when retrieving

     */

    public ResourceLoader(String resourceName, String aPrefix)

    {

        prefix = aPrefix;

    }

    /**

     * Get a string formatter of a given resource id.

     *

     * @param id resource id

     * @return formatter instance

     * @see Formatter

     */

    public Formatter format(String id)

    {

        return new Formatter(string(id));

    }

    /**

     * Formats localised text with specified parameters from an array.

     *

     * @param id resource id

     * @param textParameters parameters to be filled into the text

     * @return localised text formatted with the provided parameters

     * @see Formatter

     */

    public String format(String id, Object[] textParameters)

    {

        return new Formatter(string(id)).format(textParameters);

    }

    /**

     * Get a plain string resource with a given resource id.

     *

     * @param id resource id, either with prefix or without

     * @return resource string, or the id if does not exist

     */

    public String string(String id)

    {

        String str = (String)resourceMap.get(id);

        if (str == null)

        {

            // Try with prefix

            str = (String)resourceMap.get(prefix + id);

            if (str == null)

            {

                // Not found even with prefix. Use the id itself

                if (!id.startsWith(prefix))

                {

                    str = prefix + id;

                }

                else

                {

                    str = id;

                }

                Logger.WLOG(Logger.EUtils, "Cannot find resource: " + id);

            }

            // Put back to hash with original key for quick retrieval

            resourceMap.put(id, str);

        }

        str = decode(str);

        str = replaceCharacterCodes(str);

        return str;

    }

    /**

     * Gets the locale ID currently being used on the phone. This can be used

     * e.g. to load a localized icon file, by adding the locale id as suffix.

     *

     * @return Locale ID as provided by the platform

     */

    public String getLocaleId()

    {

        int localeId = _getLocaleId();

        if (localeId > 0)

        {

            if (localeId < 10)

            {

                // Ensure that the returned locale ID has at least two digits.

                return "0" + Integer.toString(localeId);

            }

            else

            {

                return Integer.toString(localeId);

            }

        }

        return "sc";

    }

    /*** ----------------------------- PRIVATE ---------------------------- */

    /**

     */

    {

        InputStream is = null;

        {

            is = this.getClass().getResourceAsStream(

        }

        {

            is = this.getClass().getResourceAsStream(

        }

        try

        {

            // Loc-files area always on UTF8 format

            LineReader lr = new LineReader(

                new BufferedReader(new InputStreamReader(is, "UTF-8")));

            String line;

            while ((line = lr.readLine()) != null)

            {

                // Ignore lines which are not #define's

                if (!line.startsWith("#define "))

                {

                    continue;

                }

                try

                {

                    // Skip "#define" + any whitespace

                    line = line.substring(line.indexOf(' ')).trim();

                    int idEnd = line.indexOf(' ');

                    String id = line.substring(0, idEnd);

                    int strStart = line.indexOf('"', idEnd);

                    int strEnd = line.lastIndexOf('"');

                    String str = line.substring(strStart + 1, strEnd);

                    resourceMap.put(id, str);

                }

                catch (IndexOutOfBoundsException ex)

                {

                    String error = "Incorrect line " + lr.getLineNumber() + "\"" +

                                   line + "\"";

                    Logger.WLOG(Logger.EUtils, error);

                }

            }

            is.close();

        }

        catch (IOException ex)

        {

            Logger.WLOG(Logger.EUtils,

                        "Resource file " + resourceName + " handling failed: "

                        + ex.getMessage());

        }

    }

    /**

     * Decode given string. Decoding means unescaping escaped characters.

     * Currently \n, \t, \', \\ and \" patterns are decoded to respective

     * characters.

     *

     * @param str to be decoded.

     * @return decoded String.

     */

    private String decode(String str)

    {

        str = replacePattern(str, "\\n", '\n');

        str = replacePattern(str, "\\\\", '\\');

        str = replacePattern(str, "\\\"", '\"');

        str = replacePattern(str, "\\t", '\t');

        str = replacePattern(str, "\\'", '\'');

        return str;

    }

    /**

     * Replace all occurrences of the pattern in the given String.

     *

     * @param resource string to be replaced.

     * @param pattern to replace.

     * @param replacement replacement character.

     * @return String where all occurrences of the pattern are replaced.

     */

    private String replacePattern(

        String resource, String pattern, char replacement)

    {

        StringBuffer sb = new StringBuffer();

        int startIndex = resource.indexOf(pattern);

        if (startIndex != -1)

        {

            sb.append(resource.substring(0, startIndex)).append(replacement);

            startIndex = startIndex + pattern.length();

            int endIndex = 0;

            while ((endIndex = resource.indexOf(pattern, startIndex)) != -1)

            {

                sb.append(resource.substring(startIndex, endIndex))

                .append(replacement);

                startIndex = endIndex + pattern.length();

            }

            if (startIndex < resource.length())

            {

                sb.append(resource.substring(startIndex, resource.length()));

            }

            return sb.toString();

        }

        return resource;

    }

    /**

     * Replace character codes. They are given as <0x0000> format. Where 0x0000

     * contains character unicode as hex representation.

     *

     * @param str to replace characters.

     * @return String where characters are replaced.

     */

    private String replaceCharacterCodes(String str)

    {

        StringBuffer sb = new StringBuffer();

        int startIndex = str.indexOf("<0x");

        if (startIndex != -1 && str.charAt(startIndex + 7) == '>')

        {

            sb.append(str.substring(0, startIndex));

            try

            {

                int charint = Integer.parseInt(

                                  str.substring(startIndex + 3, startIndex + 7), 16);

                sb.append((char) charint);

                int endIndex = 0;

                startIndex+= 7;

                while ((endIndex = str.indexOf("<0x", startIndex)) != -1

                        && str.charAt(endIndex + 7) == '>')

                {

                    sb.append(str.substring(startIndex + 1, endIndex));

                    charint = Integer.parseInt(