// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.simpletypes.currency;

import java.util.*;

import org.litesoft.core.simpletypes.*;
import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.typeutils.*;

public class SimpleCurrency extends CompareSupport<SimpleCurrency> implements SimpleType
{
    public static final SimpleCurrency US = new SimpleCurrency( "USD", 2, NumericFormatControl.US );
    public static final SimpleCurrency CA_English = new SimpleCurrency( "CAD", 2, NumericFormatControl.COMMA_DOT );
    public static final SimpleCurrency CA_French = new SimpleCurrency( "CAD", 2, NumericFormatControl.SPACE_COMMA );
    public static final SimpleCurrency EURO = new SimpleCurrency( "EUR", 2, NumericFormatControl.SPACE_COMMA );

    private static final HashMap<String, SimpleCurrency> CURRENCIES = new HashMap<String, SimpleCurrency>();

    public static synchronized SimpleCurrency get( String pCurrencyCode )
    {
        return (pCurrencyCode != null) ? CURRENCIES.get( pCurrencyCode ) : null;
    }

    public static synchronized void add( SimpleCurrency pCurrency )
    {
        if ( pCurrency != null )
        {
            String zCode = pCurrency.getCurrencyCode();
            if ( CURRENCIES.containsKey( zCode ) )
            {
                throw new IllegalStateException( "Currency '" + zCode + "' already registered" );
            }
            CURRENCIES.put( zCode, pCurrency );
        }
    }

    public static synchronized void replace( SimpleCurrency pCurrency )
    {
        if ( pCurrency != null )
        {
            String zCode = pCurrency.getCurrencyCode();
            if ( !CURRENCIES.containsKey( zCode ) )
            {
                throw new IllegalStateException( "Currency '" + zCode + "' NOT already registered" );
            }
            CURRENCIES.put( zCode, pCurrency );
        }
    }

    static
    {
        add( US );
        add( CA_English );
        add( EURO );
    }

    private String mCurrencyCode; // ISO 4217
    private int mDefaultFractionDigits;
    private NumericFormatControl mFormatControl;

    /**
     * @deprecated - for Serialization
     */
    protected SimpleCurrency()
    {
    }

    public SimpleCurrency( String pCurrencyCode, int pDefaultFractionDigits, NumericFormatControl pFormatControl )
    {
        mCurrencyCode = Strings.assertNotNullNotEmpty( "CurrencyCode", pCurrencyCode );
        if ( mCurrencyCode.length() != 3 )
        {
            throw new IllegalArgumentException( "Currency Codes should be 3 characters long per ISO 4217" );
        }
        if ( (mDefaultFractionDigits = pDefaultFractionDigits) < 0 )
        {
            throw new IllegalArgumentException( "DefaultFractionDigits can not be < 0" );
        }
        Objects.assertNotNull( "NumericFormatControl", mFormatControl = pFormatControl );
    }

    public String getCurrencyCode()
    {
        return mCurrencyCode;
    }

    public int getDefaultFractionDigits()
    {
        return mDefaultFractionDigits;
    }

    public NumericFormatControl getFormatControl()
    {
        return mFormatControl;
    }

    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof SimpleCurrency) && equals( (SimpleCurrency) o ));
    }

    public boolean equals( SimpleCurrency them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mCurrencyCode, them.mCurrencyCode ) //
                && equal( this.mDefaultFractionDigits, them.mDefaultFractionDigits ) //
               );
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mDefaultFractionDigits ), //
                           calcHashCode( mCurrencyCode ) );
    }

    public int compareTo( SimpleCurrency them )
    {
        return compareEm( compare( this.mCurrencyCode, them.mCurrencyCode ), //
                          compare( this.mDefaultFractionDigits, them.mDefaultFractionDigits ) );
    }

    public String toString()
    {
        return mCurrencyCode;
    }

    public String desiccate()
    {
        return mCurrencyCode + '.' + mDefaultFractionDigits + '|' + mFormatControl.desiccate();
    }

    public static SimpleCurrency rehydrate( String pDesiccated )
            throws IllegalArgumentException
    {
        pDesiccated = Strings.deNull( pDesiccated );
        int dpAt = pDesiccated.indexOf( '.' );
        int nfcSepAt = pDesiccated.indexOf( '|' );
        if ( (3 <= dpAt) && ((dpAt + 1) < nfcSepAt) )
        {
            try
            {
                String zCurrencyCode = pDesiccated.substring( 0, dpAt );
                int zDefaultFractionDigits = Integer.parseInt( pDesiccated.substring( dpAt + 1, nfcSepAt ).trim() );
                return new SimpleCurrency( zCurrencyCode, zDefaultFractionDigits, //
                                           NumericFormatControl.rehydrate( pDesiccated.substring( nfcSepAt + 1 ) ) );
            }
            catch ( NumberFormatException e )
            {
                // Fall Thru
            }
        }
        throw new IllegalArgumentException( "Unable to SimpleCurrency.rehydrate( \"" + pDesiccated + "\") form looks like: USD.2|#,###.#" );
    }
}