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

import java.io.*;
import java.util.*;

import org.litesoft.core.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.exit( 1 );
    }

    private int mNotifications = 0;
    private int mSilentChecks = 0;

    private void notify( Character pWhat )
    {
        if ( pWhat == null )
        {
            if ( ++mSilentChecks < 50 )
            {
                return;
            }
            mSilentChecks = 0;
            pWhat = SILENT_THRESHOLD;
        }
        System.out.print( pWhat );
        if ( ++mNotifications >= 80 )
        {
            System.out.println();
            mNotifications = 0;
        }
    }


    protected void process( String pName, String pVersion, String[] args )
    {
        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];
        System.arraycopy( args, 3, zFilePatterns, 0, zFilePatterns.length );
        process( sourcePath, destinationPath, xtraFilesPath, zFilePatterns );
    }

    private void process( File pSourcePath, File pDestinationPath, File pXtraFilesPath, String[] pFilePatterns )
    {
        DirectoryUtils.checkDirectoryable( pSourcePath );
        DirectoryUtils.checkDirectoryable( pDestinationPath );
        DirectoryUtils.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
            {
                File zDestinationPath = new File( pDestinationPath, dest );
                File zXtraFilesPath = new File( pXtraFilesPath, dest );
                moveDirForced( zDestinationPath, zXtraFilesPath );
                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 );
        }
        for (; dest != null; dest = getNextOrNull( destination ) )
        {
            notify( moveFileForced( pDestinationPath, pXtraFilesPath, dest ) );
        }
    }

    private void process( File pSourcePath, File pDestinationPath, File pXtraFilesPath, String pFilePattern )
    {
        FilenameFilter filter = FileUtils.createFileNameFilter( Utils.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 = getNextOrNull( sources );
                dest = getNextOrNull( destination );
            }
            else if ( i < 0 ) // source < dest
            {
                notify( copyAddFile( pSourcePath, pDestinationPath, source ) );
                source = getNextOrNull( sources );
            }
            else // source > dest
            {
                notify( moveFileForced( pDestinationPath, pXtraFilesPath, dest ) );
                dest = getNextOrNull( destination );
            }
        }
        for (; source != null; source = getNextOrNull( sources ) )
        {
            notify( copyAddFile( pSourcePath, pDestinationPath, source ) );
        }
        for (; dest != null; dest = getNextOrNull( destination ) )
        {
            notify( moveFileForced( pDestinationPath, pXtraFilesPath, dest ) );
        }
    }

    private Iterator<String> getFilesSorted( File pPath, FilenameFilter pFilter )
    {
        String[] files = Utils.EMPTY_STRING_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 = Utils.EMPTY_STRING_ARRAY;
        if ( pPath.isDirectory() )
        {
            files = pPath.list( DirectoryUtils.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 );
}