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

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

/**
 * Email address as specified by <a href="http://www.ietf.org/rfc/rfc2822.txt">RFC 2822, "Internet Message Format"</a>
 * constrained to "global" addresses (must be a Secondary Level Domain, AND the Top Level Domain must be only letters).
 * <p/>
 * In addition only the "dot-atom" forms (with out the [CFWS]) of the "local-part" and "domain" are supported!
 */
public class EmailAddress extends CompareSupport<EmailAddress>
{
    private final String mLocalPart, mDomain;

    public EmailAddress( String pLocalPart, String pDomain )
            throws IllegalArgumentException
    {
        mLocalPart = Strings.deNull( pLocalPart ).trim();
        mDomain = Strings.deNull( pDomain ).trim().toLowerCase();
        validate();
    }

    public EmailAddress( String pAddress )
            throws IllegalArgumentException
    {
        int zAt = (pAddress = Strings.deNull( pAddress )).indexOf( '@' );
        if ( zAt == -1 )
        {
            throw new IllegalArgumentException( "No Local-part / Domain separator ('@')" );
        }
        mLocalPart = pAddress.substring( 0, zAt ).trim();
        mDomain = pAddress.substring( zAt + 1 ).trim().toLowerCase();
        validate();
    }

    public String getLocalPart()
    {
        return mLocalPart;
    }

    public String getDomain()
    {
        return mDomain;
    }

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

    public boolean equals( EmailAddress them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mLocalPart, them.mLocalPart ) //
                && equal( this.mDomain, them.mDomain ) //
               );
    }

    @Override public int hashCode()
    {
        return hashCodeEm( mLocalPart.hashCode(), mDomain.hashCode() );
    }

    @Override
    public int compareTo( EmailAddress them )
    {
        return compareEm( compare( this.mLocalPart, them.mLocalPart ), //
                          compare( this.mDomain, them.mDomain ) );
    }

    @Override
    public String toString()
    {
        return mLocalPart + "@" + mDomain;
    }

    private void validate()
            throws IllegalArgumentException
    {
        validateDomain();
        validateDotAtomText( "Local-part", mLocalPart );
    }

    private void validateDomain()
            throws IllegalArgumentException
    {
        validateDotAtomText( "Domain", mDomain );
        int zAt = mDomain.lastIndexOf( '.' );
        if ( zAt == -1 )
        {
            throw new IllegalArgumentException( "TLD only Domain" );
        }
        if ( !Strings.isAll7BitAsciiAlpha( mDomain.substring( zAt + 1 ), 1 ) )
        {
            throw new IllegalArgumentException( "Domain TLD not all Ascii Alpha" );
        }
    }

    private void validateDotAtomText( String pWhat, String pText )
    {
        if ( pText.length() == 0 )
        {
            throw new IllegalArgumentException( "No " + pWhat );
        }
        if ( !isDotAtomText( pText ) )
        {
            throw new IllegalArgumentException( pWhat + " format" );
        }
    }

    private boolean isDotAtomText( String pText )
    {
        int zFrom = 0;
        for ( int zTo; -1 != (zTo = pText.indexOf( '.', zFrom )); zFrom = zTo + 1 )
        {
            if ( !isAText( pText.substring( zFrom, zTo ) ) )
            {
                return false;
            }
        }
        return isAText( pText.substring( zFrom ) );
    }

    private boolean isAText( String pText )
    {
        if ( pText.length() == 0 )
        {
            return false;
        }
        for ( int i = 0; i < pText.length(); i++ )
        {
            if ( !isAText( pText.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    private boolean isAText( char c )
    {
        return !isCtrl( c ) && (c != ' ') && !isSpecials( c );
    }

    private boolean isCtrl( char c )
    {
        return (c < ' ') || (c == 127);
    }

    private boolean isSpecials( char c )
    {
        return "()<>[]:;,.@\\\"".indexOf( c ) != -1;
    }
}