/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 * Port to the D Programming language:
 *     Jacob Carlborg <jacob.carlborg@gmail.com>
 *******************************************************************************/
module dwt.internal.Compatibility;

import Math = tango.math.Math;
import Character = tango.text.Unicode;

import dwt.DWT;

import dwt.dwthelper.BufferedInputStream;
import dwt.dwthelper.File;
import dwt.dwthelper.FileInputStream;
import dwt.dwthelper.FileOutputStream;
import dwt.dwthelper.InputStream;
import dwt.dwthelper.OutputStream;
import java.text.MessageFormat;
import dwt.dwthelper.MissingResourceException;
import dwt.dwthelper.ResourceBundle;
import dwt.dwthelper.utils;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;



/**
 * This class is a placeholder for utility methods commonly
 * used on J2SE platforms but not supported on some J2ME
 * profiles.
 * <p>
 * It is part of our effort to provide support for both J2SE
 * and J2ME platforms.
 * </p>
 * <p>
 * IMPORTANT: some of the methods have been modified from their
 * J2SE parents. Refer to the description of each method for 
 * specific changes.
 * </p>
 * <ul>
 * <li>Exceptions thrown may differ since J2ME's set of 
 * exceptions is a subset of J2SE's one.
 * </li>
 * <li>The range of the mathematic functions is subject to
 * change.
 * </li>        
 * </ul>
 */
public final class Compatibility
{

    /**
     * Returns the PI constant as a double.
     */
    public static double PI = Math.PI;

    static double toRadians = PI / 180;

    /**
     * Answers the length of the side adjacent to the given angle
     * of a right triangle. In other words, it returns the integer
     * conversion of length * cos (angle).
     * <p>
     * IMPORTANT: the j2me version has an additional restriction on
     * the argument. length must be between -32767 and 32767 (inclusive).
     * </p>
     * 
     * @param angle the angle in degrees
     * @param length the length of the triangle's hypotenuse
     * @return the integer conversion of length * cos (angle)
     */
    public static int cos (int angle, int length)
    {
        return cast(int) (Math.cos(angle * toRadians) * length);
    }

    /**
     * Answers the length of the side opposite to the given angle
     * of a right triangle. In other words, it returns the integer
     * conversion of length * sin (angle).
     * <p>
     * IMPORTANT: the j2me version has an additional restriction on
     * the argument. length must be between -32767 and 32767 (inclusive).
     * </p>
     * 
     * @param angle the angle in degrees
     * @param length the length of the triangle's hypotenuse
     * @return the integer conversion of length * sin (angle)
     */
    public static int sin (int angle, int length)
    {
        return cast(int) (Math.sin(angle * toRadians) * length);
    }

    /**
     * Answers the most negative (i.e. closest to negative infinity)
     * integer value which is greater than the number obtained by dividing
     * the first argument p by the second argument q.
     * 
     * @param p numerator
     * @param q denominator (must be different from zero)
     * @return the ceiling of the rational number p / q.
     */
    public static int ceil (int p, int q)
    {
        return cast(int) Math.ceil(cast(float) p / q);
    }

    /**
     * Answers whether the indicated file exists or not.
     * 
     * @param parent the file's parent directory
     * @param child the file's name
     * @return true if the file exists
     */
    public static bool fileExists (String parent, String child)
    {
        return (new File(parent, child)).exists();
    }

    /**
     * Answers the most positive (i.e. closest to positive infinity)
     * integer value which is less than the number obtained by dividing
     * the first argument p by the second argument q.
     *
     * @param p numerator
     * @param q denominator (must be different from zero)
     * @return the floor of the rational number p / q.
     */
    public static int floor (int p, int q)
    {
        return cast(int) Math.floor(cast(double) p / q);
    }

    /**
     * Answers the result of rounding to the closest integer the number obtained 
     * by dividing the first argument p by the second argument q.
     * <p>
     * IMPORTANT: the j2me version has an additional restriction on
     * the arguments. p must be within the range 0 - 32767 (inclusive).
     * q must be within the range 1 - 32767 (inclusive).
     * </p>
     * 
     * @param p numerator
     * @param q denominator (must be different from zero)
     * @return the closest integer to the rational number p / q
     */
    public static int round (int p, int q)
    {
        return Math.round(cast(float) p / q);
    }

    /**
     * Returns 2 raised to the power of the argument.
     *
     * @param n an int value between 0 and 30 (inclusive)
     * @return 2 raised to the power of the argument
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_INVALID_RANGE - if the argument is not between 0 and 30 (inclusive)</li>
     * </ul>
     */
    public static int pow2 (int n)
    {
        if (n >= 1 && n <= 30)
            return 2 << (n - 1);
        else if (n !is 0)
        {
            DWT.error(DWT.ERROR_INVALID_RANGE);
        }
        return 1;
    }

    /**
     * Create an DeflaterOutputStream if such things are supported.
     * 
     * @param stream the output stream
     * @return a deflater stream or <code>null</code>
     * @exception IOException
     * 
     * @since 3.4
     */
    public static OutputStream newDeflaterOutputStream (OutputStream stream)
    {
        return new DeflaterOutputStream(stream);
    }

    /**
     * Open a file if such things are supported.
     * 
     * @param filename the name of the file to open
     * @return a stream on the file if it could be opened.
     * @exception IOException
     */
    public static InputStream newFileInputStream (String filename)
    {
        return new FileInputStream(filename);
    }

    /**
     * Open a file if such things are supported.
     * 
     * @param filename the name of the file to open
     * @return a stream on the file if it could be opened.
     * @exception IOException
     */
    public static OutputStream newFileOutputStream (String filename)
    {
        return new FileOutputStream(filename);
    }

    /**
     * Create an InflaterInputStream if such things are supported.
     * 
     * @param stream the input stream
     * @return a inflater stream or <code>null</code>
     * @exception IOException
     * 
     * @since 3.3
     */
    public static InputStream newInflaterInputStream (InputStream stream)
    {
        return new BufferedInputStream(new InflaterInputStream(stream));
    }

    /**
     * Answers whether the character is a letter.
     *
     * @param c the character
     * @return true when the character is a letter
     */
    public static bool isLetter (char c)
    {
        return Character.isLetter(c);
    }

    /**
     * Answers whether the character is a letter or a digit.
     *
     * @param c the character
     * @return true when the character is a letter or a digit
     */
    public static bool isLetterOrDigit (char c)
    {
        return Character.isLetterOrDigit(c);
    }

    /**
     * Answers whether the character is a Unicode space character.
     *
     * @param c  the character
     * @return true when the character is a Unicode space character
     */
    public static bool isSpaceChar (char c)
    {
        return Character.isSpace(c);
    }

    /**
     * Answers whether the character is a whitespace character.
     *
     * @param c the character to test
     * @return true if the character is whitespace
     */
    public static bool isWhitespace (char c)
    {
        return Character.isWhitespace(c);
    }

    /**
     * Execute a program in a separate platform process if the
     * underlying platform support this.
     * <p>
     * The new process inherits the environment of the caller.
     * </p>
     *
     * @param prog the name of the program to execute
     *
     * @exception IOException
     *  if the program cannot be executed
     * @exception SecurityException
     *  if the current SecurityManager disallows program execution
     */
    public static void exec (String prog)
    {
        //Runtime.getRuntime().exec(prog);
    }

    /**
     * Execute progArray[0] in a separate platform process if the
     * underlying platform support this.
     * <p>
     * The new process inherits the environment of the caller.
     * <p>
     *
     * @param progArray array containing the program to execute and its arguments
     *
     * @exception IOException
     *  if the program cannot be executed
     * @exception   SecurityException
     *  if the current SecurityManager disallows program execution
     */
    public static void exec (String[] progArray)
    {
        Runtime.getRuntime().exec(progArray);
    }

    private static ResourceBundle msgs = null;

    /**
     * Returns the NLS'ed message for the given argument. This is only being
     * called from DWT.
     * 
     * @param key the key to look up
     * @return the message for the given key
     * 
     * @see DWT#getMessage(String)
     */
    public static String getMessage (String key)
    {
        String answer = key;

        if (key is null)
        {
            DWT.error(DWT.ERROR_NULL_ARGUMENT);
        }
        if (msgs is null)
        {
            try
            {
                msgs = ResourceBundle.getBundle("dwt.internal.SWTMessages"); //$NON-NLS-1$
            }
            catch (MissingResourceException ex)
            {
                answer = key + " (no resource bundle)"; //$NON-NLS-1$
            }
        }
        if (msgs !is null)
        {
            try
            {
                answer = msgs.getString(key);
            }
            catch (MissingResourceException ex2)
            {
            }
        }
        return answer;
    }

    public static String getMessage (String key, Object[] args)
    {
        String answer = key;

        if (key is null || args is null)
        {
            DWT.error(DWT.ERROR_NULL_ARGUMENT);
        }
        if (msgs is null)
        {
            try
            {
                msgs = ResourceBundle.getBundle("dwt.internal.SWTMessages"); //$NON-NLS-1$
            }
            catch (MissingResourceException ex)
            {
                answer = key + " (no resource bundle)"; //$NON-NLS-1$
            }
        }
        if (msgs !is null)
        {
            try
            {
                MessageFormat formatter = new MessageFormat("");
                formatter.applyPattern(msgs.getString(key));
                answer = formatter.format(args);
            }
            catch (MissingResourceException ex2)
            {
            }
        }
        return answer;
    }

    /**
     * Interrupt the current thread. 
     * <p>
     * Note that this is not available on CLDC.
     * </p>
     */
    public static void interrupt ()
    {
        Thread.currentThread().interrupt();
    }

    /**
     * Compares two instances of class String ignoring the case of the
     * characters and answers if they are equal.
     *
     * @param s1 string
     * @param s2 string
     * @return true if the two instances of class String are equal
     */
    public static bool equalsIgnoreCase (String s1, String s2)
    {
        return s1.equalsIgnoreCase(s2);
    }

}