package Torello.JavaDoc.SyntaxHiLite;

import Torello.Java.FileNode;
import Torello.Java.FileRW;
import Torello.Java.FileTransfer;
import Torello.Java.StorageWriter;
import Torello.Java.CacheError;

import java.io.File;

import java.util.TreeSet;


// These are just some simple methods that allow for reading and writing a Java TreeSet that 
// contains all of the Hash-Codes which have been saved to this Cache.  When a file is written to 
// the Cache, a simple Hash-Code is generated using the String-Contents of that file.  Currently,
// Java's Standard String.hashCode() is used to produce the Hash-Code.
// 
// This means summing the value of every character in the String 

class CacheMethodsInternal64
{
    private static final String HASH_SAVE_TREE = "HILITED_STRINGS_HASH_CODE.ts";

    static String checkCSD(String cacheSaveDirectory)
    {
        cacheSaveDirectory = cacheSaveDirectory.trim();

        if (! cacheSaveDirectory.endsWith(File.separator))
            cacheSaveDirectory = cacheSaveDirectory + File.separator;

        File f  = new File(cacheSaveDirectory);

        if (! f.exists()) throw new CacheError(
            "The specified cache-directory does not exist on the file-system: " +
            "[" + cacheSaveDirectory + "]"
        );

        return cacheSaveDirectory;
    }

    // the "return TreeSet<Long>" complains about an unchecked cast.
    @SuppressWarnings("unchecked") 
    static TreeSet<Long> checkTS(String cacheSaveDirectory)
    {
        String  fName   = cacheSaveDirectory + HASH_SAVE_TREE;
        File    f       = new File(fName);

        if (! f.exists()) throw new CacheError(
            "The current-cache directory does not contain a primary-cache file: " +
            "[" + fName + "]"
        );

        Object o;

        try
            { o = FileRW.readObjectFromFile(fName, true); }

        catch (Exception e)
        {
            throw new CacheError(
                "There was an error attempting to read the following primary-cache file.  " + 
                "It appears to be corrupted: [" + fName + "]",
                e
            );
        }

        if (! (o instanceof TreeSet)) throw new CacheError(
            "There primary cache file loaded, but does not contain the correct " +
            "data-structure.  It appears to be corrupted. [" + fName + "]"
        );

        return (TreeSet<Long>) o;
    }


    // Just saves a brand-new (empty) Hash-Code List (a java.util.TreeSet) to disk, using
    // Standard Java Object Serialization.

    private static TreeSet<Integer> writeNewTS(String cacheSaveDirectory)
    {
        TreeSet<Integer> hashCodes = new TreeSet<>();

        try
            { FileRW.writeObjectToFile(hashCodes, cacheSaveDirectory + HASH_SAVE_TREE, true); }

        catch (Exception e)
        {
            throw new CacheError(
                "There was an error writing the Cache Hash-Code File to disk.  " +
                "[" + cacheSaveDirectory + HASH_SAVE_TREE + "].  " ,
                e
            );
        }

        return hashCodes;
    }


    // This will save the hash-code {@code TreeSet<Integer>} to disk.
    // It uses standard Java Object-Serialization

    static void persistMasterHashToDisk(HiLiteCache64 cache) throws CacheError
    {
        try
        {
            FileRW.writeObjectToFile
                (cache.hashCodes, cache.cacheSaveDirectory + HASH_SAVE_TREE, true);
        }

        catch (Exception e)
        {
            throw new CacheError(
                "There was an error writing the Master Hash-Code table to disk. " +
                "File [" + cache.cacheSaveDirectory + HASH_SAVE_TREE + "] was not saved. " +
                "The cache-file will have to be refreshed at some point.  New Files " +
                "Cache-Hash not saved.",
                e
            );
        }
    }


    // This will initialize a cache in the file-system directory identified by parameter
    // 'cacheSaveDirectory'.  This method will traverse the File-System Directory-Tree and clobber
    // the contents of all sub-directories, and the files that they contain.
    // 
    // If the directory specified does not exist, a {@code CacheError} is thrown.
    // 
    // At the end a new Hash-Code => File-Location 

    static HiLiteCache64 initializeOrClear(String cacheSaveDirectory, StorageWriter sw)
        throws CacheError
    {
        cacheSaveDirectory = checkCSD(cacheSaveDirectory);

        final String tempStrForStupidLambdaFinal = cacheSaveDirectory;

        try
        {
            File f = new File(cacheSaveDirectory);

            if (f.isDirectory())
                FileTransfer.deleteFilesRecursive(
                    FileNode.createRoot(cacheSaveDirectory).loadTree(), null,
                    (FileNode fn) -> fn.getFullPathName().equals(tempStrForStupidLambdaFinal),
                    sw
                );

            f.mkdirs();
        }

        catch (Exception e)
        {
            throw new CacheError(
                "There was an error emptying/clearing the directory " +
                "[" + cacheSaveDirectory + "] of it's contents, please see cause " +
                "throwable.getCause() for details.",
                e
            );
        }

        try
            { writeNewTS(cacheSaveDirectory); }

        catch (Exception e)
        {
            throw new CacheError(
                "There was an error saving/creating the new cache-file " +
                "[" + cacheSaveDirectory + "], please see cause chain throwable.getCause(), " +
                "for more details.",
                e
            );
        }

        return new HiLiteCache64(cacheSaveDirectory);
    }

    static long computeCacheKey(
            final String    codeTypeParam,
            final boolean   includeLineNumbers,
            final byte      styleNum,
            final String    sourceCodeAsString
        )
    {
        final long FNV_PRIME = 0x100000001b3L;
        long hash = 0xcbf29ce484222325L;
    
        // Mix in codeTypeParam
        for (int i = 0; i < codeTypeParam.length(); i++) {
            hash ^= codeTypeParam.charAt(i);
            hash *= FNV_PRIME;
        }
    
        // Mix in includeLineNumbers
        hash ^= (includeLineNumbers ? 1 : 0);
        hash *= FNV_PRIME;
    
        // Mix in styleNum
        hash ^= styleNum;
        hash *= FNV_PRIME;
    
        // Mix in sourceCodeAsString
        for (int i = 0; i < sourceCodeAsString.length(); i++) {
            hash ^= sourceCodeAsString.charAt(i);
            hash *= FNV_PRIME;
        }
    
        return hash;
    }
}