/*
 * [MiniFD.java]
 *
 * Summary: File Descriptor, describes one file. Not for directories!.
 *
 * Copyright: (c) 2003-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:
 * 10.2 2009-04-03 tidy up code to check presence of necessary files to make it more WORA.
 *                 Case sensitive.
 *                 Stored internally relative to a base. This is the mini-descriptor used in the client. It is used
 *                 only to
 *                 describe the last file in a zip, not to describe every file. FD extends MiniFD for use in sender.
 */
package com.mindprod.replicatorcommon;

import com.mindprod.common18.Misc;
import com.mindprod.replicator.ConfigForReceiver;

import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Comparator;
import java.util.regex.Pattern;

/**
 * File Descriptor, describes one file. Not for directories!.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 10.2 2009-04-03 tidy up code to check presence of necessary files to make it more WORA.
 * Case sensitive.
 * Stored internally relative to a base. This is the mini-descriptor used in the client. It is used only to
 * describe the last file in a zip, not to describe every file. FD extends MiniFD for use in sender.
 * @since 2003-08-21
 */
public class MiniFD implements Serializable
    {
    /**
     * Layout version number.
     */
    public static final long serialVersionUID = 105L;

    /**
     * Comparator to sort by clumping timestamp and filename.
     */
    public static final Comparator<MiniFD> BY_CLUMPING_AND_FILENAME =
            new ByClumpingAndFilename();

    /**
     * Regex to split full filename into fragments separated by /. Separator char between elements of the directory name
     * e.g. / or \ in a regex == is ok. We are comparing chars, not Strings.
     */
    private static final Pattern SLASH_SPLITTER = Pattern.compile( File.separatorChar == '\\'
                                                                   ? "\\\\"
                                                                   : String.valueOf( File.separatorChar ) );

    /**
     * Regex to split a filename into words separated by space. Do not "correct" to \\s+
     */
    private static final Pattern SPACE_SPLITTER = Pattern.compile( " " );

    /**
     * each node of the directory name, interned.
     */
    private final String[] dirNodes;

    /**
     * true if this file has been been deleted
     */
    protected boolean isDeleted;

    /**
     * Timestamp milliseconds since 1970 of the master copy of this file. Magic value marks Deletions.
     */
    protected long timestamp = Config.NULL_TIMESTAMP;

    /**
     * Each word of directory name interned. Words are separated by a single space. Trailing space removed.
     */
    private String[] fileWords;

    /**
     * file extension after the dot interned
     */
    private String extension;

    /**
     * Usually the same as the timestamp, but for files that appear out of the blue with dates in the past, is the
     * cutoff timestamp for the last round of distributions, at so that it will clump with the newly created files.
     * Otherwise we would imagine this file was already done in some past zip. Sometimes we adjust the time by a
     * millisecond or two just to ensure all files have unique timestamps. Otherwise we would have trouble picking up
     * where we left off in the middle of a group of files with identical timestamps.
     */
    private long clumping = Config.NULL_TIMESTAMP;

    /**
     * file size in bytes, note long not int. Java Zip entry length is restricted to int.
     */
    private long fileLength;

    /**
     * copy constructor to demote an FD to a MiniFD
     *
     * @param m MiniFD or FD to copy.
     */
    public MiniFD( MiniFD m )
        {
        dirNodes = m.dirNodes;
        fileWords = m.fileWords;
        extension = m.extension;
        fileLength = m.fileLength;
        clumping = m.clumping;
        timestamp = m.timestamp;
        isDeleted = m.isDeleted;
        }

    /**
     * constructor
     *
     * @param dir      directory, relative to base, without leading or trailing \
     * @param filename including extension.
     */
    public MiniFD( String dir, String filename )
        {
        // split into fragments separated by /
        if ( dir.length() == 0 )
            {
            dirNodes = new String[ 0 ];
            }
        else
            {
            dirNodes = SLASH_SPLITTER.split( dir );
            for ( int i = 0; i < dirNodes.length; i++ )
                {
                // We intern for faster comparing.
                // We can detect equal strings faster.
                dirNodes[ i ] = dirNodes[ i ].intern();
                } // end for
            }
        // Find extension
        extension = "";
        int whereDot = filename.lastIndexOf( '.' );
        if ( whereDot > 0 )
            {
            extension = filename.substring( whereDot + 1 );
            // chop extension off
            filename = filename.substring( 0, whereDot );
            }
        // We intern for faster comparing.
        // We can detect equal strings faster.
        extension = extension.intern();
        if ( dir.length() != dir.trim().length()
             || filename.length() != filename.trim().length() )
            {
            throw new IllegalArgumentException( new StringBuilder( 200 ).append(
                    "File: \"" )
                    .append( dir )
                    .append( File
                            .separatorChar )
                    .append( filename )
                    .append( "." )
                    .append( extension )
                    .append( "\" should not have leading or trailing spaces." ).toString() );
            }
        // if filename contains two spaces in a row, will we have an empty fileword.
        fileWords = SPACE_SPLITTER.split( filename );
        for ( int i = 0; i < fileWords.length; i++ )
            {
            // We intern for faster comparing.
            // We can detect equal strings faster.
            fileWords[ i ] = fileWords[ i ].intern();
            }
        }

    /**
     * Case sensitive compare of just dir, filename and extension
     *
     * @param o1 first file to compare
     * @param o2 second file to compare
     *
     * @return +1 if a>b, 0 if a=b, -1 if a<b
     */
    protected static int comparePathCaseSensitive( MiniFD o1, MiniFD o2 )
        {
        // Strings are all interned, so we can compare for equality with ==
        // but use equals for safety. Interning speeds it up.
        int diff;
        int nd = Math.min( o1.dirNodes.length, o2.dirNodes.length );
        for ( int i = 0; i < nd; i++ )
            {
            if ( !o1.dirNodes[ i ].equals( o2.dirNodes[ i ] ) )
                {
                return o1.dirNodes[ i ].compareTo( o2.dirNodes[ i ] );
                }
            }
        diff = o1.dirNodes.length - o2.dirNodes.length;
        if ( diff != 0 )
            {
            return diff;
            }
        int nw = Math.min( o1.fileWords.length, o2.fileWords.length );
        for ( int i = 0; i < nw; i++ )
            {
            if ( !o1.fileWords[ i ].equals( o2.fileWords[ i ] ) )
                {
                return o1.fileWords[ i ].compareTo( o2.fileWords[ i ] );
                }
            }
        diff = o1.fileWords.length - o2.fileWords.length;
        if ( diff != 0 )
            {
            return diff;
            }
        if ( !o1.extension.equals( o2.extension ) )
            {
            return o1.extension.compareTo( o2.extension );
            }
        return 0;
        }

    /**
     * Case insensitive compare of just dir, filename and extension
     *
     * @param o1 first file to compare
     * @param o2 second file to compare
     *
     * @return +1 if a>b, 0 if a=b, -1 if a<b
     */
    protected static int comparePathIgnoreCase( MiniFD o1, MiniFD o2 )
        {
        // Strings are all interned, so we can compare for equality with ==
        // but use equals for safety. Interning speeds it up.
        int diff;
        int nd = Math.min( o1.dirNodes.length, o2.dirNodes.length );
        for ( int i = 0; i < nd; i++ )
            {
            if ( !o1.dirNodes[ i ].equals( o2.dirNodes[ i ] ) )
                {
                diff = o1.dirNodes[ i ].compareToIgnoreCase( o2.dirNodes[ i ] );
                if ( diff != 0 )
                    {
                    return diff;
                    }
                }
            }
        diff = o1.dirNodes.length - o2.dirNodes.length;
        if ( diff != 0 )
            {
            return diff;
            }
        int nw = Math.min( o1.fileWords.length, o2.fileWords.length );
        for ( int i = 0; i < nw; i++ )
            {
            if ( !o1.fileWords[ i ].equals( o2.fileWords[ i ] ) )
                {
                diff = o1.fileWords[ i ]
                        .compareToIgnoreCase( o2.fileWords[ i ] );
                if ( diff != 0 )
                    {
                    return diff;
                    }
                }
            }
        diff = o1.fileWords.length - o2.fileWords.length;
        if ( diff != 0 )
            {
            return diff;
            }
        if ( !o1.extension.equals( o2.extension ) )
            {
            return o1.extension.compareToIgnoreCase( o2.extension );
            }
        return 0;
        }

    /**
     * display the timestamp and clumping fields
     *
     * @return string representation
     */
    protected String displayTimestamps()
        {
        final StringBuilder sb = new StringBuilder( 40 );
        if ( timestamp != Config.NULL_TIMESTAMP )
            {
            sb.append( " ts: " );
            sb.append( Config.TIMESTAMP_MILLISECOND_FORMAT.format( timestamp ) );
            }
        if ( clumping != Config.NULL_TIMESTAMP )
            {
            sb.append( " clump: " );
            sb.append( Config.TIMESTAMP_MILLISECOND_FORMAT.format( clumping ) );
            }
        return sb.toString();
        }

    /**
     * deserialise and ensure fields are re-interned when read back
     *
     * @param stream ObjectInputStream of objects
     *
     * @throws IOException            if can't read object.
     * @throws ClassNotFoundException if stream corrupt.
     */
    private void readObject( ObjectInputStream stream ) throws IOException, ClassNotFoundException
        {
        stream.defaultReadObject();
        // reintern everything
        for ( int i = 0; i < dirNodes.length; i++ )
            {
            dirNodes[ i ] = dirNodes[ i ].intern();
            }
        for ( int i = 0; i < fileWords.length; i++ )
            {
            fileWords[ i ] = fileWords[ i ].intern();
            }
        extension = extension.intern();
        }

    /**
     * Convert to String for debug
     *
     * @return Filename as a String
     */
    public String dump()
        {
        final StringBuilder sb = new StringBuilder( 100 );
        sb.append( "MiniFD " );
        if ( isDeleted )
            {
            sb.append( "DELETED " );
            }
        sb.append( getFilename( FilenameContext.INSIDE_ZIP ) );
        sb.append( " fileLength:" );
        sb.append( fileLength );
        sb.append( displayTimestamps() );
        return sb.toString();
        }

    /**
     * get clumping timestamp date file was last updated, adjusted for latecomer files
     *
     * @return timestamp millis since 1970
     */
    public long getClumping()
        {
        return this.clumping;
        }

    /**
     * set timestamp by which files are clumped into archives.
     *
     * @param clumping new clumping timestamp.
     */
    public void setClumping( long clumping )
        {
        this.clumping = clumping;
        }

    /**
     * get the file extension. "" if none.
     *
     * @return file extension without the dot, interned.
     */
    public String getExtension()
        {
        return extension;
        }

    /**
     * get file size in bytes.
     *
     * @return size in bytes
     */
    public long getFileLength()
        {
        return this.fileLength;
        }

    /**
     * Set file size in bytes.
     *
     * @param fileLength size in bytes
     */
    public void setFileLength( long fileLength )
        {
        this.fileLength = fileLength;
        }

    /**
     * get the fully qualified filename : e.g. E:\mindprod\jgloss\java.html
     *
     * @param where which kind of name you want ON_SOURCE, ON_TARGET, INSIDE_ZIP
     *
     * @return fully qualified name of the file.
     */
    public String getFilename( FilenameContext where )
        {
        switch ( where )
            {
            // ON_SOURCE defined in FD
            case ON_TARGET:
                return ConfigForReceiver
                               .RECEIVER_BASE_DIR
                       + File
                               .separatorChar
                       + getRelativeFilename( File.separatorChar );
            case INSIDE_ZIP:
                return getRelativeFilename( '/' );
            default:
                assert false : "bad where code";
                return null;
            }
        }

    /**
     * Get filename, reconstituted as a String, relative to the base.
     *
     * @param sepChar char to use to separate directory elements.
     *
     * @return filename with directory, filename and extension.
     */
    public String getRelativeFilename( char sepChar )
        {
        assert dirNodes != null : "missing dirNodes";
        // estimate final length of filename in chars.
        int length = 0;
        for ( String dirNode : dirNodes )
            {
            length += dirNode.length() + 1;
            }
        assert fileWords != null : "missing fileWords";
        for ( String fileWord : fileWords )
            {
            length += fileWord.length() + 1;
            }
        assert extension != null : "missing extension";
        length += extension.length() + 1;
        final StringBuilder sb = new StringBuilder( length );
        // reconstitute filename from interned fragments.
        for ( String dirNode1 : dirNodes )
            {
            sb.append( dirNode1 );
            sb.append( sepChar );
            }
        for ( int i = 0; i < fileWords.length; i++ )
            {
            sb.append( fileWords[ i ] );
            if ( i < this.fileWords.length - 1 )
                {
                sb.append( ' ' );
                }
            } // end for
        if ( extension.length() > 0 )
            {
            sb.append( '.' );
            sb.append( extension );
            }
        return sb.toString();
        } // end getRelativeFilename

    /**
     * get timestamp date file was last updated.
     *
     * @return timestamp millis since 1970
     */
    public long getTimestamp()
        {
        return this.timestamp;
        }

    /**
     * Set timestamp of last update of the file.
     *
     * @param timestamp millis since 1970
     */
    public void setTimestamp( long timestamp )
        {
        this.timestamp = timestamp;
        }

    /**
     * has this file been deleted?
     *
     * @return true if this file has been deleted.
     */
    public boolean isDeleted()
        {
        return isDeleted;
        }

    /**
     * mark this file as having been deleted
     */
    public void markAsDeleted()
        {
        isDeleted = true;
        }

    /**
     * Convert to String for display
     *
     * @return Filename as a String
     */
    public String toString()
        {
        return getFilename( FilenameContext.INSIDE_ZIP );
        }

    /**
     * sort by clumping.
     * <p/>
     * Defines an alternate sort order for MiniFD.
     *
     * @version 1.0 2009-05-22 - initial release
     * @since 2009-05-22
     */
    static class ByClumpingAndFilename implements Comparator<MiniFD>, Serializable
        {
        /**
         * Layout version number.
         */
        static final long serialVersionUID = 2L;

        /**
         * sort by clumping.
         * Defines an alternate sort order for MiniFD.
         * Compare two MiniFD Objects.
         * Compares clumping then path.
         * Informally, returns (a-b), or +ve if a is more positive than b.
         *
         * @param a first MiniFD to compare
         * @param b second MiniFD to compare
         *
         * @return +ve if a&gt;b, 0 if a==b, -ve if a&lt;b
         */
        public final int compare( MiniFD a, MiniFD b )
            {
            // Long.compare not available except in 1.7.
            final int diff = Misc.signum( a.clumping - b.clumping );
            if ( diff != 0 )
                {
                return diff;
                }
            // on tie, compare by dirnodes
            return Config.CASE_SENSITIVE
                   ? comparePathCaseSensitive( a, b )
                   : comparePathIgnoreCase( a, b );
            }
        }
    }