// 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.stringmatching.*;

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

public class FileUtils extends FileUtil {
    public enum Change {New, Updated}

    public static OutputStream createOutputStream( File pFile )
            throws IOException {
        Confirm.isNotNull( "File", pFile );
        return new FileOutputStream( pFile );
    }

    public static InputStream createInputStream( File pFile )
            throws IOException {
        Confirm.isNotNull( "File", pFile );
        return new FileInputStream( pFile );
    }

    public static Reader[] filesToReaders( File pDir, String... pFileNames )
            throws FileNotFoundException {
        if ( Currently.isNullOrEmpty( pFileNames ) ) {
            throw new IllegalArgumentException( "No Files provided" );
        }
        Reader[] readers = new Reader[pFileNames.length];
        for ( int i = 0; i < pFileNames.length; i++ ) {
            File file = new File( pDir, pFileNames[i] );
            readers[i] = new InformativeFileReader( file );
        }
        return readers;
    }

    private static class InformativeFileReader extends FileReader implements ToStringInformative {
        private File mFile;

        private InformativeFileReader( File pFile )
                throws FileNotFoundException {
            super( pFile );
            mFile = pFile;
        }

        @Override
        public String toString() {
            return mFile.getAbsolutePath();
        }
    }

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

    public static FilenameFilter createFileNameFilter( String... pParts ) {
        StringMatcher zSM = StringMatcherFactory.createStartsWith( pParts );
        if ( zSM == null ) {
            throw new IllegalArgumentException( "Must Provide something to Filter on!" );
        }
        return new StringMatcherFilenameFilter( zSM );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public static String locateFile( String pFile )
            throws FileSystemException {
        try {
            File file = new File( pFile );
            while ( !file.isFile() ) {
                File parent = file.getParentFile();
                if ( parent != null ) {
                    File grandparent = parent.getParentFile();
                    if ( grandparent != null ) {
                        file = new File( grandparent, pFile );
                        continue;
                    }
                }
                throw new FileNotFoundException( pFile );
            }
            return file.getAbsolutePath();
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    public static byte[] load( File pFile, int pMaxAllowedSize )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        try {
            if ( !pFile.exists() ) {
                throw new FileNotFoundException( pFile.getAbsolutePath() );
            }
            long fSize = pFile.length();
            if ( fSize > pMaxAllowedSize ) {
                throw new FileSystemException( "File (" + pFile + ") Too large (" + fSize + "), but max set to: " + pMaxAllowedSize );
            }
            int fileSize = (int) fSize;
            byte[] b = new byte[fileSize];
            InputStream is = new FileInputStream( pFile );
            boolean closed = false;
            try {
                int offset = 0;
                while ( offset < fileSize ) {
                    int i = is.read( b, offset, fileSize - offset );
                    if ( i < 1 ) {
                        throw new FileSystemException( "Unable to read the entire file (" + pFile + ").  Expected " + fileSize + ", but only got: " + offset );
                    }
                    offset += i;
                }
                if ( -1 != is.read() ) {
                    throw new FileSystemException( "Read beyond file (" + pFile + ") size (" + fileSize + ")!" );
                }
                closed = true;
                is.close();
            }
            finally {
                if ( !closed ) {
                    Utils.dispose( is );
                }
            }
            return b;
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    public static void appendTextFile( File pFile, String... pLines )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        File file = new File( pFile.getAbsolutePath() );
        addLines( file, true, pLines );
    }

    public static void store( File pFile, byte[] pBytes )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        File file = Directories.insureParent( new File( pFile.getAbsolutePath() + ".new" ) );
        try {
            OutputStream os = new FileOutputStream( file );
            boolean closed = false;
            try {
                if ( (pBytes != null) && (pBytes.length != 0) ) {
                    os.write( pBytes );
                }
                closed = true;
                os.close();
            }
            finally {
                if ( !closed ) {
                    Utils.dispose( os );
                }
            }
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
        rollIn( file, pFile, new File( pFile.getAbsolutePath() + ".bak" ) );
    }

    public static void storeTextFile( File pFile, String... pLines )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        File file = new File( pFile.getAbsolutePath() + ".new" );
        addLines( file, false, pLines );
        rollIn( file, pFile, new File( pFile.getAbsolutePath() + ".bak" ) );
    }

    private static void addLines( File pFile, boolean pAppend, String... pLines )
            throws FileSystemException {
        try {
            addLines( createWriter( pFile, pAppend ), pLines );
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    private static void addLines( BufferedWriter pWriter, String... pLines )
            throws IOException {
        boolean closed = false;
        try {
            for ( String line : ConstrainTo.notNullImmutableList( pLines ) ) {
                if ( line != null ) {
                    pWriter.write( line );
                    pWriter.write( '\n' );
                }
            }
            closed = true;
            pWriter.close();
        }
        finally {
            if ( !closed ) {
                Utils.dispose( pWriter );
            }
        }
    }

    public static String[] loadTextFile( File pFile )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        try {
            if ( !pFile.exists() ) {
                throw new FileNotFoundException( pFile.getAbsolutePath() );
            }
            List<String> lines = new LinkedList<String>();
            BufferedReader reader = createReader( pFile );
            boolean closed = false;
            try {
                for ( String line; null != (line = reader.readLine()); ) {
                    lines.add( line );
                }
                closed = true;
                reader.close();
            }
            finally {
                if ( !closed ) {
                    Utils.dispose( reader );
                }
            }
            return lines.toArray( new String[lines.size()] );
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public static String loadTextFileAsString( File pFile )
            throws FileSystemException {
        return loadTextFileAsString( pFile, null );
    }

    public static String loadTextFileAsString( File pFile, String pLineTerminator )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        pLineTerminator = ConstrainTo.notNull( pLineTerminator, "\n" );
        try {
            if ( !pFile.exists() ) {
                throw new FileNotFoundException( pFile.getAbsolutePath() );
            }

            StringBuilder buffer = new StringBuilder();
            BufferedReader reader = createReader( pFile );
            boolean closed = false;
            try {
                for ( String line; null != (line = reader.readLine()); ) {
                    buffer.append( line ).append( pLineTerminator );
                }
                closed = true;
                reader.close();
            }
            finally {
                if ( !closed ) {
                    Utils.dispose( reader );
                }
            }

            return buffer.toString();
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    /**
     * @return Null if already exists and Not changed, otherwise either New of Updated!
     */
    public static Change storeFile( File pFile, List<byte[]> pContents )
            throws FileSystemException {
        if ( pFile.exists() && areEqual( loadFile( pFile ), pContents ) ) {
            return null;
        }
        File file = new File( pFile.getAbsolutePath() + ".new" );
        try {
            IOUtils.storeBytes( pContents, createOutputStream( file ) );
        }
        catch ( IOException e ) {
            throw new FileSystemException( "Unable to create OutputStream: " + file.getAbsolutePath() );
        }
        return rollIn( file, pFile, new File( pFile.getAbsolutePath() + ".bak" ) ) ? Change.Updated : Change.New;
    }

    public static List<byte[]> loadFile( File pFile )
            throws FileSystemException {
        Confirm.isNotNull( "File", pFile );
        try {
            if ( !pFile.exists() ) {
                throw new FileNotFoundException( pFile.getAbsolutePath() );
            }
            return IOUtils.loadBytes( createInputStream( pFile ) );
        }
        catch ( IOException e ) {
            throw new FileSystemException( e );
        }
    }

    /**
     * Roll in an Update.
     *
     * @return true if replaced an existing!
     */
    public static boolean rollIn( File pNewFile, File pTargetFile, File pBackupFile )
            throws FileSystemException {
        Confirm.isNotNull( "NewFile", pNewFile );
        Confirm.isNotNull( "TargetFile", pTargetFile );
        Confirm.isNotNull( "BackupFile", pBackupFile );
        if ( !pNewFile.exists() ) {
            throw new FileSystemException( "Does not Exist: " + pNewFile.getPath() );
        }
        boolean targetExisted = false;
        if ( pTargetFile.exists() ) {
            targetExisted = true;
            deleteIfExists( pBackupFile );
            renameFromTo( pTargetFile, pBackupFile );
        }
        try {
            renameFromTo( pNewFile, pTargetFile );
            return targetExisted;
        }
        catch ( FileSystemException e ) {
            if ( targetExisted ) {
                attemptToRollBack( pNewFile, pTargetFile, pBackupFile );
            }
            throw e;
        }
    }

    @SuppressWarnings({"ResultOfMethodCallIgnored"})
    private static void attemptToRollBack( File pNewFile, File pTargetFile, File pBackupFile ) {
        switch ( (pNewFile.exists() ? 0 : 4) + (pTargetFile.exists() ? 0 : 2) + (pBackupFile.exists() ? 0 : 1) ) {
            // What Happen'd
            case 0: // There: ------------- Nobody --------------
            case 2: // There:            pTargetFile
            case 4: // There: pNewFile
            case 6: // There: pNewFile & pTargetFile
            case 7: // There: pNewFile & pTargetFile & pBackupFile
                return;
            case 3: // There:            pTargetFile & pBackupFile
                pTargetFile.renameTo( pNewFile );
                // Fall Thru
            case 1: // There:                          pBackupFile
            case 5: // There: pNewFile               & pBackupFile
                pBackupFile.renameTo( pTargetFile );
                break;
        }
    }

    /**
     * This method will rename the pSourceFile to the pDestinationFile name.
     * <p/>
     * It is Inherently fragile when dealing with multiple processes playing
     * in the same file system name spaces.  It should therefore NOT be used
     * in a multi-process creation-consumption shared file system name space.
     * <p/>
     * Specifically there are two windows of opportunities for multiple processes
     * to mess with the "as linear" assumptions
     */
    private static void renameFromTo( File pSourceFile, File pDestinationFile )
            throws FileSystemException {
        Confirm.isNotNull( "SourceFile", pSourceFile );
        Confirm.isNotNull( "DestinationFile", pDestinationFile );
        // Win 1 Start
        if ( !pSourceFile.exists() ) {
            throw new FileSystemException( "SourceFile does not exist: " + pSourceFile.getAbsolutePath() );
        }
        if ( pDestinationFile.exists() ) {
            throw new FileSystemException( "DestinationFile already exists: " + pDestinationFile.getAbsolutePath() );
        }
        // Win 2 Start
        if ( !pSourceFile.renameTo( pDestinationFile ) )    // Win 1 End
        {
            throw renameFailed( pSourceFile, pDestinationFile, "Failed" );
        }
        boolean sThere = pSourceFile.exists();
        boolean dThere = pDestinationFile.exists();
        // Win 2 End
        if ( sThere ) {
            throw renameFailed( pSourceFile, pDestinationFile, "claims Succeess, but Source still there" + (dThere ? " and so is the Destination!" : "!") );
        }
        if ( !dThere ) {
            throw renameFailed( pSourceFile, pDestinationFile, "claims Succeess, but the Destination is NOT there!" );
        }
    }

    private static FileSystemException renameFailed( File pSourceFile, File pDestinationFile, String pAdditionalExplanation ) {
        throw new FileSystemException(
                "Rename (" + pSourceFile.getAbsolutePath() + ") to (" + pDestinationFile.getAbsolutePath() + ") " + pAdditionalExplanation );
    }

    private static class StringMatcherFilenameFilter implements FilenameFilter {
        private StringMatcher mSM;

        public StringMatcherFilenameFilter( StringMatcher pSM ) {
            mSM = pSM;
        }

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

    public static void main( String[] args )
            throws Exception {
        File zFile = new File( "PersistanceTier/design/NextGEN.xml" );
        String[] lines = loadTextFile( zFile );
        process( lines );
        storeTextFile( zFile, lines );
    }

    private static void process( String[] pLines ) {
        for ( int i = 0; i < pLines.length; i++ ) {
            String zLine = pLines[i];
            if ( zLine != null ) {
                if ( zLine.trim().startsWith( "<column " ) ) {
                    processColumn( pLines, i, findEONode( pLines, i ) );
                } else if ( zLine.trim().startsWith( "<foreignKey " ) ) {
                    processForeignKey( pLines, i, findEONode( pLines, i ) );
                }
            }
        }
    }

    private static int findEONode( String[] pLines, int pFromIndex ) {
        int zThruIndex = pFromIndex;
        while ( zThruIndex < pLines.length ) {
            String zLine = pLines[zThruIndex];
            if ( (zLine != null) && zLine.trim().endsWith( ">" ) ) {
                break;
            }
            zThruIndex++;
        }
        return zThruIndex;
    }

    private static boolean isAttributeOneOf( String pLine, String... pOneOf ) {
        for ( String s : pOneOf ) {
            if ( pLine.startsWith( s + "=" ) ) {
                return true;
            }
        }
        return false;
    }

    private static void processColumn( String[] pLines, int pBegLine, int pEndLine ) {
        for ( int i = pBegLine + 1; i < pEndLine; i++ ) {
            String zLine = pLines[i];
            if ( zLine != null ) {
                zLine = zLine.trim();
                if ( zLine.equals( "type=\"foreignKey\"" ) ) // No More Columns as ForeignKeys
                {
                    for ( int j = pBegLine; j <= pEndLine; j++ ) {
                        pLines[j] = null;
                    }
                    return;
                }
                if ( isAttributeOneOf( zLine, "fkonly", "isContainer", "IsContainer", "ReferenceSortColumn", "ThemDependsOnUs", "UsDependsOnThem", "table",
                                       "updateReferencedPO" ) ) {
                    pLines[i] = null;
                }
            }
        }
    }

    private static void processForeignKey( String[] pLines, int pBegLine, int pEndLine ) {
        for ( int i = pBegLine + 1; i < pEndLine; i++ ) {
            String zLine = pLines[i];
            if ( zLine != null ) {
                zLine = zLine.trim();
                if ( isAttributeOneOf( zLine, "fkonly", "isContainer", "IsContainer", "defaultValue", "enumeration", "len" ) ) {
                    pLines[i] = null;
                }
            }
        }
    }

    private static boolean areEqual( List<byte[]> pBytes1, List<byte[]> pBytes2 ) {
        if ( byteCount( pBytes1 ) == byteCount( pBytes2 ) ) {
            ByteStream zStream1 = new ByteStream( pBytes1 );
            ByteStream zStream2 = new ByteStream( pBytes2 );
            for ( Byte zByte1; org.litesoft.commonfoundation.typeutils.Objects.areNonArraysEqual( zByte1 = zStream1.next(), zStream2.next() ); ) {
                if ( zByte1 == null ) {
                    return true;
                }
            }
        }
        return false;
    }

    private static int byteCount( List<byte[]> pBytes ) {
        int zCount = 0;
        for ( byte[] zBlock : pBytes ) {
            zCount += zBlock.length;
        }
        return zCount;
    }

    private static class ByteStream {
        private final Iterator<byte[]> mIterator;
        private byte[] mCurrentBlock;
        private int mBlockOffset;

        public ByteStream( List<byte[]> pBytes ) {
            mIterator = pBytes.iterator();
            prepBlock();
        }

        private void prepBlock() {
            if ( mIterator.hasNext() ) {
                mCurrentBlock = mIterator.next();
                mBlockOffset = 0;
            } else {
                mCurrentBlock = null;
                mBlockOffset = -1;
            }
        }

        public Byte next() {
            for (; mBlockOffset != -1; prepBlock() ) {
                if ( mBlockOffset < mCurrentBlock.length ) {
                    return mCurrentBlock[mBlockOffset++];
                }
            }
            return null;
        }
    }
}