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

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;
        }
    }
}