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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

public final class ToMessage implements Message
{
    protected static final String PREFIX = Constants.PROTOCOL_PREFIX + ModuleMsgLifecycleForm.To + Constants.NV_SEP;
    protected static final String FROM_PREFIX = "From" + Constants.NV_SEP;
    protected static final String ERROR_PREFIX = "Error" + Constants.NV_SEP;
    protected static final String TERMINATOR_PREFIX = "Terminator" + Constants.NV_SEP;
    protected static final String ONELINE_PREFIX = "OneLine" + Constants.NV_SEP;
    protected static final String NOLINES = "NoLines";
    protected static final String INITIAL_TERMINATOR = "-----";

    private ToMsgForm mForm;
    private String mFrom;
    private String mTo;
    private String mId;
    private String mError;
    private String mTerminatingMsgLine;

    private final String[] mMsgLines;

    protected ToMessage( ToMsgForm pForm, String pFrom, String pTo, String pId, String pError,
                         String pTerminatingMsgLine, String[] pMsgLines )
    {
        mForm = pForm;
        mFrom = pFrom;
        mTo = pTo;
        mId = pId;
        mError = pError;
        mTerminatingMsgLine = pTerminatingMsgLine;
        mMsgLines = pMsgLines;
    }

    public String[] getMsgLines()
    {
        return (mMsgLines != null) ? mMsgLines.clone() : null;
    }

    public String getMsgBody()
    {
        return (mError != null) || (mMsgLines == null) || (mMsgLines.length == 0) ? null :
               LowLevelBuildMsgBody();
    }

    private String LowLevelBuildMsgBody()
    {
        StringBuilder sb = new StringBuilder();
        for ( String line : mMsgLines )
        {
            sb.append( line ).append( '\n' );
        }
        sb.append( mTerminatingMsgLine );
        return sb.toString();
    }

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

    private String CombinedHeaderAndMsgBody()
    {
        String rv = getHeader();
        if ( (mMsgLines != null) && (mMsgLines.length > 1) )
        {
            rv += "\n" + LowLevelBuildMsgBody();
        }
        return rv;
    }

    public String ToSendText()
    {
        return CombinedHeaderAndMsgBody() + "\n";
    }

    public String getHeader()
    {
        String rv = PREFIX + mTo + " " + FROM_PREFIX + mFrom + " " + mForm + Constants.NV_SEP + mId;
        if ( mError != null )
        {
            rv += " " + ERROR_PREFIX + mError;
        }
        else if ( (mMsgLines == null) || (mMsgLines.length == 0) )
        {
            rv += " " + NOLINES;
        }
        else if ( mMsgLines.length == 1 )
        {
            rv += " " + ONELINE_PREFIX + mMsgLines[0];
        }
        else if ( !Strings.isNullOrEmpty( mTerminatingMsgLine ) )
        {
            rv += " " + TERMINATOR_PREFIX + mTerminatingMsgLine;
        }
        return rv;
    }

    public ToMsgForm getForm()
    {
        return mForm;
    }

    public String getFrom()
    {
        return mFrom;
    }

    public String getTo()
    {
        return mTo;
    }

    public String getId()
    {
        return mId;
    }

    public String getError()
    {
        return mError;
    }

    public String getTerminatingMsgLine()
    {
        return mTerminatingMsgLine;
    }

    public static class Builder
    {
        public static Builder FromHeader( String pHeader )
        {
            if ( (pHeader != null) && pHeader.startsWith( PREFIX ) )
            {
                //String zRest = Utils.trimLeadingSpaces( pHeader.substring( PREFIX.length() ));
                RestOfMsg vRestOfMsg =
                        new RestOfMsg( Strings.trimLeadingSpaces( pHeader.substring( PREFIX.length() ) ) );
                String zTo = thru( ' ', vRestOfMsg ); // ref is reference. Create zRest object
                if ( vRestOfMsg.getRest().startsWith( FROM_PREFIX ) )
                {
                    vRestOfMsg.setRest( Strings.trimLeadingSpaces(
                            vRestOfMsg.getRest().substring( FROM_PREFIX.length() ) ) );
                    String zFrom = thru( ' ', vRestOfMsg );
                    ToMsgForm zForm = convertToMsgForm( thru( Constants.NV_SEP, vRestOfMsg ) );
                    if ( zForm != null )
                    {
                        vRestOfMsg.setRest( Strings.trimLeadingSpaces( vRestOfMsg.getRest().substring( 1 ) ) );
                        String zId = thru( ' ', vRestOfMsg );
                        String zError = null;
                        String zTerminator = "";
                        boolean zNoLines = false;
                        String zOneLine = null;
                        if ( vRestOfMsg.getRest().startsWith( ERROR_PREFIX ) )
                        {
                            zError = vRestOfMsg.getRest().substring( ERROR_PREFIX.length() ).trim();
                        }
                        else if ( vRestOfMsg.getRest().equals( NOLINES ) )
                        {
                            zNoLines = true;
                        }
                        else if ( vRestOfMsg.getRest().startsWith( ONELINE_PREFIX ) )
                        {
                            zOneLine = vRestOfMsg.getRest().substring( ONELINE_PREFIX.length() );
                        }
                        else if ( vRestOfMsg.getRest().startsWith( TERMINATOR_PREFIX ) )
                        {
                            zTerminator = vRestOfMsg.getRest().substring( TERMINATOR_PREFIX.length() ).trim();
                        }
                        Builder rv = fromParams( zForm, zFrom, zTo, zId, zError );
                        if ( rv != null )
                        {
                            rv.mLinesTerminatorFromHeader = zTerminator;
                            if ( zNoLines || (zOneLine != null) )
                            {
                                if ( zOneLine != null )
                                {
                                    if ( !rv.LowLevelAddMsgLine( zOneLine ) )
                                    {
                                        return null;
                                    }
                                }
                                rv.mMsgLinesTerminated = true;
                            }
                            return rv;
                        }
                    }
                }
            }
            return null;
        }

        public static class RestOfMsg
        {
            private String mRest;

            public RestOfMsg( String pRest )
            {
                mRest = pRest;
            }

            public String getRest()
            {
                return mRest;
            }

            public void setRest( String pRest )
            {
                mRest = pRest;
            }
        }

        private static ToMsgForm convertToMsgForm( String pStr )
        {
            try
            {
                return ToMsgForm.valueOf( pStr );
            }
            catch ( IllegalArgumentException ex )
            {
                return null;
            }
        }

        //private static String thru( char pSep, ref String pLine )
        private static String thru( char pSep, RestOfMsg pLine )
        {
            String rv;
            int zAt = pLine.getRest().indexOf( pSep );
            if ( zAt == -1 )
            {
                rv = pLine.getRest();
                pLine.setRest( "" );
            }
            else
            {
                rv = pLine.getRest().substring( 0, zAt );
                pLine.setRest( Strings.trimLeadingSpaces( pLine.getRest().substring( zAt ) ) );
            }
            return rv;
        }

        private Builder( ToMsgForm pForm, String pFrom, String pTo, String pId, String pError )
        {
            mForm = pForm;
            mFrom = pFrom;
            mTo = pTo;
            mId = pId;
            mError = pError;
        }

        private static Builder fromParams( ToMsgForm pForm, String pFrom, String pTo, String pId,
                                           String pError )
        {
            pFrom = Strings.noEmpty( pFrom );
            pTo = Strings.noEmpty( pTo );
            pId = Strings.noEmpty( pId );

            if ( Strings.isAsciiIdentifier( pFrom ) && Strings.isAsciiIdentifier( pTo ) && Strings.isNoSpaceAscii( pId ) )
            {
                return new Builder( pForm, pFrom, pTo, pId, Strings.noEmpty( pError ) );
            }
            return null;
        }

        public static Builder Notify( String pFrom, String pTo, String pId, String pError )
        {
            return fromParams( ToMsgForm.Notify, pFrom, pTo, pId, pError );
        }

        public static Builder Notify( String pFrom, String pTo, String pId )
        {
            return Notify( pFrom, pTo, pId, null );
        }

        public static Builder Request( String pFrom, String pTo, String pId )
        {
            return fromParams( ToMsgForm.Request, pFrom, pTo, pId, null );
        }

        public static Builder Reply( ToMessage pReplyTo, String pError )
        {
            if ( pReplyTo == null )
            {
                throw new NullPointerException( "pReplyTo" );
            }
            return fromParams( ToMsgForm.Reply, pReplyTo.mTo, pReplyTo.mFrom, pReplyTo.mId, pError );
        }

        public static Builder Reply( ToMessage pReplyTo )
        {
            return Reply( pReplyTo, null );
        }

        public void AddMsgLine( String pLine )
        {
            if ( pLine == null )
            {
                throw new IllegalStateException( "May Not add a Null line" );
            }
            if ( mMsgLinesTerminated )
            {
                throw new IllegalStateException(
                        "May Not add any more lines after the the Message Lines have been Terminated" );
            }
            if ( mError != null )
            {
                throw new IllegalStateException( "May Not add lines to an Error'd Message" );
            }
            mAnyEmptyMsgLines |= (pLine.length() == 0);
            while ( pLine.startsWith( mLinesTerminatorEvolving ) )
            {
                mLinesTerminatorEvolving += "-";
            }
            if ( pLine.equals( mLinesTerminatorFromHeader ) )
            {
                mMsgLinesTerminated = true;
                return;
            }
            if ( !LowLevelAddMsgLine( pLine ) )
            {
                throw new IllegalStateException(
                        "May Not add lines with Control Characters (< ' ') to a Message" );
            }
        }

        // return true if line is empty || consists of characters which are >= ' '
        protected boolean LowLevelAddMsgLine( String pLine )
        {
            for ( int i = 0; i < pLine.length(); i++ )
            {
                if ( pLine.charAt( i ) < ' ' )
                {
                    return false;
                }
            }
            mMsgLines.add( pLine );
            return true;
        }

        private ToMsgForm mForm;
        private String mFrom;
        private String mTo;
        private String mId;
        private String mError;

        private String mLinesTerminatorFromHeader;

        private String mLinesTerminatorEvolving = INITIAL_TERMINATOR;
        private boolean mAnyEmptyMsgLines;

        private boolean mMsgLinesTerminated;

        private final List<String> mMsgLines = new ArrayList<String>();

        public List<String> getMsgLines()
        {
            return mMsgLines;
        }

        public ToMessage ToMsg()
        {
            String zTerminator = null;
            String[] zMsgLines = null;
            if ( mError == null )
            {
                zMsgLines = mMsgLines.toArray( new String[mMsgLines.size()] );
                mMsgLinesTerminated = true;
                if ( null == (zTerminator = mLinesTerminatorFromHeader) ) // Not Header Terminated
                {
                    zTerminator = mAnyEmptyMsgLines ? mLinesTerminatorEvolving : "";
                }
            }
            return new ToMessage( mForm, mFrom, mTo, mId, mError, zTerminator, zMsgLines );
        }

        public boolean ExpectsMoreLines()
        {
            return ((mError == null) && !mMsgLinesTerminated);
        }

        public ToMsgForm getForm()
        {
            return mForm;
        }

        public void setForm( ToMsgForm pForm )
        {
            mForm = pForm;
        }

        public String getFrom()
        {
            return mFrom;
        }

        public void setFrom( String pFrom )
        {
            mFrom = pFrom;
        }

        public String getTo()
        {
            return mTo;
        }

        public void setTo( String pTo )
        {
            mTo = pTo;
        }

        public String getId()
        {
            return mId;
        }

        public void setId( String pId )
        {
            mId = pId;
        }

        public String getError()
        {
            return mError;
        }

        public void setError( String pError )
        {
            mError = pError;
        }

        public String getLinesTerminatorFromHeader()
        {
            return mLinesTerminatorFromHeader;
        }

        public void setLinesTerminatorFromHeader( String pLinesTerminatorFromHeader )
        {
            mLinesTerminatorFromHeader = pLinesTerminatorFromHeader;
        }

        public boolean isMsgLinesTerminated()
        {
            return mMsgLinesTerminated;
        }

        public void setMsgLinesTerminated( boolean pMsgLinesTerminated )
        {
            mMsgLinesTerminated = pMsgLinesTerminated;
        }
    }
}