/*
 * [MoveQuotes.java]
 *
 * Summary: Move quotations from one file to another. Moved quotes are tacked on the front, and removed from the from the sounce file.
 *
 * Copyright: (c) 2015-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.0 2015-12-30 initial version
 */
package com.mindprod.htmlmacros;

import com.mindprod.fastcat.FastCat;
import com.mindprod.hunkio.HunkIO;

import java.io.File;
import java.io.IOException;

import static java.lang.System.*;

/**
 * Move quotations from one file to another. Moved quotes are tacked on the front, and removed from the from the sounce file.
 * <p/>
 * Does not check for duplicates.  Works best with StripGenerated files.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2015-12-30 initial version
 * @since 2015-12-30
 */
public class MoveQuotes
    {
    /**
     * what we look for surrounding text of interest
     */
    private static final String CLOSE_TAG = "</blockquote>";

    /**
     * what we look for surrounding text of interest
     */
    private static final String OPEN_TAG = "<blockquote";

    /**
     * accumulate new from file
     */
    private static final FastCat fromSb = new FastCat( 10_000 );

    /**
     * accumulate new to file
     */
    private static final FastCat toSb = new FastCat( 10_000 );

    /**
     * final count of quotes is from file
     */
    private static int fromCount = 0;

    /**
     * final count of quotes in to file
     */
    private static int toCount = 0;

    /**
     * count of quotes moved from to to
     */
    private static int moveCount = 0;

    /**
     * original contents of from file
     */
    private static String fromBig;

    /**
     * original conents of to file
     */
    private static String toBig;

    /**
     * from file
     */
    private static File fromFile;

    /**
     * to file
     */
    private static File toFile;

    /**
     * handle the footer for the from file
     */
    private static void handleFromPostlude( final boolean dry ) throws IOException
        {
        final int p = fromBig.lastIndexOf( "<!-- macro Foot" );
        if ( p < 0 )
            {
            err.println( "Fatal error: Missing <!-- macro Foot in " + fromFile );
            System.exit( 2 );
            }
        fromSb.append( fromBig.substring( p ) );
        if ( !dry )
            {
            HunkIO.writeEntireFile( fromFile, fromSb.toSeparatedList( '\n' ) );
            }
        }

    /**
     * @param fromFilename name of from file contanining quotes
     *
     * @throws IOException
     */
    private static void handleFromPrelude( final String fromFilename ) throws IOException
        {
        fromFile = new File( fromFilename );
        if ( !fromFile.canWrite() )
            {
            err.println( "Fatal error: missing write access to " + fromFile );
            System.exit( 2 );
            }
        fromBig = HunkIO.readEntireFile( fromFile );
        int p = fromBig.indexOf( OPEN_TAG );
        if ( p < 0 )
            {
            err.println( "Fatal error: Missing <blockquote in " + fromFile );
            System.exit( 2 );
            }
        final String fromPrelude = fromBig.substring( 0, p );
        fromSb.append( fromPrelude );
        }

    /**
     * copy some of the quotes in from file to the to file, ones containing word
     */
    private static void handleFromQuotes( final String word )
        {
        int start0 = 0;
        int start1;
        while ( ( start1 = fromBig.indexOf( OPEN_TAG, start0 ) ) >= 0 )
            {
            final int start2 = start1 + OPEN_TAG.length();
            final int end1 = fromBig.indexOf( CLOSE_TAG, start2 );
            if ( end1 < 0 )
                {
                throw new IllegalArgumentException( ">>>missing </blockquote>" );
                }
            final int end2 = end1 + CLOSE_TAG.length();
            final String rawBlockQuote = fromBig.substring( start1, end2 );
            final String lc = rawBlockQuote.toLowerCase();
            if ( lc.contains( word ) )
                {
                // copy the quote, drop it from from
                toSb.append( rawBlockQuote );
                toCount++;
                moveCount++;
                }
            else
                {
                // keep quote in from
                fromSb.append( rawBlockQuote );
                fromCount++;
                }
            start0 = end2;
            } // end while
        }

    /**
     * handle the footer for the to file
     */
    private static void handleToPostlude( final boolean dry ) throws IOException
        {
        final int p = toBig.lastIndexOf( "<!-- macro Foot" );
        if ( p < 0 )
            {
            err.println( "Fatal error: Missing <!-- macro Foot in " + toFile );
            System.exit( 2 );
            }
        toSb.append( toBig.substring( p ) );
        if ( !dry )
            {
            HunkIO.writeEntireFile( toFile, toSb.toSeparatedList( '\n' ) );
            }
        }

    /**
     * @param toFilename name of to file contanining quotes
     *
     * @throws IOException
     */
    private static void handleToPrelude( final String toFilename ) throws IOException
        {
        toFile = new File( toFilename );
        if ( !toFile.canWrite() )
            {
            err.println( "Fatal error: missing write access to " + toFile );
            System.exit( 2 );
            }
        toBig = HunkIO.readEntireFile( toFile );
        int p = toBig.indexOf( OPEN_TAG );
        if ( p < 0 )
            {
            err.println( "Fatal error: Missing <blockquote in " + toFile );
            System.exit( 2 );
            }
        final String toPrelude = toBig.substring( 0, p );
        toSb.append( toPrelude );
        }

    /**
     * handle existing quotes in to file
     */
    private static void handleToQuotes()
        {
        int start0 = 0;
        int start1;
        while ( ( start1 = toBig.indexOf( OPEN_TAG, start0 ) ) >= 0 )
            {
            final int start2 = start1 + OPEN_TAG.length();
            final int end1 = toBig.indexOf( CLOSE_TAG, start2 );
            if ( end1 < 0 )
                {
                throw new IllegalArgumentException( ">>>missing </blockquote>" );
                }
            final int end2 = end1 + CLOSE_TAG.length();
            final String rawBlockQuote = toBig.substring( start1, end2 );
            toSb.append( rawBlockQuote );
            toCount++;
            start0 = end2;
            } // end while
        }

    /**
     * Move quotes in from file to the to file that contain a given word, case insensitive.
     *
     * @param args from-file to-file word
     *
     * @throws IOException if cannot read quotations
     */
    public static void main( String[] args ) throws IOException
        {
        boolean dry = args.length > 3 && args[ 3 ].equals( "-dry" );
        out.println( "Moving quotes from " + args[ 0 ] + " to " + args[ 1 ] + " if they contain the string " + args[ 2 ] );
        if ( dry )
            {
            out.println( "Just a dry run. No files will be modified." );
            }
        handleFromPrelude( args[ 0 ] );
        handleToPrelude( args[ 1 ] );
        handleFromQuotes( args[ 2 ].toLowerCase() );
        handleToQuotes();
        handleFromPostlude( dry );
        handleToPostlude( dry );
        out.println( fromCount + " quotes in " + fromFile );
        out.println( toCount + " quotes in " + toFile );
        out.println( moveCount + " quotes moved from " + fromFile + " to " + toFile );
        }
    }