package Torello.JavaDoc.SyntaxHiLite;

import Torello.Java.FileNode;
import Torello.Java.StrPrint;
import Torello.Java.FileRW;
import Torello.Java.StorageWriter;

import Torello.Java.Function.QuadFunction;

// Needed for a JavaDoc Comment
import Torello.Java.FileTransfer;

import Torello.JavaDoc.Annotations.LinkJavaSource;

import java.util.TreeSet;

import java.io.File;


/**
 * An {@code abstract} Parent-Class for both {@link HLC32} and {@link HLC64}.  The bulkwork of
 * methods and fields needed to run both of these classes can be placed in the abstract parent.
 * In fact, there are only two {@code abstract} implementatio methods that subclasses need to
 * implement in order to properly fullfill this {@code abstract} Parent-Class,
 */
public abstract class AbstractHashCodeHLC<NUMBER extends Number> implements HiLiteCache
{
    static final short NUM_DIRS = 5000;

    static
    {
        if ((NUM_DIRS < 1000) || (NUM_DIRS > 9999))
            throw new InternalError("Wrong Number of NUM_DIRS");
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Instance Fields
    // ********************************************************************************************
    // ********************************************************************************************


    /** This is nothing more than a "reified" Generic Type Parameter.  No more, no less. */
    public final Class<NUMBER> NUMBER_CLASS;

    /** This is, as the name clearly says, the Cache's Storae-Directory */
    public final String cacheSaveDirectory;


    // This is the list of Hash-Codes for all Code/HTML pairs stored in the cache.  This is the
    // exact data-structure that is referred to as the "Master Hash File"
    // 
    // This has also been recently converted to "Package-Private", instead of "Private"
    // See Above Note for Details.

    final TreeSet<NUMBER> hashCodes;


    // ********************************************************************************************
    // ********************************************************************************************
    // Constructor
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * This will load the hashCodes table to memory from the file-system directory identified
     * by {@code String}-Parameter {@code 'cacheSaveDirectory'}.  An exception shall be thrown
     * if this file is not found, or the specified directory doesn't exist.
     *
     * @param cacheSaveDirectory This constructor presumes that this cache has been used and
     * visited before.  This directory name should point to your local-cache of the
     * {@code HiLite.ME} Server Code hilite past-operations.
     *
     * @throws CacheError This error will throw if the cache has not been instantiated, or
     * is corrupted.  If the specified directory does not exist, then this {@code Error} shall
     * also throw.  The chain-cause {@code Throwable} should be visible, and is included as the 
     * {@code Throwable.getCause()}.
     */
    @LinkJavaSource(handle="TreeSetMethods", name="checkCSD")
    @LinkJavaSource(handle="TreeSetMethods", name="checkTS")
    public AbstractHashCodeHLC(
            final String        cacheSaveDirectory,
            final Class<NUMBER> NUMBER_CLASS
        )
    {
        this.cacheSaveDirectory = TreeSetMethods.checkCSD(cacheSaveDirectory);
        this.hashCodes          = TreeSetMethods.checkTS(this.cacheSaveDirectory, NUMBER_CLASS);
        this.NUMBER_CLASS       = NUMBER_CLASS;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Initialize a Directory for Cachine - Create if need be, Erase its contents, if non-empty
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * This will initialize a cache-file in the file-system directory identified by parameter
     * {@code String cacheSaveDirectory}.  If the directory specified does not exist,
     * {@code File.mkdirs()} will be invoked, thereby creating that directory.  If the specified
     * directory already exists - it's contents shall be fully wiped, meaning all files deleted.
     *
     * <BR /><BR /><DIV CLASS=JDHint>
     * <B>Erasing Contents:</B> If the directory structure provided to this method is non-empty,
     * the <B STYLE="color: red;"><I>its entire contents shall be erased by a call to</I></B>
     * <B>{@link FileTransfer#deleteFilesRecursive(FileNode, FileNodeFilter, FileNodeFilter,
     * Appendable)  FileTransfer#deleteFilesRecursive}.</B>, as per the statement below
     * </DIV>
     * 
     * <BR /><DIV CLASS=SNIP>{@code 
     * FileTransfer.deleteFilesRecursive
     *     (FileNode.createRoot(cacheSaveDirectory).loadTree(), sw);
     * }</DIV>
     * 
     * <BR />This method saves a brand-new (empty) Hash-Code List (a java.util.TreeSet) to disk, 
     * using  Java Object Serialization.  It is not actually important to know whether this Cache
     * is going to be a 32-Bit or a 64-Bit Cache.  The {@code TreeSet} which is written to disk is
     * empty.  Therefore, in all actuality, what is written to disk is a "Raw-Types" TreeSet 
     * (precisely because of Java's Generic Erasure).  Thus it is perfectly irrelevant what is
     * written to disk.
     * 
     * @param cacheSaveDirectory This constructor presumes that this cache has been used and
     * visited before.  This directory name should point to your local-cache of 
     * {@code HiLite.ME} Server Code hilite past-operations.
     * 
     * @param sw This receives log-writes from the call to
     * {@link FileTransfer#deleteFilesRecursive} which clears the files currently in the cache.
     * This parameter may be null, and if it is, output-text will be shunted.
     * 
     * @throws CacheError This exception will be throw if there are errors deleting any
     * old-cache files currently in the directory; or if there is any error creating the new
     * master hash-cache file.  The chain-cause {@code Throwable} should be visible, and is 
     * included as the {@code Throwable.getCause()}.
     */
    @LinkJavaSource(handle="TreeSetMethods", name="initializeDirectory")
    public static String initializeDirectory(String cacheSaveDirectory, StorageWriter sw)
    { return TreeSetMethods.initializeDirectory(cacheSaveDirectory, sw); }


    // ********************************************************************************************
    // ********************************************************************************************
    // Implemented Interface Methods
    // ********************************************************************************************
    // ********************************************************************************************


    public long totalSize()
    {
        return FileNode
            .createRoot(this.cacheSaveDirectory)
            .loadTree()
            .getDirTotalContentsSize();
    }

    public int totalNumber()
    {
        return FileNode
            .createRoot(this.cacheSaveDirectory)
            .loadTree()
            .count();
    }

    @LinkJavaSource(handle="TreeSetMethods", name="persistMasterHashToDisk")
    public void persistMasterHashToDisk() throws CacheError
    { TreeSetMethods.persistMasterHashToDisk(this.hashCodes, this.cacheSaveDirectory); }


    // ********************************************************************************************
    // ********************************************************************************************
    // Implemented Interface Methods: Check In and Out
    // ********************************************************************************************
    // ********************************************************************************************


    @LinkJavaSource(handle="CheckInOut", name="get")
    public String get(
            final String    sourceCodeAsString,
            final String    codeTypeParam,
            final boolean   includeLineNumbers,
            final byte      styleNum
        )
    {
        return CheckInOut.get(
            sourceCodeAsString,
            this.computeCacheKey
                (codeTypeParam, includeLineNumbers, styleNum, sourceCodeAsString),
            this
        );
    }

    @LinkJavaSource(handle="CheckInOut", name="checkIn")
    public void checkIn(
            final String    sourceCodeAsString,
            final String    hilitedCodeAsString, 
            final String    codeTypeParam,
            final boolean   includeLineNumbers,
            final byte      styleNum
        )
    {
        CheckInOut.checkIn(
            sourceCodeAsString,
            hilitedCodeAsString,
            this.computeCacheKey
                (codeTypeParam, includeLineNumbers, styleNum, sourceCodeAsString),
            this 
        );
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Abstract Methods
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Compute a Hash-Code for a given Source-File, and it's HiLiting Parameters
     * @param codeTypeParam         <EMBED CLASS='external-html' DATA-FILE-ID=HLC_PARAM_CODE_TP>
     * @param includeLineNumbers    <EMBED CLASS='external-html' DATA-FILE-ID=HLC_PARAM_INC_LINEN>
     * @param styleNum              <EMBED CLASS='external-html' DATA-FILE-ID=HLC_PARAM_STYLE_N>
     * @param sourceCodeAsString    <EMBED CLASS='external-html' DATA-FILE-ID=HLC_PARAM_SRC_ASSTR>
     * @return A key which may be used for saving a file to disk.
     */
    public abstract NUMBER computeCacheKey(
            final String    codeTypeParam,
            final boolean   includeLineNumbers,
            final byte      styleNum,
            final String    sourceCodeAsString
        );

    abstract String getSubDirName(NUMBER hashCode);


    // ********************************************************************************************
    // ********************************************************************************************
    // Main Method for invoking '' ...
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * A Main-Method which invokes {@link #initializeDirectory(String, StorageWriter)}
     */
    public static void main(String[] argv)
    {
        if (argv.length != 1)
        {
            System.out.println(
                "argv.length != 1\n" +
                "argv[0] must contain the Cache-Directory Name.\n"
            );

            System.exit(1);
        }

        initializeDirectory(argv[0], new StorageWriter());
    }
}