package Torello.JavaDoc.Messager;

import java.io.File;

import Torello.Java.StringParse;
import Torello.Java.UnreachableError;
import Torello.Java.C;
import Torello.Java.StorageWriter;

import Torello.JavaDoc.Declaration;

public class PrintRecord
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Constructor & Immutable-Fields ==> Fields set in stone at time of construction
    // ********************************************************************************************
    // ********************************************************************************************


    // This Appendable allows the user to pick a place to store the log-contents to disk, or just
    // about any output-Appendable.  This java.lang.Appendable may be specified/configured with the
    // class Upgrade - using the method: setLogFile
    //
    // NOTE: There are two methods for setting this field.  One allows the user to provide a file
    //       name, and the other allows them to provide any free-formed java.lang.Appendable.
    // 
    // FINAL-IMMUTABLE & **PRIVATE** Instance-Field - Only Used inside this class

    private final Appendable logAppendable;


    // Here is the level of the Verbosity.  The actual printing is done inside class MsgPkgPrivate,
    // and in that method, messages are only printed if they are above or equal to the current
    // Verbosity-Level

    final int verbosityLevel;


    // This just tells whether the above field is null.
    // TRUE => NON-NULL
    // FALSE => NULL
    // NOTE: This one is null

    final boolean hasLogAppendable;


    // Some stupid little thing, which I totally don't completely remember right now.
    // It is used inside the PrintHeading class.
    // Certain Verbosity-Levels necessitate a newline character

    final String VERBOSITY_LEVEL_NEW_LINE;


    // The "StorageWriter" Prints to the Screen.  The String's that it saves inside of it's
    // "Storage", are then send to the 'logAppendable' - if-and-only-if the logAppendable is non
    // null!

    final StorageWriter screenWriterSW = new StorageWriter();


    // This is used OVER-AND-OVER through out the Print-Messager & Print-Heading classes
    // It is "reset" whenever it is finished, rather than destroyed / freed.
    // 
    // This is currently important because it allows the logic to avoid creating and destroying a
    // million little StringBuilder's.  The only other point to "know about" is that StringBuilder
    // wasn't used at all a few months back (except "implicity", since the JDK, internally, uses a 
    // StringBuilder when doing its concatenation routines).
    // 
    // Now that some of the Parse Code is being turned into an external thing, there is the 
    // potential to re-use the messager code.  If that happens, a StringBuilder is used to retrieve
    // the Error-Message Strings, and then shove them into an exception instead!  (Thereby 
    // revering the original premise for having a "Messager" at all, namely avoid exception throws)

    final StringBuilder sb = new StringBuilder();

    // The actual constructor
    PrintRecord(final int verbosityLevel, final Appendable logAppendable)
    {
        this.verbosityLevel             = verbosityLevel;
        this.VERBOSITY_LEVEL_NEW_LINE   = (verbosityLevel < 2) ? "\n" : "";
        this.logAppendable              = logAppendable;
        this.hasLogAppendable           = (logAppendable != null);
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Static-Constants
    // ********************************************************************************************
    // ********************************************************************************************


    private static final byte   mode_FILE_AND_PROC_ONLY         = 1;
    private static final byte   mode_FILE_PROC_AND_DECL         = 2;
    private static final int    indentation_FILE_AND_PROC_ONLY  = 8;
    private static final int    indentation_FILE_PROC_AND_DECL  = 12;

    // These are **ONLY** used in the getter below
    private static final String I8  = StringParse.nChars(' ', 8);
    private static final String I12 = StringParse.nChars(' ', 12);


    // There is a very detail explanation for why "19" and "23" have been chosen, below!
    // 
    // final String fodIndent = " Processing ".length() + fileOrDir.length() + 2;
    // 
    // ==> " Directory " is 11 (9 + 2), " File " is 6 (4 + 2)
    // ==> " Processing " is 12 spaces long
    // ==> 12 + (11 or 6)
    // ==> 23 or 18

    private static final String I18 = StringParse.nChars(' ', 18);
    private static final String I23 = StringParse.nChars(' ', 23);


    // ********************************************************************************************
    // ********************************************************************************************
    // PRIVATE & **MUTABLE** Instance-Fields
    // ********************************************************************************************
    // ********************************************************************************************


    private int errorCount   = 0;
    private int warningCount = 0;

    // The mode it's using
    private byte mode = mode_FILE_AND_PROC_ONLY;

    // This sets the indentation level - as a number of space ' ' characters
    private Integer indentation = indentation_FILE_AND_PROC_ONLY;


    // The "current" Java Doc HTML File being analyzed.  Whenever an error occurs, presuming this
    // field is non-null, it will be printed at the top of the error message.

    private String fileName = null;


    // In this class, there is a method which "sets" the file-name.  This is done many times insde
    // the JDU-Internal classes.  Whenever the file-name is set, there is a second parameter 
    // included in the "set" method that mandates / requires a brief-small description of what the
    // file is also be provided.

    private String fileNameKind = null;

    // This shall be set to ==>   ? " Directory " : " File ";
    private String fileOrDir = null;


    // There is a very detail explanation for why "19" and "23" have been chosen, ABOVE!
    // final String fodIndent = " Processing ".length() + fileOrDir.length() + 2;

    private String fodIndentation = null;


    // The first time that an error or warning is printed, the file-name being "analyzed" must be
    // printed at the top of the message.  All subsequent messges do not need this error
    // header message, AS LONG AS THE SAME FILE IS STILL BEING ANALYZED.
    // 
    // When the Program Control-Flow sends a message that a new File-Name is being analzyed, then
    // the boolean is reset to FALSE immediately!
    // 
    // Whenever this boolean is FALSE, the File-Name being anaylzed has to be printed to any output
    // error-message or warning-messages that are printed to the user's terminal.

    private boolean printedFileNameAlready = false;


    // The "current" declaration about which error messages will be printed (if there are any)
    private Declaration declaration = null;


    // The "EmbedTag" processor treats the "TopDescription" as one of the details section.  It
    // really isn't "a hack" - because the code is so long and the "Top Description" Embed Tag's
    // are the exact same as the "Details" EmbedTag's.  This is also true for the "HiLiteDividers"
    // 
    // This, sort of, "overrides" the "detailSection" boolean.  Since the "Top Description" part of
    // any Java-Doc Web-Page also needs to be analyzed-and-updated, it is altogether possible that
    // that an error-or-warning message for the Top-Description HTML might be generated.
    // 
    // This needs to be handled IN THE EXACT SAME MANNER as error-or-warning messages are handled
    // for the Detail-Sections.  It needes to be printed to the user's terminal before the actual
    // error-message itself!
    //
    // This boolean just says: JDU isn't currently processing **ANY** Detail-Sections, so don't 
    // print the Detail-Section's name, instead please print a friendly message saying
    // that the "Top-Description Segment" of the Java-Doc Web-Page is being processed and analyzed
    // at the moment.

    private boolean topDescriptionAsDecl = false;


    // The first time that an error or warning is printed, the detail-section location must be
    // printed at the top of the message.  All subsequent messges do not need this error
    // header message.

    private boolean printedDeclAlready = false;


    // The purpose of is to - sort of - "Prevent" reprinting the Processor-Name and / or the  
    // Sub-Processor Name (over and over) when the Messager Receives requests to print errors over 
    // and over that are from the exact same Messager-Processor Location.
    // 
    // It looks **REALLY UGLY** to see the exact same, long-winded, Processor Location over and 
    // over for the exact same type of error.

    private Where_Am_I prev_WHERE_AM_I = null;



    // ********************************************************************************************
    // ********************************************************************************************
    // PACKAGE-PRIVATE **GETTERS** - Used in "PrintHeading" 
    // ********************************************************************************************
    // ********************************************************************************************


    boolean     hadErrors()                 { return this.errorCount > 0;                   }
    boolean     hadWarnings()               { return this.warningCount > 0;                 }
    int         getErrorCount()             { return this.errorCount;                       }
    int         getWarningCount()           { return this.warningCount;                     }
    int         getIndentation()            { return this.indentation;                      }
    byte        getMode()                   { return this.mode;                             }
    String      getFileName()               { return this.fileName;                         }
    String      getFileNameKind()           { return this.fileNameKind;                     }
    boolean     alreadyPrintedFileName()    { return this.printedFileNameAlready;           }
    Declaration getDeclaration()            { return this.declaration;                      }
    boolean     topDescriptionAsDecl()      { return this.topDescriptionAsDecl;             }
    boolean     alreadyPrintedDecl()        { return this.printedDeclAlready;               }
    boolean     modeFileAndProc()           { return this.mode == mode_FILE_AND_PROC_ONLY;  }
    boolean     modeFileProcAndDecl()       { return this.mode == mode_FILE_PROC_AND_DECL;  }
    String      isFileOrDir()               { return this.fileOrDir;                        }
    String      fodIndentation()            { return this.fodIndentation;                   }

    boolean whereAmIChanged(final Where_Am_I WHERE_AM_I)
    { return this.prev_WHERE_AM_I == WHERE_AM_I; }

    String getIndentationStr()
    {
        if (this.indentation == 8)  return I8;
        if (this.indentation == 12) return I12;

        throw new UnreachableError();
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Some simple setters
    // ********************************************************************************************
    // ********************************************************************************************


    void printingFileNameRightNow()
    { this.printedFileNameAlready = true; }

    void printingFirstDeclRightNow()
    { this.printedDeclAlready = true; }

    int incErrorCountAndCheck()
    {
        if (++this.errorCount > 25) throw new ReachedMaxErrors();
        else                        return this.errorCount;
    }

    int incWarningCount()
    { return ++this.warningCount;   }

    void setPreviouseWhereAmI(final Where_Am_I WHERE_AM_I)
    { this.prev_WHERE_AM_I = WHERE_AM_I;    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Messager Control Setters
    // ********************************************************************************************
    // ********************************************************************************************


    void setCurrentFileName(final String fName, final String fNameKind)
    {
        final boolean b = fName.endsWith(File.separator);

        this.fileNameKind           = fNameKind;
        this.fileName               = fName;
        this.fileOrDir              = b ? " Directory " : " File ";
        this.fodIndentation         = b ? I18 : I23;
        this.printedFileNameAlready = false;
        this.indentation            = indentation_FILE_AND_PROC_ONLY;
        this.mode                   = mode_FILE_AND_PROC_ONLY;

        // Also clear the detail section, and the entity
        this.declaration        = null;
        this.printedDeclAlready = false;
    }

    void setTopDescriptionSection()
    {
        this.declaration            = null;
        this.printedDeclAlready     = false;
        this.topDescriptionAsDecl   = true;
        this.indentation            = indentation_FILE_PROC_AND_DECL;
        this.mode                   = mode_FILE_PROC_AND_DECL;
    }

    void setDeclaration(final Declaration declaration)
    {
        this.declaration            = declaration;
        this.printedDeclAlready     = false;
        this.topDescriptionAsDecl   = false;
        this.indentation            = indentation_FILE_PROC_AND_DECL;
        this.mode                   = mode_FILE_PROC_AND_DECL;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Do Something
    // ********************************************************************************************
    // ********************************************************************************************


    void writeSBToScreen() 
    { 
        this.screenWriterSW.print(this.sb.toString());
        this.sb.setLength(0);
    }

    void checkPointLog()
    {
        final String textAlreadyWrittenToScreen = C
            .toHTML(this.screenWriterSW.getString(), true, true, true)
            .replace("\t", "        ");

        this.screenWriterSW.erase();

        try
            { this.logAppendable.append(textAlreadyWrittenToScreen); }

        catch (Exception e)
        {
            this.setCurrentFileName("User Provided Log", null);

            Messager.assertFail(
                e,
                "Exception thrown while attempting to write to User-Provided Appendable-Log\n" +
                "The Appendable which was provided to the class 'Torello.JavaDoc.Upgrade' has " +
                "thrown an Exception while attempting to write to it.",
                JDUMessager.PrintRecord
            );
        }
    }
}