package org.litesoft.locale;

public abstract class AbstractLocale
{
    public static final String BAD_LANGUAGE_OR_COUNTRY = "??";

    private static final String LOCALE_CLASS_NAME_PREFIX = ".Locale_";

    private final boolean mActive;
    private final String mLanguage, mCountry, mCode;
    /* friend( DerivedLocaleGraph ) */ int mDepth;

    protected AbstractLocale( boolean pActive )
    {
        mActive = pActive;
        String zName = "." + this.getClass().getName();
        int zAt = zName.indexOf( LOCALE_CLASS_NAME_PREFIX );
        if ( zAt == -1 )
        {
            throw new IllegalStateException( "'" + LOCALE_CLASS_NAME_PREFIX + "' not found in: " + zName );
        }
        String zLanguageCountry = zName.substring( zAt + LOCALE_CLASS_NAME_PREFIX.length() );
        if ( !isValidStructuredCode( zLanguageCountry ) )
        {
            throw new IllegalStateException( "No Language & Country found in: " + zName );
        }
        mLanguage = assertLowerCase( "Language", codeToLanguage( zLanguageCountry ) );
        mCountry = assertUpperCase( "Country", codeToCountry( zLanguageCountry ) );
        mCode = toCode( mLanguage, mCountry );
    }

    private static String assertLowerCase( String pWhat, String pString )
    {
        return assertCase( pWhat, pString, pString.toLowerCase(), "LowerCase" );
    }

    private static String assertUpperCase( String pWhat, String pString )
    {
        return assertCase( pWhat, pString, pString.toUpperCase(), "UpperCase" );
    }

    private static String assertCase( String pWhat, String pString, String pAdjustedString, String pCase )
    {
        if ( pString.equals( pAdjustedString ) )
        {
            return pString;
        }
        throw new IllegalStateException( pWhat + " '" + pString + "' NOT " + pCase );
    }

    protected AbstractLocale()
    {
        this( true );
    }

    public boolean isActive()
    {
        return mActive;
    }

    public String getLanguage()
    {
        return mLanguage;
    }

    public String getCountry()
    {
        return mCountry;
    }

    public String getCode()
    {
        return mCode;
    }

    @Override
    public boolean equals( Object o )
    {
        return (this == o) || ((o instanceof AbstractLocale) && equals( (AbstractLocale) o ));
    }

    public boolean equals( AbstractLocale them )
    {
        return (this == them) || ((them != null)
                                  && this.mCode.equals( them.mCode ));
    }

    @Override
    public int hashCode()
    {
        return mCode.hashCode();
    }

    @Override
    public String toString()
    {
        return getCode();
    }

    public static String languageFrom( String pCode )
    {
        return isValidStructuredCode( pCode ) ? codeToLanguage( pCode ) : BAD_LANGUAGE_OR_COUNTRY;
    }

    public static String countryFrom( String pCode )
    {
        return isValidStructuredCode( pCode ) ? codeToCountry( pCode ) : BAD_LANGUAGE_OR_COUNTRY;
    }

    public static String toCode( String pLanguage, String pCountry )
    {
        return ensure2Char( pLanguage ).toLowerCase() + "_" + ensure2Char( pCountry ).toUpperCase();
    }

    private static boolean isValidStructuredCode( String pCode )
    {
        return (pCode != null) && (pCode.length() == 5) && (pCode.charAt( 2 ) == '_');
    }

    private static String codeToLanguage( String pLanguageCountry )
    {
        return pLanguageCountry.substring( 0, 2 );
    }

    private static String codeToCountry( String pLanguageCountry )
    {
        return pLanguageCountry.substring( 3 );
    }

    private static String ensure2Char( String pString )
    {
        if ( pString != null )
        {
            if ( (pString = pString.trim()).length() == 2 )
            {
                return pString;
            }
        }
        return BAD_LANGUAGE_OR_COUNTRY;
    }
}