/*
 * [Include.java]
 *
 * Summary: Implements Include macro.
 *
 * Copyright: (c) 2009-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.8 2009-02-06 include go package in ZIP bundle.
 *  1.9 2011-11-21 fileBeingProcessed is now an instance variable rather than a parm.
 */
package com.mindprod.htmlmacros.macro;

import com.mindprod.compactor.Compactor;
import com.mindprod.fastcat.FastCat;
import com.mindprod.htmlmacros.Replacer;
import com.mindprod.htmlmacros.support.LoadCodeToProcessMacro;
import com.mindprod.htmlmacros.support.ParmParser;
import com.mindprod.htmlmacros.support.Tools;
import com.mindprod.hunkio.HunkIO;

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

import static com.mindprod.htmlmacros.macro.Global.configuration;
import static java.lang.System.*;

/**
 * Implements Include macro.
 * <p/>
 * Expands HTML boilerplate  macro that simply include from another file e.g. &lt;!-- macro Include dogs.txt
 * --&gt;<br> &lt;!-- generated--&gt;<br> <img src=&quot;image/animals/dog.jpg&quot; height=&quot;410&quot;
 * width=&quot;511&quot; alt=&quot;dog&quot;><br> &lt;!-- /generated by Include --&gt;<br> It is not this class's duty
 * to create the generated and /generated comment tags, just the material between them.<br> This code is like a stripped
 * down version of Replacer. We don't have the complications of:<ol> <li>fixing line separators</li> <li>Deciding
 * whether to compact or not. We don't. Replacer does it for us.</li> <li>Tracking whether to abort. We just throw an
 * exception.</li> <li>Tracking whether this expansion is different from the existing expansion.</li> <li>Writing out
 * the results to disk.</li></ol>
 * <p/>
 * Included macro text may be compact or not, and may contain leading or trailing whitespace.
 * Replacer deals with COMPACTING if necessary. We pass expansion on without compacting.
 * Macros in included text will be expanded, but the macros themselves and the <!-- generated are stripped.
 * Includes may be nested. Included comments are currently stripped by Compactor. Other commends are stripped
 * my char-by-char logic.
 * <p>There is only one Include object even with nested includes. Recursion is handled purely with local variables
 * on the stack.</p>
 * <p/>
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.9 2011-11-21 fileBeingProcessed is now an instance variable rather than a parm.
 * @noinspection WeakerAccess
 * @since 2009
 */
public final class Include extends Macro
    {
    /** how to use the macro */
    /**
     * how to use the macro
     */
    private static final String USAGE = "\nInclude macro needs uPathFilename to include.";

    /**
     * 0 = no include, 1 = processing include text, 2 = processing text included from included text ...
     */
    private static int nestingDepth;

    /**
     * which file we processed last.  Used to detect start of processing a new file
     */
    private static File prevFileBeingProcessed;

    /**
     * where generated HTML is appended
     */
    private FastCat emit;

    /**
     * array of parameters to macro.
     */
    private String[] parms;

    /**
     * the chunk we are processing now.
     */
    private String chunk;

    /**
     * name of macro we are processing.
     */
    private String macroName;

    /**
     * The string representing the original file image we are processing.
     * Each layer of include will have a different Include object with its own copy of original, chunk etc.
     */
    private String original;

    /**
     * offset in chars we have so far processed the file image. offset is an instance variable. In Replacer, it is
     * static.
     */
    private int offset;

    /**
     * length of the original input string before any processing.
     */
    private int originalLength;

    /**
     * Process included text in ram , may have macros and further includes in it.
     * Must set up files first to define what page links included are relative to.
     *
     * @param textToInclude     html fragment to include.
     * @param whereTextCameFrom where the included text came from.
     * @param maxFastCatSlots   how many slots to use to concatenate macro expansions in included text
     * @param checkEstimate     true if want a check on how good the FastCat size estimate was.
     * @param quiet             true if should suppress progress messages.
     * @param verbose           true if want progress log.
     *
     * @return expanded text
     * @throws ClassNotFoundException if can't find macro, or code does not implement Macro.
     * @throws IllegalAccessException if missing public access
     * @throws InstantiationException if missing no-arg constructor.
     */
    String includeStringGuts( final String textToInclude,
                              final String whereTextCameFrom,
                              final int maxFastCatSlots,
                              final boolean checkEstimate,
                              final boolean quiet,
                              final boolean verbose
    )
            throws ClassNotFoundException, IllegalAccessException, InstantiationException
        {
        original = textToInclude;
        originalLength = original.length();
        // will throw IllegalArgumentException if problems.
        Replacer.verifyGeneratedTags( original, fileBeingProcessed );
        // start processing at the first character.
        offset = 0;
        macroName = null;
        // similar logic to Replacer except we do not generate any <generate </generated,
        // (other than the outermost pair).
        /// We expandNoRef macros and throw away old generated stuff in one pass.
        // logic is similar to Replacer.processFile
        // each layer of include gets its own Include object, hence copy of emit.
        // allow for macros in included file to expandNoRef.
        // Create a buffer big enough for text to include, plus expansions.
        emit = new FastCat( maxFastCatSlots );
        emit.setWhereTextCameFrom( "Include " + whereTextCameFrom );
        boolean copy = true;
        // loop for each fragment
        while ( true )
            {
            // scan for beginning of next comment
            if ( scan( "<!-- ", false ) )
                {
                // we found the start of a comment.
                if ( copy )
                    {
                    emit.append( chunk );
                    }
                // bypass the initial <!--
                scan( "<!-- ", true );
                String command = nextWord();
                if ( command.equals( "macro" ) )
                    {
                    // handles scanning to -->
                    parseAndExpandMacro( quiet, verbose );
                    }
                else if ( command.equals( "generated" ) )
                    {
                    // delete generated through /generated, for any macro
                    if ( scan( "-->", true ) )
                        {
                        copy = false;
                        }
                    else
                        {
                        throw new IllegalArgumentException( "Syntax error: <!-- generated." );
                        }
                    }
                else if ( command.equals( "/generated" ) )
                    {
                    if ( scan( "-->", true ) )
                        {
                        copy = true;
                        }
                    else
                        {
                        throw new IllegalArgumentException(
                                "Syntax error: <!-- generated" );
                        }
                    }
                else
                    {
                    // just ordinary comment, treat it like other HTML text.
                    if ( scan( "-->", true ) )
                        {
                        if ( copy )
                            {
                            emit.append( "<!-- " );
                            emit.append( chunk );
                            }
                        }
                    else
                        {
                        throw new IllegalArgumentException(
                                "Syntax error: missing -->" );
                        }
                    }
                }
            else
                {
                // no more comments, just copy tail and we are done.
                if ( copy )
                    {
                    // tail end
                    assert 0 <= offset && offset <= originalLength;
                    emit.append( original.substring( offset ) );
                    }
                break;
                }
            } // end while
        // might shrink if not compact to start.
        if ( checkEstimate )
            {
            emit.checkEstimate();
            }
        return emit.toString();
        }

    /**
     * Scan from the current offset looking for the next word (delimited by white space) It does not modify chunk or
     * offset.
     *
     * @return next word in original starting at offset.
     */
    private String nextWord()
        {
        // we want to avoid creating needless substrings that could
        // be very long, so we process char by char.
        boolean inLeading = true;
        int start = offset;
        for ( int i = offset; i < originalLength; i++ )
            {
            if ( Character.isWhitespace( original.charAt( i ) ) )
                {
                if ( inLeading )
                    {
                    start = i + 1;
                    }
                else
                    {
                    return original.substring( start, i/* one past end */ );
                    }
                }
            else
                {
                inLeading = false;
                }
            } // end for
        return ( original.substring( start ) );
        } // end nextWord

    /**
     * process a macro or nested include of the form: <!-- macro Include dogs.txt -->
     *
     * @param quiet   true if want progress messages suppressed
     * @param verbose true if want progress log.
     *
     * @throws ClassNotFoundException if can't find macro, or code does not implement Macro.
     * @throws IllegalAccessException if missing public access
     * @throws InstantiationException if missing no-arg constructor.
     */
    private void parseAndExpandMacro( final boolean quiet, final boolean verbose ) throws
            ClassNotFoundException,
            IllegalAccessException,
            InstantiationException
        {
        // we found something of the form:
        // <!-- macro Include dogs.txt -->
        // we have parsed up to but not including the word macro
        // parse out the various sections.
        // has to be ok, since we already found it.
        scan( "macro", true );
        macroName = nextWord();
        // at worst would be empty name
        scan( macroName, true );
        if ( !scan( "-->", false ) )
            {
            throw new IllegalArgumentException(
                    "syntax error missing --> to close macro." );
            }
        // text between macro and -->
        parms = ParmParser.parseParms( chunk.trim() );
        // has to be ok, since already found it earlier
        scan( "-->", true );
        // we remove the <!-- macro since we have handled it. We don't pass it
        // along to be reprocessed by higher levels.
        // get the Macro-implementing class instance that will process the macro.
        // It implement the Macro interface with the expandNoRef method.
        // Hopefully already loaded from previous use.  Will throw exception on trouble. Should not return null.
        Macro macroDelegate = LoadCodeToProcessMacro.getMacroProcessorInstance( macroName );
        assert macroDelegate != null : "null delegate to process macro " + macroName;
        // Tell the macro the source and target files.  It does not need to read/write them,
        // but it may need to know them.
        macroDelegate.setFileBeingProcessedAndFileBeingDistributed( fileBeingProcessed, fileBeingDistributed );
        // don't emit <!-- generated for any macro in include text, or at recursive depth.
        // invoke the specific macro processor, getting it to expandNoRef
        // tell it the filename, not so that it can read it, but so that it
        // can use its names in the generation of the macro.
        // E X P A N D _ T H E _M A C R O !
        // possibly recursively
        emit.append( macroDelegate.expandMacro( parms, quiet, verbose ) );
        // We don't add /generated. replacer handles that for outermost include only.
        // we don't compact or insert line esparators yet
        } // end parseAndExpandMacro

    /**
     * Scan original looking for the lookFor string, starting at offset.<br> It leaves the material prior to what was
     * sought in chunk. It updates the offset to point either before or after the lookFor string.
     *
     * @param lookFor String to search for. Not a regex.
     * @param after   true if scan to char after the lookFor String <br> false, leave offset pointing to beginning of
     *                the lookFor string.
     *
     * @return true if successful.
     */
    @SuppressWarnings( { "BooleanMethodNameMustStartWithQuestion" } )
    private boolean scan( final String lookFor, final boolean after )
        {
        int where = original.indexOf( lookFor, offset );
        if ( where < 0 )
            {
            // did not find it
            chunk = null;
            return false;
            }
        if ( after )
            {
            where += lookFor.length();
            }
        chunk = original.substring( offset, where );
        offset = where;
        return true;
        } // end scan

    /**
     * Display macro name and parms on error.
     *
     * @return parms as a human-readable string.
     */
    private String showParms()
        {
        // macroName and parms may be null.
        if ( macroName == null )
            {
            macroName = "?";
            }
        final FastCat sb = new FastCat( parms != null ? parms.length * 3 + 4 : 4 );
        sb.append( "    <!-- macro " );
        sb.append( macroName );
        sb.append( '\n' );
        if ( parms != null )
            {
            for ( String parm : parms )
                {
                sb.append( "      {" );
                sb.append( parm );
                sb.append( "}\n" );
                }
            }
        sb.append( "    -->" );
        return sb.toString();
        }

    public static void clearNestingDepth()
        {
        nestingDepth = 0;
        }

    /**
     * Generate macro expansion for Include macro, recursively expands macros including other includes. This is what
     * replacer calls start the possibly nested include process off.
     *
     * @param parms   parsed params for the macro, in this case just "filename".
     * @param quiet   true if want output suppressed.
     * @param verbose @return expanded macro HTML
     *
     * @return text included from some file as result of this macro.
     */
    public final String expandMacro( final String[] parms, final boolean quiet, final boolean verbose )
        {
        if ( !quiet )
            {
            // indicate we handled an include macro on the console
            out.print( "I" );
            }
        if ( !fileBeingProcessed.equals( prevFileBeingProcessed ) )
            {
            nestingDepth = 0;
            prevFileBeingProcessed = fileBeingProcessed;
            }
        if ( parms.length != 1 )
            {
            throw new IllegalArgumentException( USAGE );
            }
        final String includedFile = parms[ 0 ].replace( '\\', '/' );
        // <!-- generated will be appended by Replacer
        final File where = new File( configuration.getLocalWebrootWithSlashes() + "/" + includedFile );
        final String uncompacted = includeFile( new File( configuration.getLocalWebrootWithSlashes() + "/" + includedFile ),
                quiet,
                verbose );
        // strip macros and comments
        return Compactor.compactStringStrippingMacrosAndComments( uncompacted, where.getPath() );
        } // end expandNoRef

    /**
     * guts of Include expansion, also used by JGlossHead to include caveat files.
     * Must set up files first.
     *
     * @param fileToInclude fully qualified filename to include.
     * @param quiet         true if should display status about included includes
     * @param verbose       true if want progress log.
     *
     * @return included HTML.
     */
    public String includeFile( final File fileToInclude, final boolean quiet, final boolean verbose )
        {
        assert fileToInclude != null : "null includedFile";
        assert fileBeingProcessed != null : "null fileBeingProcessed";
        try
            {
            // we are not worrying about \r \n here.   It will be handled later in Replacer.
            final String textToInclude = HunkIO.readEntireFile( fileToInclude );
            final int maxFastCatSlotsForIncludedFile = Replacer.estimateFastCatSlots( textToInclude );
            return includeStringGuts( textToInclude,
                    Tools.uPathName( fileToInclude ),
                    maxFastCatSlotsForIncludedFile,
                    true
                    /* check */,
                    quiet,
                    verbose );
            }
        catch ( IOException e )
            {
            throw new IllegalArgumentException( "error: unable to find file "
                                                + fileToInclude
                                                + " to include." );
            }
        catch ( IndexOutOfBoundsException e )
            {
            e.printStackTrace( err );
            throw new IllegalArgumentException(
                    "IndexOutOfBoundsException possibly a FastCat overflow"
                    + e.getMessage()
                    + "\n"
                    + "near offset "
                    + offset
                    + " in an included file "
                    + fileToInclude
                    + "\n"
                    + showParms()
            );
            }
        catch ( Throwable e )
            {
            e.printStackTrace( err );
            throw new IllegalArgumentException( e.getMessage()
                                                + "\n"
                                                + "near offset "
                                                + offset
                                                + " in an included file "
                                                + fileToInclude
                                                + "\n"
                                                + showParms() );
            }
        }

    /**
     * process included text in ram , may have macros and further includes in it.
     * must set up files first to define what page links included are relative to.
     *
     * @param textToInclude     html fragment to include.
     * @param whereTextCameFrom where the included text came from.
     * @param maxFastCatSlots   how many slots to use to concatenate macro expansions in included text
     * @param quiet             true if should suppress progress messages.
     * @param verbose           true if want progress log.
     * @param checkEstimate     true if want a FastCat check on how good the size estimate was
     *
     * @return expanded text
     */
    public String includeString( final String textToInclude,
                                 final String whereTextCameFrom,
                                 final int maxFastCatSlots,
                                 final boolean checkEstimate,
                                 final boolean quiet,
                                 final boolean verbose
    )
        {
        assert fileBeingProcessed != null : "null fileBeingProcessed";
        try
            {
            // we are not worrying about \r \n here.   It will be handled later in Replacer.
            return includeStringGuts( textToInclude,
                    whereTextCameFrom,
                    maxFastCatSlots,
                    checkEstimate,
                    quiet,
                    verbose );
            }
        catch ( IndexOutOfBoundsException e )
            {
            throw new IllegalArgumentException(
                    "Index out of bounds, probable missing parm or FastCat overflow"
                    + "\n"
                    + e.getMessage()
                    + "\n"
                    + "near offset "
                    + offset
                    + " in "
                    + whereTextCameFrom
                    + "\n"
                    + showParms()
            );
            }
        catch ( Throwable e )
            {
            e.printStackTrace( err );
            throw new IllegalArgumentException( e.getMessage()
                                                + "\n"
                                                + "near offset "
                                                + offset
                                                + " in "
                                                + whereTextCameFrom
                                                + "\n"
                                                + showParms() );
            }
        }
    }