/*
 * [RefreshInserts.java]
 *
 * Summary: Refresh Insert/Cite with latest descriptions/prices.
 *
 * Copyright: (c) 2013-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 2013-02-03 initial version
 */
package com.mindprod.stores;

import com.mindprod.common18.EIO;
import com.mindprod.common18.Misc;
import com.mindprod.fastcat.FastCat;
import com.mindprod.filter.ExtensionListFilter;
import com.mindprod.htmlmacros.macro.Global;
import com.mindprod.htmlmacros.support.ConfigurationForMindprod;
import com.mindprod.hunkio.HunkIO;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.System.*;

/**
 * Refresh Insert/Cite with latest descriptions/prices.
 * <p/>
 * <br>
 * Refreshes title and price on Cite and Insert macro from ElectronicsHead, BookHead.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2013-02-03 initial version
 * @since 2013-02-03
 */
public class RefreshInserts
    {
    // TidyBookMacros: reflow Book macros.  Update BookHead with recent title and published. Add missing published to BookHead.
    // RefreshInserts: refresh data on Insert macros from book page. Add missing published to book Insert.
    // InsertBookMarkers: put <!-- +++ --> between books to make it easier to sort.  One shot.
    // SortBooks: sort book Inserts on page so most recently published are first.
    // ProofreadInserts: check that sort worked.

    /**
     * true to get extra output
     */
    private static final boolean DEBUGGING = false;

    /**
     * pieces used to compose regexes
     */
    private static final String BRACE_GROUP = "\\s+\\{([\\p{Alnum} \\n!-@\\[-_\\|~]*)\\}";

    private static final String IGNORED_PRICE = "(?:\\s+[\\$\\.,0-9]+)?";

    private static final String MACRO = "<!\\-\\-\\s+macro";

    // allow optional {}
    private static final String MANDATORY_PRICE = "\\s+\\{?([\\$\\.,0-9]+)\\}?";

    // published date in book head
    private static final String PUBLISHED = "\\spublished=([\\d\\-]+)";

    private static final String PARTNO = "\\s+([\\p{Alnum}]+)";

    private static final String TAIL = "\\s+\\-\\->";

    /**
     * find BookHead macro
     */
    private static final Pattern FIND_BOOK_HEAD = Pattern.compile( MACRO + "\\s+BookHead" + BRACE_GROUP + PUBLISHED +
                                                                   TAIL );

    /**
     * find Cite macro
     */
    private static final Pattern FIND_CITE = Pattern.compile( MACRO + "\\s+Cite" + PARTNO + BRACE_GROUP + TAIL );

    /**
     * find DVDHead macro
     */
    private static final Pattern FIND_DVD_HEAD = Pattern.compile( MACRO + "\\s+DVDHead" + BRACE_GROUP + TAIL );

    /**
     * find ElectronicHead macro
     */
    private static final Pattern FIND_ELECTRONIC_HEAD = Pattern.compile( MACRO + "\\s+ElectronicHead" + BRACE_GROUP +
                                                                         MANDATORY_PRICE + TAIL );

    /*
     * find Insert macro
     */
    private static final Pattern FIND_INSERT = Pattern.compile( MACRO + "\\s+Insert"
                                                                + PARTNO + BRACE_GROUP + IGNORED_PRICE + TAIL );

    /**
     * which dirs we scan of Insert and Cite macros
     */
    private static List<String> dirsToProcess;

    /**
     * dir where Book macros are kept.
     */
    private static File bookDir;

    /**
     * dir where DVD macros are kept.
     */
    private static File dvdDir;

    /**
     * dir where electronic macros are kept in files of form B0057A5RA6.html
     */
    private static File electronicDir;

    /**
     * webrootDir directory of website
     */
    private static File webrootDir;

    /**
     * scan file contents for <!-- macro Insert
     *
     * @param big  contents of file
     * @param file file, used only for error messages. does not touch file
     *
     * @return tidied text
     */
    private static String scanForCiteMacros( String big, File file ) throws IOException
        {
        // where we collect the replacement. Must be a StringBuffer, not a StringBuilder. Regex has a legacy problem.
        final StringBuffer sb = new StringBuffer( big.length() + 200 );
        final Matcher m = FIND_CITE.matcher( big );  // Matchers are used both for matching and finding.
        while ( m.find() )
            {
            assert m.groupCount() == 2 : "Missing groups " + m.groupCount() + " " + m.group( 0 );
            String partNo = m.group( 1 );
            String desc = m.group( 2 );
            switch ( partNo.length() )
                {
                case 10:
                    // asin
                    final File eMaster = new File( electronicDir, partNo + ".html" );
                    final String eContents = HunkIO.readEntireFile( eMaster );
                    final Matcher e = FIND_ELECTRONIC_HEAD.matcher( eContents );
                    if ( !e.find() )
                        {
                        err.println( "Missing ElectronicsHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = e.group( 1 );
                    break;
                case 12:
                    // upc
                    final File dMaster = new File( dvdDir, partNo + ".html" );
                    final String dContents = HunkIO.readEntireFile( dMaster );
                    final Matcher d = FIND_DVD_HEAD.matcher( dContents );
                    if ( !d.find() )
                        {
                        err.println( "Missing DVDHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = d.group( 1 );
                    break;
                case 13:
                    // isbn
                    final File bMaster = new File( bookDir, partNo + ".html" );
                    final String bContents = HunkIO.readEntireFile( bMaster );
                    final Matcher b = FIND_BOOK_HEAD.matcher( bContents );
                    if ( !b.find() )
                        {
                        err.println( "Missing BookHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = b.group( 1 );
                    break;
                default:
                    err.println( "Invalid Cite number " + partNo + " in " + EIO.getCanOrAbsPath( file ) );
                }
            final String replacement = "<!-- macro Cite " + partNo + " {" + desc + "} -->";
            m.appendReplacement( sb, Matcher.quoteReplacement( replacement ) );
            }
        m.appendTail( sb );
        return sb.toString();
        }

    /**
     * scan file contents for <!-- macro Insert
     *
     * @param big  contents of file
     * @param file file, used only for error messages. does not touch file
     *
     * @return tidied text
     */
    private static String scanForInsertMacros( String big, File file ) throws IOException
        {
        // where we collect the replacement. Must be a StringBuffer, not a StringBuilder. Regex has a legacy problem.
        final StringBuffer sb = new StringBuffer( big.length() + 200 );
        final Matcher m = FIND_INSERT.matcher( big );  // Matchers are used both for matching and finding.
        while ( m.find() )
            {
            String partNo = m.group( 1 );
            String desc = m.group( 2 );
            String price = "";
            String published = "";
            switch ( partNo.length() )
                {
                case 10:
                    // asin
                    final File eMaster = new File( electronicDir, partNo + ".html" );
                    final String eContents = HunkIO.readEntireFile( eMaster );
                    final Matcher e = FIND_ELECTRONIC_HEAD.matcher( eContents );
                    if ( !e.find() )
                        {
                        err.println( "Missing ElectronicsHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = e.group( 1 );
                    price = e.group( 2 );
                    break;
                case 12:
                    // upc
                    final File dMaster = new File( dvdDir, partNo + ".html" );
                    final String dContents = HunkIO.readEntireFile( dMaster );
                    final Matcher d = FIND_DVD_HEAD.matcher( dContents );
                    if ( !d.find() )
                        {
                        err.println( "Missing DVDHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = d.group( 1 );
                    break;
                case 13:
                    // isbn
                    final File bMaster = new File( bookDir, partNo + ".html" );
                    final String bContents = HunkIO.readEntireFile( bMaster );
                    final Matcher b = FIND_BOOK_HEAD.matcher( bContents );
                    if ( !b.find() )
                        {
                        err.println( "Missing BookHead " + partNo );
                        System.exit( 2 );
                        }
                    desc = b.group( 1 );
                    published = b.group( 2 );
                    break;
                default:
                    err.println( "Invalid insert number " + partNo + " in " + EIO.getCanOrAbsPath( file ) );
                }
            FastCat r = new FastCat( 10 );
            r.append( "<!-- macro Insert ", partNo );
            r.append( " {", desc, "}" );
            if ( price.length() > 0 )
                {
                r.append( " ", price );
                }
            if ( published.length() > 0 )
                {
                r.append( " published=", published );
                }
            r.append( " -->" );
            final String replacement = r.toString();
            m.appendReplacement( sb, Matcher.quoteReplacement( replacement ) );
            }
        m.appendTail( sb );
        return sb.toString();
        }

    /**
     * copy from BookHead to Insert.
     *
     * @param args not used
     *
     * @throws java.io.IOException if trouble reading or writing files containing Book macros.
     */
    public static void main( String[] args ) throws IOException
        {
        Global.installConfiguration( new ConfigurationForMindprod() );
        // combine dirsWithMacros and dirsWithIncludes into dirsToProcess;
        final List<String> a = Global.configuration.getDirsContainingHTMLMacros();
        final List<String> b = Global.configuration.getDirsContainingIncludes();
        dirsToProcess = new ArrayList<>( a.size() + b.size() );
        dirsToProcess.addAll( a );
        dirsToProcess.addAll( b );
        webrootDir = new File( Global.configuration.getLocalWebrootWithSlashes() );
        electronicDir = new File( webrootDir, "electronic" );
        bookDir = new File( webrootDir, "book" );
        dvdDir = new File( webrootDir, "dvd" );
        if ( DEBUGGING )
            {
            out.println( FIND_INSERT );
            out.println( FIND_CITE );
            out.println( FIND_BOOK_HEAD );
            out.println( FIND_DVD_HEAD );
            out.println( FIND_ELECTRONIC_HEAD );
            }
        for ( String dirname : dirsToProcess )
            {
            final File dir = new File( webrootDir, dirname );
            // out.println("Processing " + dir );
            final String[] filenames = dir.list( new ExtensionListFilter( "html" ) );
            for ( String filename : filenames )
                {
                final File file = new File( dir, filename );
                final String big = HunkIO.readEntireFile( file, HunkIO.UTF8 );
                final String big2 = scanForInsertMacros( big, file );
                final String big3 = scanForCiteMacros( big2, file );
                if ( !big3.equals( big ) )
                    {
                    out.println( "refreshing: " + EIO.getCanOrAbsPath( file ) );
                    HunkIO.writeEntireFile( file, big3 );
                    }
                } // end scan  all files in dir
            } // end scan all dirs.
        Misc.trackLastThread();
        System.exit( 0 );
        } // end main
    }