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

import org.litesoft.commonfoundation.base.*;
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 ( !Currently.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 = ConstrainTo.significantOrNull( pFrom );
            pTo = ConstrainTo.significantOrNull( pTo );
            pId = ConstrainTo.significantOrNull( pId );

            if ( Strings.isAsciiIdentifier( pFrom ) && Strings.isAsciiIdentifier( pTo ) && Strings.isNoSpaceAscii( pId ) ) {
                return new Builder( pForm, pFrom, pTo, pId, ConstrainTo.significantOrNull( 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;
        }
    }
}