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

import org.litesoft.server.file.*;

import java.io.*;
import java.util.*;

public class TextFileProcessor {
    public static void main( String[] args ) {
        if ( args.length < 3 ) {
            System.out.println( "Usage: inputFile, acceptedFile, rejectedFile" );
            System.exit( 1 );
        }

        File zRejectedFile = new File( args[2] );
        File zAcceptedFile = new File( args[1] );
        Chunk[] zChunks = chunk( FileUtils.loadTextFile( new File( args[0] ) ) );

        List<String> zAccepted = new ArrayList<String>();
        List<Chunk> zRejected = new ArrayList<Chunk>();

        for ( Chunk zChunk : zChunks ) {
            String zQuoteAsString = zChunk.accept();
            if ( zQuoteAsString != null ) {
                zAccepted.add( zQuoteAsString );
            } else {
                zRejected.add( zChunk );
            }
        }

        if ( !zAccepted.isEmpty() ) {
            System.out.println( "Accepted: " + zAccepted.size() );
            FileUtils.appendTextFile( zAcceptedFile, zAccepted.toArray( new String[zAccepted.size()] ) );
        }
        if ( !zRejected.isEmpty() ) {
            System.out.println( "Rejected: " + zRejected.size() );
            List<String> zToWrite = new ArrayList<String>();
            for ( Chunk zChunk : zRejected ) {
                zToWrite.addAll( zChunk.getLines() );
                zToWrite.add( "." );
            }
            FileUtils.storeTextFile( zRejectedFile, zToWrite.toArray( new String[zToWrite.size()] ) );
        }
    }

    private static Chunk[] chunk( String[] pStrings ) {
        List<Chunk> zChunks = new ArrayList<Chunk>();
        Chunk zChunk = new Chunk();
        for ( String zLine : pStrings ) {
            if ( !zLine.equals( "." ) ) {
                zChunk.addLine( zLine );
            } else if ( !zChunk.isEmpty() ) {
                zChunks.add( zChunk );
                zChunk = new Chunk();
            }
        }
        if ( !zChunk.isEmpty() ) {
            zChunks.add( zChunk );
        }
        return zChunks.toArray( new Chunk[zChunks.size()] );
    }

    private static class Chunk {
        private List<String> mLines = new ArrayList<String>();

        public boolean isEmpty() {
            return mLines.isEmpty();
        }

        public List<String> getLines() {
            return mLines;
        }

        public void addLine( String pLine ) {
            mLines.add( pLine );
        }

        private boolean all7BitAscii( String pLine ) {
            for ( int i = pLine.length(); --i >= 0; ) {
                char c = pLine.charAt( i );
                if ( (c < ' ') || (126 < c) ) {
                    return false;
                }
            }
            return true;
        }

        public String accept() {
            String rv = combineLinesIfOK();
            if ( rv == null ) {
                return null;  // reject!
            } // . . . . . . . . . 012345
            int at = rv.indexOf( "\" -- " );
            String zQuote = rv.substring( 1, at ).trim();
            String zAttribute = rv.substring( at + 5 ).trim();
            return isOK( zAttribute ) && isOK( zQuote ) ? zAttribute + " | " + zQuote : null;
        }

        private boolean isOK( String pText ) {
            return (pText.length() > 1) && !pText.contains( "\"" );
        }

        private String combineLinesIfOK() {
            String rv = null;
            if ( (mLines.size() <= 15) ) {
                if ( mLines.size() == 1 ) {
                    rv = checkSingleLine( mLines.get( 0 ) );
                } else {
                    int ndx = mLines.size() - 1;
                    String zLastLine = mLines.get( ndx-- );
                    if ( zLastLine.startsWith( " -- " ) ) {
                        zLastLine = mLines.get( ndx-- ) + zLastLine;
                    }
                    rv = checkLastLine( zLastLine );
                    while ( (rv != null) && ndx > 0 ) {
                        rv = checkMiddleLine( rv, mLines.get( ndx-- ) );
                    }
                    if ( rv != null ) {
                        rv = checkFirstLine( rv, mLines.get( 0 ) );
                    }
                }
            }
            return rv;
        }

        private boolean lineOK( String pLine, char pStartsWith ) {
            return ((pLine.length() > 1) && all7BitAscii( pLine ) && (pLine.charAt( 0 ) == pStartsWith));
        }

        private String checkSingleLine( String pLine ) {
            if ( lineOK( pLine, '"' ) && pLine.contains( "\" -- " ) ) {
                return pLine.trim();
            }
            return null;
        }

        private String checkLastLine( String pLine ) {
            if ( lineOK( pLine, ' ' ) && pLine.contains( "\" -- " ) ) {
                return pLine.trim();
            }
            return null;
        }

        private String checkMiddleLine( String pAccumulated, String pLine ) {
            if ( lineOK( pLine, ' ' ) && !pLine.contains( " -- " ) ) {
                return pLine.trim() + " " + pAccumulated;
            }
            return null;
        }

        private String checkFirstLine( String pAccumulated, String pLine ) {
            if ( lineOK( pLine, '"' ) && !pLine.contains( " -- " ) ) {
                return pLine.trim() + " " + pAccumulated;
            }
            return null;
        }
    }
}