/*

* 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.util.Date;

/**

 * Utility for formatting text strings from a pattern with positional

 * parameters.

 * <br>

 * Supported parameters are:

 * <UL>

 * <LI>%nU - String in position n

 * <LI>%U - Next string

 * <LI>%Ln - Integer in position n

 * <LI>%nN - Integer in position n

 * <LI>%N - Next integer

 * <LI>%nC - Character in position n

 * <LI>%C - Next character

 * <LI>%n - Parameter in position n

 * </UL>

 * <br>

 * Example of usage:

 * <pre>

 *   Formatter formatter = new Formatter("You have %N email(s) left");

 *   String message = formatter.arg(5).toString();

 *   // Becomes :You have 5 email(s) left

 *

 *   Formatter formatter = new Formatter("There are %N0 files in folder \"%U1\"");

 *   String message = formatter.arg(5).arg("photos").toString();

 *   // Becomes :There are 5 files in folder "photos"

 * </pre>

 * <br>

 * Limitation: more than 10 positional arguments are not supported (only 0...9)

 * <br>

 * Note that Formatter supports Avkon and Qt based localisation.

 * Text parameter indices start from 0 when Avkon is used and from 1

 * when Qt is used.

 */

public class Formatter

{

    /** Original pattern string */

    private String pattern;

    /** String with latest replacements */

    private String replaced;

    /**

     * Platform localisation type.

     * Either ResourceLoader.AVKON or ResourceLoader.QT. */

    private final int locType;

    /**

     * The first text parameter replacement index. For Avkon based

     * localisation this is 0, for Qt based localisation this is 1.

     */

    private final int startIndex;

    /** Next replacement index */

    private int nextIndex;

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

    /**

     * Create a new formatter

     *

     * @param pattern formatter pattern

     */

    Formatter(String aPattern)

    {

        this(aPattern, ResourceLoader.AVKON);

    }

    /**

     * Create a new formatter

     *

     * @param pattern formatter pattern

     * @param aLocType platform localisation type

     */

    Formatter(String aPattern, int aLocType)

    {

        pattern = aPattern;

        replaced = aPattern;

        locType = aLocType;

        startIndex = (locType == ResourceLoader.QT? 1: 0);

        nextIndex = startIndex;

    }

    /**

     * Replace the lowest numbered parameter in the string, which is not yet

     * replaced.

     *

     * @param string string to replace at the argument

     * @return same formatter

     */

    public Formatter arg(String string)

    {

                replace("%" + nextIndex, string) ||

                replace("%U", string))

        {

            nextIndex++;

        }

        else

        {

            Logger.WLOG(Logger.EUtils,

                        "String replacement failed on parameter " +

                        nextIndex + ": " + pattern);

        }

        return this;

    }

    /**

     * Replace the least numbered parameter in the string, which is not yet

     * replaced.

     *

     * @param number number to replace at the argument

     * @return same formatter

     */

    public Formatter arg(int number)

    {

        String localisedNumber = _formatInteger(number);

                replace("%" + nextIndex + "N", localisedNumber) ||

                replace("%" + nextIndex, localisedNumber) ||

                replace("%N", localisedNumber))

        {

            nextIndex++;

        }

        else

        {

            Logger.WLOG(Logger.EUtils,

                        "Integer replacement failed on parameter " +

                        nextIndex + ": " + pattern);

        }

        return this;

    }

    /**

     * Replace the least numbered parameter in the string, which is not yet

     * replaced.

     *

     * @param ch character to replace at the argument

     * @return same formatter

     */

    public Formatter arg(char ch)

    {

        String chString = new String(new char[] { ch });

        if (replace("%" + nextIndex + "C", chString) ||

                replace("%" + nextIndex, chString) ||

                replace("%C", chString))

        {

            nextIndex++;

        }

        else

        {

            Logger.WLOG(Logger.EUtils,

                        "Character replacement failed on parameter " +

                        nextIndex + ": " + pattern);

        }

        return this;

    }

    /**

     * Replace the least numbered parameter in the string, which is not yet

     * replaced. Date is formatted according to current device date format.

     *

     * @param date date to replace at the argument

     * @return same formatter

     */

    public Formatter arg(Date date)

    {

        String dateString = _formatDate(date.getTime());

        return arg(dateString);

    }

    /**

     * Replace the least numbered parameter in the string, which is not yet

     * replaced.

     *

     * @param o object whose toString() will be used for argument position

     * @return same formatter

     */

    public Formatter arg(Object o)

    {

        if (o != null)

        {

            if (o instanceof String)

            {

                return arg((String) o);

            }

            else if (o instanceof Integer)

            {

                return arg(((Integer) o).intValue());

            }

            else if (o instanceof Character)

            {

                return arg(((Character) o).charValue());

            }

            else if (o instanceof Date)

            {

                return arg((Date) o);

            }

            // Skip not supported types.

        }

        return this;

    }

    /**

     * Convert the current pattern to string, along with parameter

     * replacements.

     *

     * @return string where parameters are replaced

     */

    public String toString()

    {

        String result = replaced;

        // Reset for next usage

        replaced = pattern;

        nextIndex = startIndex;

        return result;

    }

    /**

     * Formats localised text with specified parameters from an array.

     *

     * Note that the arg().arg().toString() is preferred method of

     * usage. E.g. Date format type can not be defined with this method.

     *

     * @param textParameters parameters to be filled into the text

     * @return localised text formatted with the provided parameters

     */

    public String format(Object[] textParameters)

    {

        if (textParameters != null)

        {

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

            {

                if (textParameters[i] instanceof String)

                {

                    arg((String)textParameters[i]);

                }

                else if (textParameters[i] instanceof Integer)

                {

                    arg(((Integer)textParameters[i]).intValue());

                }

                else if (textParameters[i] instanceof Date)

                {

                    arg((Date)textParameters[i]);

                }

                else

                {

                    arg(textParameters[i]);

                }

            }

        }

        return toString();

    }

    /**

     * Applies convertion from european digits into arabic-indic digits

     * based on existing language settings

     *

     * @param str String which might contain european digits

     * @return A string identical with the provided string but with the

     *         european digits (if any) converted to arabic-indic digits

     */

    public static String formatDigits(String str)

    {

        return _formatDigits(str);

    }

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

    /**

     * Replace first occurrence of the string pattern in the replaced field.

     *

     * @param pattern string to search for

     * @param replacement string to replace patterns

     * @return true if pattern was found and replaced, false if pattern was

     *         not found

     */

    private boolean replace(String pattern, String replacement)

    {

        int index = replaced.indexOf(pattern);

        if (index != -1)

        {

            if (replaced.indexOf(pattern + "[]") != -1)

            {

                replaced =

                    replaced.substring(0, index) + replacement +

                    replaced.substring(index + pattern.length() + 2);

            }

            else if (replaced.indexOf(pattern + "[") != -1)

            {

                return replaceWithMax(pattern, replacement, index);

            }

            else

            {

                replaced =

                    replaced.substring(0, index) + replacement +

                    replaced.substring(index + pattern.length());

            }

            return true;

        }

        return false;

    }

    /**

     * Replace first occurrence of the string pattern in the replaced field.

     * Replace [N...N] defined amount of characters.

     *

     * @param pattern string to search for

     * @param replacement string to replace patterns

     * @param index of replacement tag.

     * @return true if pattern was found and replaced, false if pattern was

     *         not found

     */

    private boolean replaceWithMax(String pattern, String replacement, int maxIndex)

    {

        boolean result = false;

        int closingIndex = replaced.indexOf("]", maxIndex + pattern.length());

        // Check format [N...N] comply. If not skip.

        if (closingIndex > 0)

        {

            try

            {

                int maxLen = Integer.parseInt(replaced.substring(

                                                  maxIndex + pattern.length() + 1, closingIndex));

                if (maxLen > replacement.length())

                {

                    maxLen = replacement.length();

                }

                replaced = replaced.substring(0, maxIndex) +

                           replacement.substring(0, maxLen) +

                           replaced.substring(closingIndex + 1);

                result = true;

            }

            catch (NumberFormatException nfe)

            {

                Logger.WLOG(Logger.EUtils, "Replace with max failed to invalid"

                            + " replacement amount");

            }

        }

        return result;

    }

    /*** ----------------------------- NATIVE ----------------------------- */

    /**

     * Format integer to current locale.

     *

     * @param number to be formatted.

     * @return number formatted as current locale String.

     */

    private native String _formatInteger(int number);

    /**

     * Format date to current locale.

     *

     * @param timeInMilliSecs to be formatted.

     * @param format Date format.

     * @return date formatted as current locale String.

     *

     */

    private native String _formatDate(long timeInMilliSecs);

    /**

     * Applies convertion from european digits into arabic-indic digits

     * based on existing language settings

     *

     * @param str String which might contain european digits

     * @return A string identical with the provided string but with the

     *         european digits (if any) converted to arabic-indic digits

     */

    private static native String _formatDigits(String str);

}