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.LinkJavaSource;

import java.util.TreeSet;

import java.io.File;

/**
 * A caching-system class that allows this tool to efficiently bypass calls to the server when
 * an exact-copy of the hilited source-code already exists inside the cache.
 */
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.
     *
     * @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;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Static Builder Method
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * This will initialize a cache-file in the file-system directory identified by parameter
     * {@code String cacheSaveDirectory}.  If the directory specified does not exist, a
     * {@code CacheError} is thrown.  Any old cache files will be removed.  To attempt to
     * preserve old cache-files, call method {@code initializeOrRepair(String, StorageWriter)}
     * 
     * <BR /><BR /><B><I>OrClear:</I></B> If the directory structure provided to this
     * initialize method is not empty, the <SPAN STYLE="color: red;"><B><I>its entire contents
     * shall be erased by a call to </I></B></SPAN> (Below)
     * 
     * <DIV CLASS=LOC>{@code 
     * FileTransfer.deleteFilesRecursive
     *     (FileNode.createRoot(cacheSaveDirectory).loadTree(), sw);
     * }</DIV>
     * 
     * @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="initializeOrClear")
    public static String initializeOrClear(String cacheSaveDirectory, StorageWriter sw)
    { return TreeSetMethods.initializeOrClear(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
     * @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);


    // ********************************************************************************************
    // ********************************************************************************************
    // I forgot ...
    // ********************************************************************************************
    // ********************************************************************************************


    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);
        }

        java.io.File f = new java.io.File(argv[0]);

        if ((! f.exists()) || (! f.isDirectory()))
        {
            System.out.println(
                "argv[0] must contain the Cache-Directory Name.\n" +
                "Unfortunately: ((! f.exists()) || (! f.isDirectory()))\n"
            );

            System.exit(1);
        }

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