/*
 * The Apache Software License, Version 1.1
 * 
 * Copyright (c) 1999 The Apache Software Foundation.  All rights 
 * reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:  
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 * 
 * 4. The names "Xerces" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written 
 *    permission, please contact apache\@apache.org.
 * 
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation, and was
 * originally based on software copyright (c) 1999, International
 * Business Machines, Inc., http://www.ibm.com .  For more information
 * on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */


/**
 * $Log$
 * Revision 1.1  1999/11/09 01:01:12  twl
 * Initial revision
 *
 * Revision 1.5  1999/11/08 20:42:04  rahul
 * Swat for adding in Product name and CVS comment log variable.
 *
 */


// ---------------------------------------------------------------------------
//  This program is designed to parse an XML file which holds error text
//  data. It will build a DOM tree from that source file and can output it
//  a number of different formats.
//
//  In order to drastically simplify the program, it is designed only to run
//  on platforms/compilers that understand Unicode. It can output the data
//  in whatever format is required, so it can handle outputting for other
//  platforms. This also simplifies bootstrapping new releases up on other
//  platforms. Once the Win32 version is working, it can generate output for
//  the other platforms so that they can have loadable text from day one.
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
//  Includes 
// ---------------------------------------------------------------------------
#include "Xlat.hpp"


// ---------------------------------------------------------------------------
//  Static data
//
//  gRelativeInputPath
//      This is the path, relative to the given input source root, to the
//      input file. The given local suffix must also be added to it.
// ---------------------------------------------------------------------------
static XMLCh* const     gRelativeInputPath  = L"src/NLS/";


// ---------------------------------------------------------------------------
//  Global data
// ---------------------------------------------------------------------------
const XMLCh* typePrefixes[MsgTypes_Count] = 
{
    L"W_"
    , L"E_"
    , L"V_"
};


// ---------------------------------------------------------------------------
//  Local data
//
//  gLocale
//      This is the locale suffix, e.g. US_EN, that is used to find the
//      correct file and can be used on output files as well. Its set via
//      the /Locale= parameter.
//
//  gOutFormat
//      This is the output format, which is given on the command line as
//      /OutFmt= Its mapped to the internal enum which is stored here.
//
//  gOutPath
//      This is the path to the output path, which is given on the command
//      line as /OutPath=. Its just the path, not a name, since the output
//      might consist of multiple output files. They will all be based on
//      the base part of the input name.
//
//  gSrcRoot
//      This the path to the root of the build tree. The input files needed
//      are found in known places relative to it.
// ---------------------------------------------------------------------------
const XMLCh*    gLocale = 0;
OutFormats      gOutFormat = OutFormat_Unknown;
const XMLCh*    gOutPath = 0;
const XMLCh*    gSrcRoot = 0;


// ---------------------------------------------------------------------------
//  Local utility methods
// ---------------------------------------------------------------------------

//
//  This method is called to parse the parameters. They must be in this
//  order and format, for simplicity:
//
//  /SrcRoot=xxx /OutPath=xxx /OutFmt=xxx /Locale=xxx
//
static bool parseParms(const int argC, XMLCh** argV)
{
    if (argC < 5)
        return false;

    unsigned int curParm = 1;

    if (XMLString::startsWith(argV[curParm], L"/SrcRoot="))
    {
        gSrcRoot = &argV[curParm][9];
    }
     else
    {
        wprintf(L"\nExpected /SrcRoot=xxx. Got: %s\n", argV[curParm]);
        return false;
    }

    curParm++;
    if (XMLString::startsWith(argV[curParm], L"/OutPath="))
    {
        gOutPath = &argV[curParm][9];
    }
     else
    {
        wprintf(L"\nExpected /OutPath=xxx. Got: %s\n", argV[curParm]);
        return false;
    }


    curParm++;
    if (XMLString::startsWith(argV[curParm], L"/OutFmt="))
    {
        const XMLCh* tmpFmt = &argV[curParm][8];
        if (!XMLString::compareIString(tmpFmt, L"ResBundle"))
            gOutFormat = OutFormat_ResBundle;
        else if (!XMLString::compareIString(tmpFmt, L"Win32RC"))
            gOutFormat = OutFormat_Win32RC;
        else if (!XMLString::compareIString(tmpFmt, L"CppSrc"))
            gOutFormat = OutFormat_CppSrc;
        else if (!XMLString::compareIString(tmpFmt, L"MsgCat"))
            gOutFormat = OutFormat_MsgCatalog;
        else
        {
            wprintf(L"\n'%s' is not a legal output format\n", tmpFmt);
            return false;
        }
    }
     else
    {
        wprintf(L"\nExpected /OutFmt=xxx. Got: %s\n", argV[curParm]);
        return false;
    }

    curParm++;
    if (XMLString::startsWith(argV[curParm], L"/Locale="))
    {
        gLocale = &argV[curParm][8];
    }
     else
    {
        wprintf(L"\nExpected /Locale=xxx. Got: %s\n", argV[curParm]);
        return false;
    }

    return true;
}


static void parseError(const XMLException& toCatch)
{
    wprintf(L"Parse Error:\n   ERROR: %s\n\n", toCatch.getMessage());
    throw ErrReturn_ParseErr;
}


static void parseError(const SAXParseException& toCatch)
{
    wprintf(L"Parse Error:\n   SAX ERROR: %s\n\n", toCatch.getMessage());
    throw ErrReturn_ParseErr;
}


static void
enumMessages(   const   DOM_Element             srcElem
                ,       XlatFormatter* const    toCall
                ,       FILE* const             headerFl
                , const MsgTypes                msgType
                ,       unsigned int&           count)
{
    fwprintf
    (
        headerFl
        , L"      , %s%-30s   = %d\n"
        , typePrefixes[msgType]
        , L"LowBounds"
        , count++
    );

    //
    //  We just run through each of the child elements, each of which is
    //  a Message element. Each one represents a message to output. We keep
    //  a count so that we can output a const value afterwards.
    //
    DOM_Node curNode = srcElem.getFirstChild();
    while (!curNode.isNull())
    {
        // Skip over text nodes or comment nodes ect...
        if (curNode.getNodeType() != DOM_Node::ELEMENT_NODE)
        {
            curNode = curNode.getNextSibling();
            continue;
        }

        // Convert it to an element node
        const DOM_Element& curElem = (const DOM_Element&)curNode;

        // Ok, this should be a Message node
        if (!curElem.getTagName().equals(L"Message"))
        {
            wprintf(L"Expected a Message node\n\n");
            throw ErrReturn_SrcFmtError;
        }

        //
        //  Ok, lets pull out the id, text value, and message type. These are
        //  to be passed to the formatter. We have to translate the message
        //  type into one of the offical enum values.
        //
        XMLCh* msgText = curElem.getAttribute(L"Text").rawBuffer();
        XMLCh* msgId   = curElem.getAttribute(L"Id").rawBuffer();

        //
        //  Write out an entry to the target header file. These are enums, so
        //  we use the id as the enum name.
        //
        fwprintf(headerFl, L"      , %-32s   = %d\n", msgId, count);

        // And tell the formatter about this one
        toCall->nextMessage
        (
            msgText
            , msgId
            , count
            , count
        );

        // Bump the counter, which is also the id assigner
        count++;

        // Move to the next child of the source element
        curNode = curNode.getNextSibling();
    }

    // Write out an upper range bracketing id for this type of error
    fwprintf
    (
        headerFl
        , L"      , %s%-30s   = %d\n"
        , typePrefixes[msgType]
        , L"HighBounds"
        , count++
    );
}


// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------

//
//  This is the program entry point. It checks the parms, parses the input
//  file to get a DOM tree, then passes the DOM tree to the appropriate
//  output method to output the info in a particular format.
//
extern "C" int wmain(int argC, XMLCh** argV)
{
    try
    {
        XMLPlatformUtils::Initialize();
    }

    catch(const XMLException& toCatch)
    {
        wprintf(L"Parser init error.\n  ERROR: %s\n\n", toCatch.getMessage());
        return ErrReturn_ParserInit;
    }

    //
    //  Lets check the parameters and save them away in globals for use by
    //  the processing code.
    //
    if (!parseParms(argC, argV))
    {
        wprintf(L"Usage:\n  NLSXlat /SrcRoot=xx /OutPath=xx /OutFmt=xx /Locale=xx\n\n");
        return ErrReturn_BadParameters;
    }

    DOM_Document srcDoc;
    const unsigned int bufSize = 4095;
    XMLCh tmpFileBuf[bufSize + 1];
    try
    {
        try
        {
            // Build the input file name
            swprintf
            (
                tmpFileBuf
                , L"%s%s%s/XMLErrList_%s.Xml"
                , gSrcRoot
                , gRelativeInputPath
                , gLocale
                , gLocale
            );

            //
            //  Ok, lets invoke the DOM parser on the input file and build
            //  a DOM tree. Turn on validation when we do this.
            //
            DOMParser parser;
            parser.setDoValidation(true);
            XlatErrHandler errHandler;
            parser.setErrorHandler(&errHandler);
            parser.parse(tmpFileBuf);
            srcDoc = parser.getDocument();
        }

        catch(const XMLException& toCatch)
        {
            parseError(toCatch);
        }

        //
        //  Use the output format parm to create the correct kind of output
        //  formatter.
        //
        XlatFormatter* formatter = 0;
        switch(gOutFormat)
        {
            case OutFormat_CppSrc :
                formatter = new CppSrcFormatter;
                break;

            case OutFormat_Win32RC :
                formatter = new Win32RCFormatter;
                break;

            case OutFormat_MsgCatalog :
                formatter = new MsgCatFormatter;
                break;

            default :
                wprintf(L"Uknown formatter type enum\n\n");
                throw ErrReturn_Internal;
        }

        //
        //  Lets handle the root element stuff first. This one holds any over
        //  all information.
        //
        DOM_Element rootElem = srcDoc.getDocumentElement();
        const XMLCh* localeStr = rootElem.getAttribute(L"Locale").rawBuffer();

        // Make sure that the locale matches what we were given
        if (XMLString::compareString(localeStr, gLocale))
        {
            wprintf(L"The file's locale does not match the target locale\n");
            throw ErrReturn_LocaleErr;
        }

        //
        //  Get a list of all the MsgDomain children. These each hold one of
        //  the sets of (potentially separately) loadable messages. More
        //  importantly they all have their own error id space.
        //
        DOM_NodeList msgSetList = rootElem.getElementsByTagName(L"MsgDomain");

        //
        //  Loop through them and look for the domains that we know are
        //  supposed to be there.
        //
        const unsigned int count = msgSetList.getLength();

        //
        //  Ok, its good enough to get started. So lets call the start output
        //  method on the formatter.
        //
        formatter->startOutput(localeStr, gOutPath);

        //
        //  For each message domain element, we call start and end domain
        //  events bracketed around the loop that sends out each message
        //  in that domain.
        //
        //  Within each domain, we check for the Warning, Error, and Validity
        //  subelements, and then iterate all the messages in each one.
        //
        for (unsigned int index = 0; index < count; index++)
        {
            // We know its a DOM Element, so go ahead and cast it
            DOM_Node curNode = msgSetList.item(index);
            const DOM_Element& curElem = (const DOM_Element&)curNode;

            //
            //  Get some of  the attribute strings that we need, and transcode
            //  couple that need to be in local format.
            //
            const XMLCh* const domainStr = curElem.getAttribute(L"Domain").rawBuffer();

            //
            //  Look at the domain and set up our application specific info
            //  that is on a per-domain basis. We need to indicate what the
            //  name of the header is and what the namespace is that they
            //  codes will go into
            //
            const XMLCh* headerName = 0;
            const XMLCh* errNameSpace = 0;
            if (!XMLString::compareString(domainStr, XMLUni::fgXMLErrDomain))
            {
                headerName = L"XMLErrorCodes.hpp";
                errNameSpace = L"XML4CErrs";
            }
             else if (!XMLString::compareString(domainStr, XMLUni::fgValidityDomain))
            {
                headerName = L"XMLValidityCodes.hpp";
                errNameSpace = L"XML4CValid";
            }
             else if (!XMLString::compareString(domainStr, XMLUni::fgExceptDomain))
            {
                headerName = L"XMLExceptMsgs.hpp";
                errNameSpace = L"XML4CExcepts";
            }
             else
            {
                // Not one of ours, so skip it
                continue;
            }

            //
            //  Lets try to create the header file that was indicated for
            //  this domain.
            //
            swprintf
            (
                tmpFileBuf
                , L"%s%s"
                , gOutPath
                , headerName
            );
            FILE* outHeader = _wfopen(tmpFileBuf, L"wt+");
            if (!outHeader)
            {
                wprintf(L"Could not open domain header file: %s\n\n", tmpFileBuf);
                throw ErrReturn_OutFileOpenFailed;
            }

            //
            //  Write out the opening of the class they are nested within, and
            //  the header protection define.
            //
            fwprintf(outHeader, L"// This file is generated, don't edit it!!\n\n");
            fwprintf(outHeader, L"#if !defined(ERRHEADER_%s)\n", errNameSpace);
            fwprintf(outHeader, L"#define ERRHEADER_%s\n\n", errNameSpace);

            // If its not the exception domain, then we need a header included
            if (XMLString::compareString(domainStr, XMLUni::fgExceptDomain))
                fwprintf(outHeader, L"#include <framework/XMLErrorReporter.hpp>\n\n");

            fwprintf(outHeader, L"class %s\n{\npublic :\n    enum Codes\n    {\n", errNameSpace);

            // Tell the formatter that a new domain is starting
            formatter->startDomain(domainStr);

            //
            //  Force out the first message, which is always implicit and is
            //  the 'no error' entry for that domain.
            //
            unsigned int count = 0;
            fwprintf(outHeader, L"        %-32s   = %d\n", L"NoError", count++);

            //
            //  Loop through the children of this node, which should take us
            //  through the optional Warning, Error, and Validity subsections.
            //
            DOM_Node typeNode = curElem.getFirstChild();
            bool typeGotten[3] = { false, false, false };
            while (!typeNode.isNull())
            {
                // Skip over text nodes or comment nodes ect...
                if (typeNode.getNodeType() != DOM_Node::ELEMENT_NODE)
                {
                    typeNode = typeNode.getNextSibling();
                    continue;
                }

                // Convert it to an element node
                const DOM_Element& typeElem = (const DOM_Element&)typeNode;

                // Now get its tag name and convert that to a message type enum
                DOMString typeName = typeElem.getTagName();

                MsgTypes type;
                if (typeName.equals(L"Warning"))
                {
                    type = MsgType_Warning;
                    typeGotten[0] = true;
                }
                 else if (typeName.equals(L"Error"))
                {
                    if (!XMLString::compareString(domainStr, XMLUni::fgValidityDomain))
                    {
                        type = MsgType_Validity;
                        typeGotten[2] = true;
                    }
                     else
                    {
                        type = MsgType_Error;
                        typeGotten[1] = true;
                    }
                }
                 else
                {
                    wprintf(L"Expected a Warning or Errornode\n\n");
                    throw ErrReturn_SrcFmtError;
                }

                // Call the start message type event
                formatter->startMsgType(type);

                // Enumerate the messages under this subsection
                enumMessages
                (
                    typeElem
                    , formatter
                    , outHeader
                    , type
                    , count
                );

                // Call the end message type event
                formatter->endMsgType(type);

                // Move to the next child of the source element
                typeNode = typeNode.getNextSibling();
            }

            //
            //  For any that we did not get, spit out faux boundary
            //  values for it.
            //
            for (unsigned int subIndex = 0; subIndex < 3; subIndex++)
            {
                if (!typeGotten[subIndex])
                {
                    fwprintf
                    (
                        outHeader
                        , L"      , %s%-30s   = %d\n"
                        , typePrefixes[subIndex]
                        , L"LowBounds"
                        , count++
                    );
                    fwprintf
                    (
                        outHeader
                        , L"      , %s%-30s   = %d\n"
                        , typePrefixes[subIndex]
                        , L"HighBounds"
                        , count++
                    );
                }
            }

            // Tell the formatter that this domain is ending
            formatter->endDomain(domainStr, count);

            // Close out the enum declaration
            fwprintf(outHeader, L"    };\n\n");

            //
            //  Generate the code that creates the simple static methods
            //  for testing the error types. We don't do this for the
            //  exceptions header.
            //
            if (XMLString::compareString(domainStr, XMLUni::fgExceptDomain))
            {
                fwprintf
                (
                    outHeader
                    , L"    static bool isFatal(const %s::Codes toCheck)\n"
                      L"    {\n"
                      L"        return ((toCheck >= E_LowBounds) && (toCheck <= E_HighBounds));\n"
                      L"    }\n\n"
                    , errNameSpace
                );

                fwprintf
                (
                    outHeader
                    , L"    static bool isWarning(const %s::Codes toCheck)\n"
                      L"    {\n"
                      L"        return ((toCheck >= W_LowBounds) && (toCheck <= W_HighBounds));\n"
                      L"    }\n\n"
                    , errNameSpace
                );

                fwprintf
                (
                    outHeader
                    , L"    static bool isValid(const %s::Codes toCheck)\n"
                      L"    {\n"
                      L"        return ((toCheck >= V_LowBounds) && (toCheck <= V_HighBounds));\n"
                      L"    }\n\n"
                    , errNameSpace
                );

                fwprintf
                (
                    outHeader
                    , L"    static XMLErrorReporter::ErrTypes errorType(const %s::Codes toCheck)\n"
                      L"    {\n"
                      L"       if ((toCheck >= W_LowBounds) && (toCheck <= W_HighBounds))\n"
                      L"           return XMLErrorReporter::ErrType_Warning;\n"
                      L"       else if ((toCheck >= E_LowBounds) && (toCheck <= E_HighBounds))\n"
                      L"            return XMLErrorReporter::ErrType_Fatal;\n"
                      L"       else if ((toCheck >= V_LowBounds) && (toCheck <= V_HighBounds))\n"
                      L"            return XMLErrorReporter::ErrType_Invalid;\n"
                      L"       return XMLErrorReporter::ErrTypes_Unknown;\n"
                      L"    }\n"
                    , errNameSpace
                );
            }

            // And close out the class declaration and the header file
            fwprintf(outHeader, L"};\n#endif\n\n");
            fclose(outHeader);
        }

        // Ok, we are done so call the end output method
        formatter->endOutput();

        // And clean up the stuff we allocated
        delete formatter;
    }

    catch(const ErrReturns retVal)
    {
        return retVal;
    }

    // Went ok, so return success
    return ErrReturn_Success;
}


// -----------------------------------------------------------------------
//  XlatErrHandler: Implementation of the error handler interface
// -----------------------------------------------------------------------
void XlatErrHandler::warning(const SAXParseException& toCatch)
{
    parseError(toCatch);
}

void XlatErrHandler::error(const SAXParseException& toCatch)
{
    parseError(toCatch);
}

void XlatErrHandler::fatalError(const SAXParseException& toCatch)
{
    parseError(toCatch);
}

void XlatErrHandler::resetErrors()
{
}