/*
 * [Splitter.java]
 *
 * Summary: splits files into pieces based on embedded markers.
 *
 * Copyright: (c) 2004-2017 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.1 2006-03-05 reformat with IntelliJ, add Javadoc
 *  1.2 2007-05-22 add PAD and icon. Tidy with IntelliJ inspector.
 *  1.3 2008-03-21 allow user to specify the encoding.
 *  1.4 2014-05-17 allow multiple files and dirs on comand line
 */
package com.mindprod.splitter;

import com.mindprod.commandline.CommandLine;
import com.mindprod.common18.EIO;
import com.mindprod.common18.ST;
import com.mindprod.filter.AllButSVNDirectoriesFilter;
import com.mindprod.filter.ExtensionListFilter;
import com.mindprod.hunkio.HunkIO;

import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.Charset;

import static java.lang.System.*;

/**
 * splits files into pieces based on embedded markers.
 * <p/>
 * splits a large file into pieces based on embedded tags in it that tell it where to put the pieces. The &lt;split tags
 * are case-insensitive
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.4 2014-05-17 allow multiple files and dirs on comand line
 * @since 2004
 */
public final class Splitter
    {
    // declarations
    private static final int FIRST_COPYRIGHT_YEAR = 2004;

    /**
     * undisplayed copyright notice
     */
    @SuppressWarnings( { "UnusedDeclaration" } )
    private static final String EMBEDDED_COPYRIGHT =
            "Copyright: (c) 2004-2017 Roedy Green, Canadian Mind Products, http://mindprod.com";

    @SuppressWarnings( { "UnusedDeclaration" } )
    private static final String RELEASE_DATE = "2014-05-17";

    /**
     * syntax of command line
     */
    private static final String USAGE = "\nSplitter.jar -charset=UTF8 [-q] file [file -s dir...]";

    /**
     * embedded version string.
     */
    @SuppressWarnings( { "UnusedDeclaration" } )
    private static final String VERSION_STRING = "1.4";

    /**
     * keeps track of which files have been used previously. If they have, we isAppending.
     */
    private static final FileStack dupsStack = new FileStack();

    /**
     * keeps track of nesting of <split tags
     */
    private static final FileStack stack = new FileStack();

    /**
     * beginning of chunk of text to be processed in big buffer
     */
    private static int fromIndex = 0;

    /**
     * original length of the file we are splitting.
     */
    private static int originalLength = 0;

    /**
     * text of the entire file we are splitting.
     */
    private static String big = null;

    /**
     * encoding of input and output files
     */
    private static Charset cs = null;

    /**
     * the file where we directing stuff not inside tags.
     */
    private static Writer base = null;

    /**
     * the file where we are currently directing the output.
     */
    private static Writer emit = null;
    // /declarations
    // methods

    /**
     * Close the redirect stream.
     *
     * @throws java.io.IOException if close fails.
     */
    private static void close() throws IOException
        {
        // keep the base file open all the elapsedTime.
        if ( emit != base )
            {
            emit.close();
            }
        }// /method

    /**
     * If we have already written to this file before we will isAppending to it rather than overwrite it.
     *
     * @param filename name of a file we are about to write to.
     *
     * @return true if we should isAppending rather than overwrite this file.
     */
    private static boolean isAppending( String filename )
        {
        if ( dupsStack.contains( filename ) )
            {
            return true;
            }
        else
            {
            dupsStack.push( filename );
            return false;
            }
        }// /method

    /**
     * split a single file into pieces, on <split boundaries.
     *
     * @param quiet         true if suppress progress messages
     * @param fileToProcess file to split apart
     */
    private static void processFile( final boolean quiet, File fileToProcess )
        {
        // on entry originalFilename is file, and cs is encoding.
        try
            {
            if ( !quiet )
                {
                out.println( "splitting " + fileToProcess.getAbsolutePath() );
                }
            // create a temp file in the same directory as filename, to hold
            final File baseFile = HunkIO
                    .createTempFile( "temp_", ".tmp", fileToProcess );
            // generate output into a temporary file until we are sure all is
            // ok.
            base = EIO.getBufferedWriter( baseFile, 1024 * 64, cs );
            emit = base;
            big = HunkIO.readEntireFile( fileToProcess, cs );
            originalLength = big.length();
            fromIndex = 0;
            while ( fromIndex < originalLength )
                {
                scan();
                }
            base.close();
            if ( stack.depth() != 0 )
                {
                baseFile.delete();   // temp no longer needed
                throw new IllegalArgumentException(
                        "<split> ... </split> tags do not balance." );
                }
            HunkIO.deleteAndRename( baseFile, fileToProcess );
            }
        catch ( IOException e )
            {
            err.println();
            e.printStackTrace( err );
            err.println( "I/O Exception splitter aborted." );
            err.println();
            }
        }// /method

    /**
     * We just parsed a </split tag process it.
     *
     * @throws java.io.IOException if close fails.
     */
    private static void processSplitEndTag() throws IOException
        {
        close();
        stack.drop();
        redirect( stack.top() );
        }// /method

    /**
     * We just parsed a <split tag, process it.
     *
     * @param filename of file to split up.
     *
     * @throws java.io.IOException if close fails.
     */
    private static void processSplitTag( String filename ) throws IOException
        {
        close();
        stack.push( filename );
        redirect( filename );
        }// /method

    /**
     * redirect output to given file
     *
     * @param filename to redirect output to. null means base.
     *
     * @throws java.io.IOException if write fails
     */
    private static void redirect( String filename ) throws IOException
        {
        if ( filename == null )
            {
            emit = base;
            }
        else
            {
            emit = EIO.getBufferedWriter( new File( filename ), 64 * 1024, isAppending( filename ), cs );
            }
        }// /method

    /**
     * scan for next <split or </split tag, and process it.
     *
     * @throws java.io.IOException if write fails.
     */
    private static void scan() throws IOException
        {
        // scan for next <
        int nextTagIndex = big.indexOf( '<', fromIndex );
        if ( nextTagIndex >= 0 )
            {
            // output stuff ahead of the tag
            squirt( fromIndex, nextTagIndex );
            if ( nextTagIndex + "</split>".length() < originalLength )
                {
                int startFilename = nextTagIndex + "<split ".length();
                if ( big.substring( nextTagIndex + 1, startFilename )
                        .equalsIgnoreCase( "split " ) )
                    {
                    // was <split filename
                    // find > at tail end of filename.
                    int endTag = big.indexOf( '>', startFilename );
                    if ( endTag < 0 )
                        {
                        throw new IllegalArgumentException(
                                "<split xxx missing trailing >." );
                        }
                    String filename = big.substring( startFilename, endTag )
                            .trim();
                    if ( filename.length() <= 0 )
                        {
                        throw new IllegalArgumentException(
                                "<split xxx missing filename." );
                        }
                    fromIndex = endTag + 1;
                    processSplitTag( filename );
                    }
                else if ( big.substring( nextTagIndex + 1,
                        nextTagIndex + "</split>".length() )
                        .equalsIgnoreCase( "/split>" ) )
                    {
                    // was </split>
                    // bypass tag
                    fromIndex = nextTagIndex + "</split>".length();
                    processSplitEndTag();
                    }
                else
                    {
                    // false alarm was not a split tag, some other sort of <tag
                    // process the < as an ordinary data char.
                    squirt( nextTagIndex, nextTagIndex + 1 );
                    fromIndex = nextTagIndex + 1;
                    }
                }
            else
                {
                // must be a false alarm, we are too close to the end
                // process < and subsequent chars as ordinary data
                squirt( nextTagIndex, originalLength );
                fromIndex = originalLength;
                }
            }
        else
            {
            // ran right off the end without finding anything.
            squirt( fromIndex, originalLength );
            fromIndex = originalLength;
            }
        }// /method

    /**
     * write out a chunk of the big array to the current split file
     *
     * @param fromIndex where to start in the big string.
     * @param toIndex   one past where to stop in the big string.
     *
     * @throws java.io.IOException if the write fails.
     */
    private static void squirt( int fromIndex, int toIndex ) throws IOException
        {
        if ( fromIndex < toIndex )
            {
            // actually have something to emit
            emit.write( big.substring( fromIndex, toIndex ) );
            }
        }// /method

    /**
     * split a single file into pieces, on <split boundaries
     *
     * @param args args -charset=UTF8 followed by names of files to split containing embedded <split tags.
     */
    public static void main( String[] args )
        {
        if ( args.length < 1 )
            {
            throw new IllegalArgumentException(
                    "Splitter needs -charset=UTF8 and the names of files/dirs to split on the command line." );
            }
        if ( args.length >= 1 && args[ 0 ].startsWith( "-charset=" ) )
            {
            cs = Charset.forName( ST.chopLeadingString( args[ 0 ], "-charset;" ) );
            args[ 0 ] = null; /* hide from CommandLine */
            }
        else
            {
            cs = Charset.defaultCharset();
            }
        // gather all the files mentioned on the command line.
        // either directories, files, *.*, with -s and subdirs option.
        out.println( "Gathering files to split..." );
        CommandLine commandLine = new CommandLine( args,
                new AllButSVNDirectoriesFilter(),
                new ExtensionListFilter( ExtensionListFilter.COMMON_TEXT_EXTENSIONS ) );
        final boolean quiet = commandLine.isQuiet();
        if ( commandLine.size() == 0 )
            {
            throw new IllegalArgumentException( "No files found to process\n" + USAGE );
            }
        for ( File file : commandLine )
            {
            try
                {
                processFile( quiet, file );
                }
            catch ( Exception e )
                {
                err.println();
                e.printStackTrace( err );
                err.println( " in file "
                             + EIO.getCanOrAbsPath( file ) );
                err.println();
                }
            } // end for
        }// /method
    // /methods
    } // end Splitter