package com.digi.config.util;

import com.digi.config.exception.LocalizationException;
import java.io.*;
import java.rmi.MarshalledObject;
import java.text.FieldPosition;
import java.text.MessageFormat;
import java.util.*;


/**
 * Helper class to encapsulate the retrieval and formatting of localizable messages.
 * Instances of this class should be considered immutable.  In support of this, copies
 * are made of the substitution objects provided on the construction of instances of this
 * class.
 */
public final class LocalizableMessage implements Serializable, Cloneable {

    //==============================================================================
    //=                  Object attributes
    //==============================================================================
    //the key into the resource bundle for the desired base message text
    private String resourceKey;

    //the set of replacement text to be inserted into the base message text
    private MarshalledObject[] replacementText;

    //the name of the resource bundle containing the translatable message text.  This
    //must be a fully qualified name (e.g.
    // com.<company>.<project>.<package>.xxxResourceBundle).
    private String rsrcBundleName;

    //the Locale to be considered the original Local of the message.  This is usually
    //the Locale of the JVM that originated the message but is not required to be so.
    private Locale originalLocale;

    //a basic fallback msg that will be used when the local JVM does not have the
    //necessary resource bundle needed to resolve build the localized message text.
    //We make it transient to ensure it can be serialized across the wire.  That is,
    //readObject/writeObject explicitely handle this field.  If there is a problem with
    //re-hydrating one of the replacement text objects, we can ignore the error and at
    //least have this fallback text to display.
    transient private String fallbackMessage;

    //==============================================================================
    //=                  Constructors
    //==============================================================================

  /**
   * Create a localizable message object.
   * @param rsrcBundleName is the name of the resource bundle containing the translatable
   *            message text.  This must be a fully qualified name
   *            (e.g. com.<company>.<project>.<package>.xxxResourceBundle). It is a
   *            Mandatory parameter and may not be an empty String.
   * @param key is the key into the resourceBundle of the message text to use
   *            for this localizable message. The resource associated with this key must either
   *            be a String or a MessageFormat.  It is a
   *            Mandatory parameter and may not be an empty String.
   * @param rplcTxt is the array of objects to be used as replacement
   *            text in the text retrieved from the resourceBundle.  An array element may not
   *            be <code>null</code>
   * @param originalLocale is the Locale to be considered as the Locale of the message origin.
   *         It is primarily used for creating the fallbackMsg.  If left null, the default
   *         Locale of the system will be used.
   * @throws IllegalArgumentException if rsrcBundleName or key is empty string.  It may also be thrown
   *         if an unexpected error is detected while processing the replacement text.
   * @throws NullPointerException if rsrcrBundleName or key is null or replacementText array contains a
   *         null.
   */
    public LocalizableMessage(String rsrcBundleName, String key,
        Serializable[] rplcTxt, Locale originalLocale) {
            // validate parameters
            if ((key==null)||(rsrcBundleName==null)) {
                throw new NullPointerException("Message key or rsrcrBundleName is null");
            }
            if ((key.length()==0)||(rsrcBundleName.length()==0)) {
                throw new IllegalArgumentException("Message key and rsrcBundleName must be provided");
            }
            if (rplcTxt!=null) {
                for (int i=0; i<rplcTxt.length; i++) {
                    if (rplcTxt[i]==null) {
                        throw new NullPointerException("ReplacementText[" +i+ "] == null");
                    }
                }
            } //end for

            // Make copies of the replacementText to make them immutable (from the outside
            // perspective).  One way of doing this is to make them MarshalledObjects.
            int j=0;

            try {
                replacementText=new MarshalledObject[rplcTxt!=null?rplcTxt.length:0];

                for ( ; j<replacementText.length; j++) {
                    replacementText[j]=new MarshalledObject(rplcTxt[j]);
                } //end for
            }
            catch (IOException io) {
                throw new IllegalArgumentException("Marshalling ReplacementText failed. index: " +j+
                    " Exception: " +io);
            }

            this.originalLocale=originalLocale!=null?originalLocale:
                Locale.getDefault();

            resourceKey=key;
            this.rsrcBundleName=rsrcBundleName;

            // create the fallback message
            try {
                fallbackMessage=localize(rsrcBundleName, key, rplcTxt, this.originalLocale);
            }
            catch (ThreadDeath td) {
                throw td;
            }
            catch (Throwable t) {
                // if fallback message failed, create something
                StringBuffer text=new
                    StringBuffer("Error: Message '" +resourceKey+
                    "' was issued but it was not found in local resource bundle '" +
                    this.rsrcBundleName+"'. ");

                if (rplcTxt!=null) {
                    for (int i=0; i<rplcTxt.length; i++) {
                        text.append(": ");
                        try {
                            text.append(rplcTxt[i]);
                        }
                        catch (ThreadDeath td) {
                            throw td;
                        }
                        catch (Throwable t2) {
                            text.append("??");
                        }
                    } //end for
                }

                fallbackMessage=text.toString();
            } //end catch
    } //end constructor


    //==============================================================================
    //=                  Static Methods
    //==============================================================================


    //==============================================================================
    //=                  Public Methods
    //==============================================================================

  /**
   * Returns the localized text for this message.  If localization fails, a version
   * of the message localized in the original locale will be returned instead.
   *
   * @param localeToUse is the Locale to be used for localizing the text.  If not provided,
   *               the default system Locale will be used.
   * @return Localized text of the message.
   */
    public String getLocalizedText(Locale localeToUse) {

        Locale locale=localeToUse!=null?localeToUse:Locale.getDefault();

        String text=null;

        try {
            //turn the replacement text paramaeters back into useable object form
            Serializable[] rplcTxt=new Serializable[replacementText.length];
            for (int i=0; i<rplcTxt.length; i++) {
                rplcTxt[i]=(Serializable)replacementText[i].get();
            }

            text=localize(rsrcBundleName, resourceKey, rplcTxt, locale);
        }
        catch (Throwable t) {
            //finish this - we might want to log this problem
        } //end catch

        // use fallback message if necessary
        return text!=null?text:fallbackMessage;
    } //end getLocalizedText

  /**
   * Gets the original locale used to create this message. This is
   * the Locale that was used to generate the default message text
   * if there is a problem returning the message text in the current (or
   * provided) Locale.
   *
   * @return The original Locale for this message
   **/
    public Locale getOriginalLocale() {
        return originalLocale;
    }

  /**
   * Gets the key to the resource in the resourceBundle that is used to create
   * the localizable message text.
   *
   * @return the key to the resourceBundle resource used to create the localizable message
   **/
    public String getResourceKey() {
        return resourceKey;
    }

  /**
   * Gets the replacement text that is used to create
   * the localizable message text.
   *
   * @return the replacement text that is used to create the localizable message text.
   **/
    public MarshalledObject[] getReplacementText() {
        return replacementText;
    }

  /**
   * Gets the name of the resource bundle from where the resource used to create
   * the localizable message text will be retrieved.
   *
   * @return the name of the resource bundle
   **/
    public String getResourceBundleName() {
        return rsrcBundleName;
    }

  /**
   * Gets the message text that will be returned in localization of this message fails.  This
   * fallback text is generated at the time the LocalizableMessage is created and uses the original
   * Locale.
   *
   * @return the fallback message String
   **/
    public String getFallbackMessage() {
        return fallbackMessage;
    }


    //Override ToString implementation
    public String toString() {
        String newLine=System.getProperty("line.separator");

        StringBuffer wrkArea=new
            StringBuffer(this.getClass().getName()+"Values: " +newLine);
        wrkArea.append("\t originalLocale:   " +
            this.getOriginalLocale()+newLine);
        wrkArea.append("\t key:              " +this.getResourceKey()+newLine);
        wrkArea.append("\t resource bundle:  " +
            this.getResourceBundleName()+newLine);
        wrkArea.append("\t fallback message: " +
            this.getFallbackMessage()+newLine);

        MarshalledObject[] mo=this.getReplacementText();
        wrkArea.append("\t Replacement Text " +newLine);
        if (mo.length==0) {
            wrkArea.append("\t\t NONE" +newLine);
        }
        else {
            for (int i=0; i<mo.length; i++) {
                try {
                    wrkArea.append("\t\t replacement text[" +i+"]: " +
                        mo[i].get()+newLine);
                }
                catch (ThreadDeath td) {
                    throw td;
                }
                catch (Throwable t) {
                    wrkArea.append("\t\t replacement text[" +i+
                        "]: ERROR RETRIEVING" +newLine);
                }
            }
        }
        wrkArea.append("\t Localized Message: " +this.getLocalizedText(null));
        wrkArea.append(newLine+newLine);

        return wrkArea.toString();
    }


    //===================================================================================================
    //                               Protected Methods
    //===================================================================================================

 /**
  * Returns the localized text for this message.
  *
  * @param rsrcBundleName is the name of the resource bundle containing the translatable
  *            message text.  This must be a fully qualified name
  *            (e.g. com.<company>.<project>.<package>.xxxResourceBundle). It is a
  *            Mandatory parameter and may not be an empty String.
  * @param key is the key into the resourceBundle of the message text to use
  *            for this localizable message. The key must be associated with either a String or
  *            a MessageFormat object.  It is a Mandatory parameter and may not be an empty String.
  * @param rplcText is the array of objects to be used as replacement
  *            text in the text retrieved from the resourceBundle.
  * @param localeToUse is the Locale in which the message text is to be formatted.  It
  *            is a Mandatory parameter.
  * @return Localized text of the message.
  * @throws LocalizationException is thrown if localization fails.  This may be because the retrieval of the
  *            resource from the messageBundle failed, the retrieved resource was not a String or
  *            MessageFormat object.
  * @throws MissingResourceException is thrown if either the resourceBundle is not found
  *             or the key is not valid within the resourceBundle
  */
    protected String localize(String rsrcBundleName, String key,
        Serializable[] rplcText, Locale localeToUse)
        throws LocalizationException {

            Object resource=null;

            try {
                ResourceBundle rb=ResourceBundle.getBundle(rsrcBundleName,
                    localeToUse);
                if (rb!=null) {
                    resource=rb.getObject(key);
                }
            }
            catch (Throwable t) {
                throw new LocalizationException("Unable to localize text. ResourceBundle: " +
                    rsrcBundleName+" key: " +key+" locale: " +localeToUse+
                    "original Throwable: " +t, rsrcBundleName, key, true);
            }

            // fail if localization file cannot be found
            if (resource==null) {
                throw new MissingResourceException("Resource not found",
                    rsrcBundleName, key);
            }

            // resource is non-null, and is a valid "resource".
            //
            // If it is a string, use the string as a pattern string
            // to create a MessageFormat; if it is a MessageFormat, use it
            // as is; otherwise just convert it to a string via toString(),
            // and return that string as the result.
            MessageFormat messageFormat=null;
            if (resource instanceof String) {
                messageFormat=new MessageFormat((String)resource);
            }
            else if (resource instanceof MessageFormat) {
                messageFormat=(MessageFormat)resource;
            }
            else {
                throw new LocalizationException("Resource retrieved from ResourceBundle is not a String or MessageFormat. " +
                    " ResourceBundle: " +rsrcBundleName+" key: " +key+
                    " locale: " +localeToUse+" resourceType: " +
                    resource.getClass().getName(), rsrcBundleName, key, true);
            } //end if/then/else

            //  messageFormat is a valid MessageFormat.
            //
            //  Set the locale for the message format, and do the formatting
            //  of the parameters into that message format, and return the
            //  result.
            StringBuffer result=new StringBuffer();
            messageFormat.setLocale(localeToUse);
            try {
                // localize any params if needed first
                if (rplcText!=null) {
                    for (int i=0; i<rplcText.length; i++) {
                        if (rplcText[i] instanceof
                            com.digi.config.util.LocalizableMessage) {
                                LocalizableMessage lm=
                                    (LocalizableMessage)rplcText[i];
                                rplcText[i]=null; // avoid possible recursive infinite loop
                                rplcText[i]=lm.getLocalizedText(localeToUse);
                        } //end if
                    } //end for
                } //end if

                messageFormat.format(rplcText, result, new FieldPosition(0));
            }
            catch (ThreadDeath td) {
                throw td;
            }
            catch (Throwable t) {
                throw new LocalizationException("Message Format failed" +
                    " ResourceBundle: " +rsrcBundleName+" key: " +key+
                    " locale: " +localeToUse+"original Throwable: " +t,
                    rsrcBundleName, key, true);
            } //end catch Throwable

            return result.toString();
    } //end localize


    //===================================================================================================
    //                               Private Methods
    //===================================================================================================
    //
    // Writes the object out to the ObjectOutputStream.  We want to bullet proof this operation
    // since this method is called by the Java infrastructure.  At the very least, we want to ensure
    // that the fallBackMessage is written to the stream.
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.writeObject(fallbackMessage);
        try {
            out.defaultWriteObject();
        }
        catch (Throwable t) {
            //nothing we can really do so ignore it
        }
    } //end writeObject

    //
    // Reads the object from the ObjectOutputStream.  We want to bullet proof this operation
    // since this method is called by the Java infrastructure.  At the very least, we want to ensure
    // that the fallbackMessage is read from the stream.
    private void readObject(ObjectInputStream in) throws IOException,
        ClassNotFoundException {
            fallbackMessage=(String)in.readObject();
            try {
                in.defaultReadObject();
            }
            catch (Throwable t) {
                //nothing we can really do so ignore it
            } //end catch
    } //end readObject

} // LocalizableMessage