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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.exceptions.*;
import org.litesoft.commonfoundation.typeutils.*;

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

@SuppressWarnings("UnusedDeclaration")
public class Directories {
    public static String currentWorking() {
        return System.getProperty( "user.dir" );
    }

    public static String temp() {
        return System.getProperty( "java.io.tmpdir" );
    }

    public static File findFromCurrent( String pSubPath ) {
        return find( currentWorking(), pSubPath );
    }

    public static File find( String pStartingPath, String pSubPath ) {
        Confirm.isNotNull( "StartingPath", pStartingPath );
        pSubPath = Confirm.significant( "SubPath", pSubPath );

        File target = locate( pStartingPath, pSubPath, Paths.justTheLastName( pSubPath ) + ".path" );
        if ( target != null ) {
            return target;
        }
        throw new IllegalStateException( "Unable to locate Directory: " + pSubPath );
    }

    private static File locate( String pStartingPath, String pSubPath, String pRedirectorName ) {
        File base = new File( pStartingPath );
        do {
            File target = new File( base, pSubPath );
            if ( target.exists() ) {
                return target;
            }
            if ( pRedirectorName != null ) {
                target = new File( base, pRedirectorName );
                if ( target.isFile() ) {
                    for ( String line : FileUtils.loadTextFile( target ) ) {
                        if ( Currently.isNotNullOrEmpty( line ) ) {
                            if ( null != (target = locate( line, pSubPath, null )) ) {
                                return target;
                            }
                        }
                    }
                }
            }
            base = base.getParentFile();
        }
        while ( base != null );
        return null;
    }

    public static File assertDirectory( File pExpectedDir )
            throws FileSystemException {
        Confirm.isNotNull( "ExpectedDir", pExpectedDir );
        if ( !pExpectedDir.isDirectory() ) {
            throw new FileSystemException( "Not a Directory: " + pExpectedDir.getAbsolutePath() );
        }
        return pExpectedDir;
    }

    public static void checkDirectoryable( File pExpectedDir )
            throws FileSystemException {
        Confirm.isNotNull( "ExpectedDir", pExpectedDir );
        if ( !pExpectedDir.isDirectory() && pExpectedDir.exists() ) {
            throw new FileSystemException( "Exists, but is Not a Directory: " + pExpectedDir.getAbsolutePath() );
        }
    }

    public static File insureParent( File pExpectedFile )
            throws FileSystemException {
        Confirm.isNotNull( "ExpectedFile", pExpectedFile );
        File zParentFile = pExpectedFile.getParentFile();
        if ( zParentFile != null ) {
            insure( zParentFile );
        }
        return pExpectedFile;
    }

    public static File insure( File pExpectedDir )
            throws FileSystemException {
        Confirm.isNotNull( "ExpectedDir", pExpectedDir );
        if ( !pExpectedDir.isDirectory() ) {
            if ( pExpectedDir.exists() ) {
                throw new FileSystemException( "Exists, but is Not a Directory: " + pExpectedDir.getAbsolutePath() );
            }
            if ( !pExpectedDir.mkdirs() || !pExpectedDir.isDirectory() ) {
                throw new FileSystemException( "Unable to create Directory: " + pExpectedDir.getAbsolutePath() );
            }
        }
        return pExpectedDir;
    }

    public static void moveAllFiles( String pFromPath, String pToPath ) {
        File zFrom = assertDirectory( new File( pFromPath ) );
        File zTo = insure( new File( pToPath ) );
        File[] zFiles = zFrom.listFiles();
        if ( zFiles != null ) {
            for ( File zFile : zFiles ) {
                String zName = zFile.getName();
                moveFile( zFile, new File( zTo, zName ) );
            }
        }
    }

    public static void moveFile( File pSourceFile, File pTargetFile )
            throws FileSystemException {
        Confirm.isNotNull( "SourceFile", pSourceFile );
        Confirm.isNotNull( "TargetFile", pTargetFile );
        Throwable zProblem = null;
        try {
            if ( pSourceFile.exists() ) {
                insureParent( pTargetFile );
            }
            if ( pSourceFile.renameTo( pTargetFile ) ) {
                if ( pTargetFile.exists() ) {
                    return;
                }
            }
        }
        catch ( RuntimeException e ) {
            zProblem = e;
        }
        throw new FileSystemException( "Failed to Move (rename): " + pSourceFile + " to " + pTargetFile, zProblem );
    }

    public static void deleteIfExists( File pDirectory )
            throws FileSystemException {
        Confirm.isNotNull( "Directory", pDirectory );
        if ( pDirectory.isDirectory() ) {
            LowLevelDeleteAllEntries( pDirectory );
            if ( !pDirectory.delete() || pDirectory.exists() ) {
                throw new FileSystemException( "Unable to delete: " + pDirectory.getAbsolutePath() );
            }
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public static void deleteAllEntries( File pDirectory )
            throws FileSystemException {
        Confirm.isNotNull( "Directory", pDirectory );
        if ( pDirectory.isDirectory() ) {
            LowLevelDeleteAllEntries( pDirectory );
        }
    }

    private static void LowLevelDeleteAllEntries( File pDirectory )
            throws FileSystemException {
        String[] files = pDirectory.list();
        for ( String file : files ) {
            File entry = new File( pDirectory, file );
            if ( entry.isDirectory() ) {
                deleteIfExists( entry );
            } else {
                FileUtils.deleteIfExists( entry );
            }
        }
    }

    /**
     * @param pExpectedDirectory e.g. C:\work\OBEDS\test\odlfExpected
     * @param pActualDirectory   e.g. C:\work\OBEDS\test\odlf
     *
     * @return error if not null or empty
     */
    @SuppressWarnings({"UnusedDeclaration"})
    public static String compare( String pExpectedDirectory, String pActualDirectory, String... pSkipEntries ) {
        File expected = new File( pExpectedDirectory );
        File actual = new File( pActualDirectory );
        if ( !expected.isDirectory() ) {
            return "'" + expected.getAbsolutePath() + "' Not a Directory";
        }
        if ( !actual.isDirectory() ) {
            return "'" + actual.getAbsolutePath() + "' Not a Directory";
        }

        AllButFilter filter = new AllButFilter( pSkipEntries );
        String[] entriesExpected = expected.list( filter );
        String[] entriesActual = actual.list( filter );
        Arrays.sort( entriesExpected );
        Arrays.sort( entriesActual );
        if ( entriesActual.length == 0 ) {
            return (entriesExpected.length == 0) ? null : // No Error
                   "Missing: " + addEntries( entriesExpected, 0 ).substring( 1 );
        }
        if ( entriesExpected.length == 0 ) {
            return "Unexpected: " + addEntries( entriesActual, 0 ).substring( 1 );
        }
        List<FileMatcher> matchers = new ArrayList<FileMatcher>();
        StringBuilder unexpected = new StringBuilder();
        StringBuilder missing = new StringBuilder();
        int atActual = 0;
        int atExpected = 0;
        while ( (atActual < entriesActual.length) && (atExpected < entriesExpected.length) ) {
            int cmp = entriesActual[atActual].compareTo( entriesExpected[atExpected] );
            if ( cmp == 0 ) {
                // Equal
                matchers.add( new FileMatcher( pExpectedDirectory, pActualDirectory, entriesExpected[atExpected++] ) );
                atActual++;
            } else if ( cmp > 0 ) {
                // Actual > Expected
                add( missing, entriesExpected[atExpected++] );
            } else {
                // Actual < Expected
                add( unexpected, entriesActual[atActual++] );
            }
        }
        while ( atActual < entriesActual.length ) {
            add( unexpected, entriesActual[atActual++] );
        }
        while ( atExpected < entriesExpected.length ) {
            add( missing, entriesExpected[atExpected++] );
        }
        StringBuilder issues = new StringBuilder();
        if ( unexpected.length() != 0 ) {
            issues.append( "<br>" ).append( "Unexpected: " ).append( unexpected.toString().substring( 1 ) );
        }
        if ( missing.length() != 0 ) {
            issues.append( "<br>" ).append( "Missing: " ).append( missing.toString().substring( 1 ) );
        }
        if ( issues.length() != 0 ) {
            return issues.toString();
        }
        for ( FileMatcher matcher : matchers ) {
            matcher.checkLengths( issues );
        }
        if ( issues.length() != 0 ) {
            return issues.toString();
        }
        for ( FileMatcher matcher : matchers ) {
            matcher.checkContents( issues );
        }
        if ( issues.length() != 0 ) {
            return issues.toString();
        }
        return null; // No error
    }

    private static String addEntries( String[] pEntries, int pAt ) {
        StringBuilder sb = new StringBuilder();
        while ( pAt < pEntries.length ) {
            add( sb, pEntries[pAt++] );
        }
        return sb.toString();
    }

    private static void add( StringBuilder pSb, String pEntry ) {
        pSb.append( ", " ).append( pEntry );
    }

    public static class DirsOnlyFilter implements FilenameFilter {
        public static final FilenameFilter INSTANCE = new DirsOnlyFilter();

        @Override
        public boolean accept( File dir, String name ) {
            return new File( dir, name ).isDirectory();
        }
    }

    public static class DirsOnlyFileFilter implements FileFilter {
        public static final FileFilter INSTANCE = new DirsOnlyFileFilter();

        @Override
        public boolean accept( File pathname ) {
            return pathname.isDirectory();
        }
    }

    public static class AllButFilter implements FilenameFilter {
        private String[] mButs;

        public AllButFilter( String... pButs ) {
            mButs = pButs;
        }

        @Override
        public boolean accept( File dir, String name ) {
            for ( String but : mButs ) {
                if ( name.equals( but ) ) {
                    return false;
                }
            }
            return true;
        }
    }

    public static class FileMatcher {
        private File mExpected, mActual;
        private String mName;

        public FileMatcher( String pExpectedDirectory, String pActualDirectory, String pName ) {
            mName = pName;
            mExpected = new File( pExpectedDirectory, pName );
            mActual = new File( pActualDirectory, pName );
        }

        public void checkLengths( StringBuilder pIssues ) {
            long expected = mExpected.length();
            long actual = mActual.length();

            if ( actual != expected ) {
                pIssues.append( "<br>Files '" ).append( mName ).append( "' Lengths MisMatch " ).append( "Actual(" ).append( actual ).append( ") != Expected(" )
                        .append( expected ).append( ")" );
            }
        }

        public void checkContents( StringBuilder pIssues ) {
            StreamBlockReader eSBR = new StreamBlockReader();
            StreamBlockReader aSBR = new StreamBlockReader();
            try {
                eSBR.initialize( new FileInputStream( mExpected ) );
                aSBR.initialize( new FileInputStream( mActual ) );
                eSBR.readNextBlock();
                aSBR.readNextBlock();
                do {
                    if ( !eSBR.blocksEqual( aSBR ) ) {
                        pIssues.append( "<br>Files '" ).append( mName ).append( "' Contents Mismatch" );
                        return;
                    }
                }
                while ( 0 != (eSBR.readNextBlock() + aSBR.readNextBlock()) );
            }
            catch ( IOException e ) {
                pIssues.append( "<br>Files '" ).append( mName ).append( "' IOException: " ).append( e.getMessage() );
            }
            finally {
                eSBR.dispose();
                aSBR.dispose();
            }
        }
    }

    public static class StreamBlockReader {
        private InputStream mInputStream = null;
        private byte[] mBuf = new byte[16 * 1024];
        private int mCount = 0;

        public void initialize( InputStream pInputStream ) {
            mInputStream = pInputStream;
            mCount = 0;
        }

        public int readNextBlock()
                throws IOException {
            mCount = 0;
            int bytes;
            while ( 0 < (bytes = mInputStream.read( mBuf, mCount, mBuf.length - mCount )) ) {
                mCount += bytes;
                if ( mCount == mBuf.length ) {
                    break;
                }
            }
            return mCount;
        }

        public boolean blocksEqual( StreamBlockReader pThem ) {
            if ( this.mCount != pThem.mCount ) {
                return false;
            }
            for ( int i = 0; i < mCount; i++ ) {
                if ( this.mBuf[i] != pThem.mBuf[i] ) {
                    return false;
                }
            }
            return true;
        }

        public void dispose() {
            if ( mInputStream != null ) {
                Utils.dispose( mInputStream );
                mInputStream = null;
            }
        }
    }

    public static void main( String[] args )
            throws Exception {
        DirectoriesDepthFirst.Visitor zVisitor = new MyVisitor( FileUtils.createFileNameFilter( Strings.parseChar( args[0], '*' ) ) );

        new DirectoriesDepthFirst( zVisitor ).process( new File( currentWorking() ) );
    }

    private static class MyVisitor implements DirectoriesDepthFirst.Visitor {
        private FilenameFilter mFilter;

        public MyVisitor( FilenameFilter pFilter ) {
            mFilter = pFilter;
        }

        @Override
        public void process( File pDirectory )
                throws IOException {
            File[] zFiles = pDirectory.listFiles( mFilter );
            if ( Currently.isNotNullOrEmpty( zFiles ) ) {
                System.out.println( pDirectory );
                for ( File zFile : zFiles ) {
                    boolean zDeleted = zFile.delete();
                    System.out.println( "  " + (zDeleted ? " " : "!") + " " + zFile.getName() );
                }
                String[] zFileNames = pDirectory.list();
                if ( Currently.isNullOrEmpty( zFileNames ) ) {
                    boolean zDeleted = pDirectory.delete();
                    System.out.println( " " + (zDeleted ? "x!" : "!x") );
                }
            }
        }
    }
}