/*
 * [TidyForJars.java]
 *
 * Summary: Tidy/sort files of the form for*.xml.
 *
 * Copyright: (c) 2016-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 2016-06-03 initial version
 */
package com.mindprod.repair;

import com.mindprod.common18.EIO;
import com.mindprod.common18.ST;
import com.mindprod.filter.ClamFilter;
import com.mindprod.filter.OnlyDirectoriesFilter;
import com.mindprod.hunkio.HunkIO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;

import static java.lang.System.*;

/**
 * Tidy/sort files of the form for*.xml.
 * <p/>
 * These files control ANT GenJar, java.exe, copy, zip building ...
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2016-06-03 initial versions
 * @since 2016-06-03
 */
public class TidyForJars
    {
    /**
     * dedup and array list
     *
     * @param a ArrayList of Strings
     */
    private static void deDup( ArrayList<String> a )
        {
        int n = a.size();
        if ( n <= 1 )
            {
            return;
            }
        String prev = a.get( n - 1 ); // last elt
        // work down from second last elt
        for ( int i = n - 2; i >= 0; i-- )
            {
            String here = a.get( i );
            if ( here.equals( prev ) )
                {
                err.println( "dup removed " + here );
                a.remove( i );
                }
            else
                {
                prev = here;
                }
            }
        }

    /**
     * should this line be sorted?
     *
     * @param line from the .xml file
     *
     * @return true if should be sorted
     */
    private static boolean isSortable( String line )
        {
        if ( line.startsWith( "<include" ) )
            {
            if ( !line.substring( line.length() - 10 ).contains( "." ) )
                {
                err.println( "missing .class .png etc. on " + line );
                }
            return true;
            }
        else if ( line.startsWith( "<zipfileset" ) )
            {
            return true;  // to include in zip
            }
        else if ( line.startsWith( "<class" ) )
            {
            return true;
            }
        else if ( line.startsWith( "<!--" ) )
            {
            return false;
            }
        else if ( line.startsWith( "<resource" ) )
            {
            return false;   // genjar surround <include
            }
        else if ( line.startsWith( "<fileset" ) )
            {
            return false;
            }
        else if ( line.startsWith( "</fileset" ) )
            {
            return false;
            }
        else if ( line.startsWith( "</resource" ) )
            {
            return false;
            }
        else if ( line.startsWith( "<library" ) )
            {
            return false;
            }
        else if ( line.startsWith( "</class" ) )
            {
            return false;
            }
        else if ( line.startsWith( "<delete" ) )
            {
            return false;
            }
        else if ( line.startsWith( "</delete" ) )
            {
            return false;
            }
        else if ( line.startsWith( "<copy" ) )
            {
            return false;  // in forpost
            }
        else
            {
            err.println( "not categorisable " + line );
            return false;
            }
        }

    /**
     * read and sort one file
     *
     * @param toTidy file to process
     * @param dry    true if this is a dry run
     */
    private static void readAndSortFile( final File toTidy, final boolean dry )
        {
        try
            {
            // O P E N
            final FileReader fr = new FileReader( toTidy );
            final BufferedReader br = new BufferedReader( fr, 16_384 /* 32K bytes/16K chars, 50% of 64K byte allocation is optimal */ );
            ArrayList<String> toSort = new ArrayList<>( 200 );
            ArrayList<String> sorted = new ArrayList<>( 200 );
            String line;
            // R E A D.
            while ( ( line = br.readLine() ) != null )
                {
                line = line.trim();
                if ( ST.isEmpty( line ) )
                    {
                    continue;
                    }
                if ( isSortable( line ) )
                    {
                    toSort.add( "  " + line );  // indented
                    }
                else
                    {
                    if ( toSort.size() > 0 )
                        {
                        Collections.sort( toSort );
                        sorted.addAll( toSort );
                        toSort.clear();
                        }
                    sorted.add( line );
                    }
                }
            br.close();
            // process the last batch of lines to sort if any.
            if ( toSort.size() > 0 )
                {
                Collections.sort( toSort );
                sorted.addAll( toSort );
                toSort.clear();
                deDup( sorted );
                }
            // display sorted file
            for ( String elt : sorted )
                {
                out.println( elt );
                }
            if ( !dry )
                {
                writeBackSortedFile( toTidy, sorted );
                }
            }
        catch ( IOException e )
            {
            out.println( "IO Failure on " + EIO.getCanOrAbsPath( toTidy ) + " " + e.getMessage() );
            }
        //  sort alphabeticall except <fileset goes to top and </fileset goes to end.
        }

    /**
     * @param toTidy file to write
     * @param sorted data to write
     *
     * @throws IOException
     */
    private static void writeBackSortedFile( final File toTidy, final ArrayList<String> sorted ) throws IOException
        {
        // write sorted stuff back out, to temp file, then rename.
        // O P E N
        final File tempFile = HunkIO.createTempFile( "temp_", ".tmp", toTidy );
        final FileWriter fw = new FileWriter( tempFile, false /* append */ );
        final BufferedWriter bw = new BufferedWriter( fw, 16_384 /* 32K bytes/16K chars, 50% of 64K byte allocation is optimal */ );
        final PrintWriter prw = new PrintWriter( bw, false /* auto flush on println */ );
        // W R I T E
        for ( String line : sorted )
            {
            prw.println( line );
            }
        prw.close();
        HunkIO.deleteAndRename( tempFile, toTidy );
        }

    /**
     * only parm is -dry
     */
    public static void main( String[] args )
        {
        final boolean dry = ( args.length > 0 && args[ 0 ].equals( "-dry " ) );
        final ClamFilter clamFilter = new ClamFilter( "for", ".xml" );
        final File base = new File( "E:/com/mindprod" );
        final String[] dirs = base.list( new OnlyDirectoriesFilter() );
        for ( String dir : dirs )
            {
            final String[] files = new File( base, dir ).list( clamFilter );
            for ( String file : files )
                {
                final File toTidy = new File( new File( base, dir ), file );
                out.println( EIO.getCanOrAbsPath( toTidy ) );
                readAndSortFile( toTidy, dry );
                }
            }
        }
    }