// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.util;

import java.io.*;

import org.litesoft.commonfoundation.interators.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

public abstract class AbstractFileAR
{
    private static final Character DIR_MOVED = 'O';
    private static final Character FILE_MOVED = 'o';
    private static final Character FILE_UPDATED = 'u';
    private static final Character FILE_COPY_ADDED = 'n';
    private static final Character SILENT_THRESHOLD = '.';

    private void showHelp()
    {
        System.out.println( "Requires a minimum of 4 parameters:" );
        System.out.println();
        System.out.println( "   1) Source Directory Path" );
        System.out.println( "   2) Destination Directory Path" );
        System.out.println( "   3) Path for Extra files that match the Pattern found in the Destination Path" );
        System.out.println( " 4-n) File Pattern (e.g. \\\\*PO.java - only '*' supported)" );
        System.out.println();
        System.out.println( "Note: The \\\\ before each File Pattern keeps both your shell AND Java from expanding the pattern based on the current directory" );
        System.exit( 1 );
    }

    private boolean mCleanDestDirs = System.getProperty( "CleanDestDirs" ) != null;

    private boolean mChanges = false;
    private int mNotifications = 0;
    private int mSilentChecks = 0;

    private void notify( Character pAction, String pWhat )
    {
        if ( pAction == null )
        {
            if ( ++mSilentChecks < 25 )
            {
                return;
            }
            mSilentChecks = 0;
            System.out.print( SILENT_THRESHOLD );
            if ( ++mNotifications >= 80 )
            {
                System.out.println();
                mNotifications = 0;
            }
            return;
        }
        if ( mNotifications != 0 )
        {
            System.out.println();
            mNotifications = 0;
        }
        System.out.println( pAction + " - " + pWhat );
        mChanges = true;
    }

    @SuppressWarnings({"ResultOfMethodCallIgnored"})
    protected void process( String pName, String pVersion, String[] args )
            throws IOException
    {
        System.out.println( pName + " vs " + pVersion );
        if ( args.length < 4 )
        {
            showHelp();
        }
        File sourcePath = new File( args[0] );
        File destinationPath = new File( args[1] );
        File xtraFilesPath = new File( args[2] );
        if ( !sourcePath.isDirectory() )
        {
            System.out.println( "Not a Directory: " + sourcePath.getAbsolutePath() );
            System.exit( 2 );
        }
        String[] zFilePatterns = new String[args.length - 3];
        for ( int i = 3; i < args.length; i++ )
        {
            zFilePatterns[i - 3] = deEscape( i, args[i] );
        }
        process( sourcePath, destinationPath, xtraFilesPath, zFilePatterns );
        if ( mChanges )
        {
            System.out.println();
            System.out.print( "Press Enter to Exit: " );
            System.in.read();
        }
    }

    private String deEscape( int pIndex, String pArg )
    {
        String rv = pArg.replace( '/', '\\' );
        while ( rv.startsWith( "\\" ) )
        {
            rv = rv.substring( 1 );
        }
        if ( rv.length() == 0 )
        {
            throw new IllegalArgumentException( "Nothing left after cleaning Argument[" + pIndex + "]: " + pArg );
        }
        if ( rv.contains( "\\" ) )
        {
            throw new IllegalArgumentException( "Argument[" + pIndex + "] '" + pArg + "' after cleaning still contained a back slash ('\\'): " + rv );
        }
        return rv;
    }

    private void process( File pSourcePath, File pDestinationPath, File pXtraFilesPath, String[] pFilePatterns )
    {
        Directories.checkDirectoryable( pSourcePath );
        Directories.checkDirectoryable( pDestinationPath );
        Directories.checkDirectoryable( pXtraFilesPath );

        for ( String zFilePattern : pFilePatterns )
        {
            process( pSourcePath, pDestinationPath, pXtraFilesPath, zFilePattern );
        }
        Iterator<String> sources = getDirsSorted( pSourcePath );
        Iterator<String> destination = getDirsSorted( pDestinationPath );

        String source = getNextOrNull( sources );
        String dest = getNextOrNull( destination );
        while ( (source != null) && (dest != null) )
        {
            File zSourcePath = new File( pSourcePath, source );
            int i = source.compareTo( dest );
            if ( i == 0 ) // Equal
            {
                File zDestinationPath = new File( pDestinationPath, source );
                File zXtraFilesPath = new File( pXtraFilesPath, source );
                process( zSourcePath, zDestinationPath, zXtraFilesPath, pFilePatterns );
                source = getNextOrNull( sources );
                dest = getNextOrNull( destination );
            }
            else if ( i < 0 ) // source < dest
            {
                File zDestinationPath = new File( pDestinationPath, source );
                File zXtraFilesPath = new File( pXtraFilesPath, source );
                process( zSourcePath, zDestinationPath, zXtraFilesPath, pFilePatterns );
                source = getNextOrNull( sources );
            }
            else // source > dest
            {
                if ( mCleanDestDirs )
                {
                    File zDestinationPath = new File( pDestinationPath, dest );
                    File zXtraFilesPath = new File( pXtraFilesPath, dest );
                    notify( moveDirForced( zDestinationPath, zXtraFilesPath ), zDestinationPath.getPath() );
                }
                dest = getNextOrNull( destination );
            }
        }
        for (; source != null; source = getNextOrNull( sources ) )
        {
            File zSourcePath = new File( pSourcePath, source );
            File zDestinationPath = new File( pDestinationPath, source );
            File zXtraFilesPath = new File( pXtraFilesPath, source );
            process( zSourcePath, zDestinationPath, zXtraFilesPath, pFilePatterns );
        }
        if ( mCleanDestDirs )
        {
            for (; dest != null; dest = getNextOrNull( destination ) )
            {
                File zDestinationPath = new File( pDestinationPath, dest );
                File zXtraFilesPath = new File( pXtraFilesPath, dest );
                notify( moveDirForced( zDestinationPath, zXtraFilesPath ), zDestinationPath.getPath() );
            }
        }
    }

    private void process( File pSourcePath, File pDestinationPath, File pXtraFilesPath, String pFilePattern )
    {
        FilenameFilter filter = FileUtils.createFileNameFilter( Strings.parseChar( pFilePattern, '*' ) );

        Iterator<String> sources = getFilesSorted( pSourcePath, filter );
        Iterator<String> destination = getFilesSorted( pDestinationPath, filter );

        String source = getNextOrNull( sources );
        String dest = getNextOrNull( destination );
        while ( (source != null) && (dest != null) )
        {
            int i = source.compareTo( dest );
            if ( i == 0 ) // Equal
            {
                notify( updateFile( pSourcePath, pDestinationPath, source ), source );
                source = getNextOrNull( sources );
                dest = getNextOrNull( destination );
            }
            else if ( i < 0 ) // source < dest
            {
                notify( copyAddFile( pSourcePath, pDestinationPath, source ), source );
                source = getNextOrNull( sources );
            }
            else // source > dest
            {
                notify( moveFileForced( pDestinationPath, pXtraFilesPath, dest ), dest );
                dest = getNextOrNull( destination );
            }
        }
        for (; source != null; source = getNextOrNull( sources ) )
        {
            notify( copyAddFile( pSourcePath, pDestinationPath, source ), source );
        }
        for (; dest != null; dest = getNextOrNull( destination ) )
        {
            notify( moveFileForced( pDestinationPath, pXtraFilesPath, dest ), dest );
        }
    }

    private Iterator<String> getFilesSorted( File pPath, FilenameFilter pFilter )
    {
        String[] files = Strings.EMPTY_ARRAY;
        if ( pPath.isDirectory() )
        {
            files = pPath.list( pFilter );
        }
        else if ( pPath.exists() )
        {
            System.out.println( "Not a Directory: " + pPath.getAbsolutePath() );
            System.exit( 2 );
        }
        Arrays.sort( files );
        return new ArrayIterator<String>( files );
    }

    private Iterator<String> getDirsSorted( File pPath )
    {
        String[] files = Strings.EMPTY_ARRAY;
        if ( pPath.isDirectory() )
        {
            files = pPath.list( Directories.DirsOnlyFilter.INSTANCE );
        }
        else if ( pPath.exists() )
        {
            System.out.println( "Not a Directory: " + pPath.getAbsolutePath() );
            System.exit( 2 );
        }
        Arrays.sort( files );
        return new ArrayIterator<String>( files );
    }

    private String getNextOrNull( Iterator<String> pIterator )
    {
        return pIterator.hasNext() ? pIterator.next() : null;
    }

    protected Character moveDirForced( File pSourcePath, File pDestinationPath )
    {
        return moveDir( pSourcePath, pDestinationPath ) ? DIR_MOVED : null;
    }

    protected Character moveFileForced( File pSourcePath, File pDestinationPath, String pFileName )
    {
        File source = new File( pSourcePath, pFileName );
        File dest = new File( pDestinationPath, pFileName );
        return moveFile( source, dest ) ? FILE_MOVED : null;
    }

    protected Character updateFile( File pSourcePath, File pDestinationPath, String pFileName )
    {
        File source = new File( pSourcePath, pFileName );
        File dest = new File( pDestinationPath, pFileName );
        return updateFile( source, dest ) ? FILE_UPDATED : null;
    }

    protected Character copyAddFile( File pSourcePath, File pDestinationPath, String pFileName )
    {
        File source = new File( pSourcePath, pFileName );
        File dest = new File( pDestinationPath, pFileName );
        return copyAddFile( source, dest ) ? FILE_COPY_ADDED : null;
    }

    /**
     * Move Dir - Assume same volume!
     */
    abstract protected boolean moveDir( File pSource, File pDestination );

    /**
     * Move File - Assume same volume!
     */
    abstract protected boolean moveFile( File pSource, File pDestination );

    /**
     * Update the existing pDestination from the pSource - Assume NOT the same volume!
     */
    abstract protected boolean updateFile( File pSource, File pDestination );

    /**
     * Copy the pSource to the pDestination - Assume NOT the same volume!
     */
    abstract protected boolean copyAddFile( File pSource, File pDestination );
}