/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#if (defined(WIN32) || defined(_WIN32)) && !defined(_WIN32_WCE)

#include <apr_strings.h>

#include <log4cxx/nt/nteventlogappender.h>
#include <log4cxx/spi/loggingevent.h>
#include <log4cxx/helpers/loglog.h>
#include <log4cxx/level.h>
#include <log4cxx/helpers/stringhelper.h>
#include <log4cxx/helpers/transcoder.h>
#include <log4cxx/helpers/pool.h>

using namespace log4cxx;
using namespace log4cxx::spi;
using namespace log4cxx::helpers;
using namespace log4cxx::nt;

class CCtUserSIDHelper
{
    public:
        static bool FreeSid(SID* pSid)
        {
            return ::HeapFree(GetProcessHeap(), 0, (LPVOID)pSid) != 0;
        }

        static bool CopySid(SID * * ppDstSid, SID* pSrcSid)
        {
            bool bSuccess = false;

            DWORD dwLength = ::GetLengthSid(pSrcSid);
            *ppDstSid = (SID*) ::HeapAlloc(GetProcessHeap(),
                                           HEAP_ZERO_MEMORY, dwLength);

            if (::CopySid(dwLength, *ppDstSid, pSrcSid))
            {
                bSuccess = true;
            }
            else
            {
                FreeSid(*ppDstSid);
            }

            return bSuccess;
        }

        static bool GetCurrentUserSID(SID * * ppSid)
        {
            bool bSuccess = false;

            // Pseudohandle so don't need to close it
            HANDLE hProcess = ::GetCurrentProcess();
            HANDLE hToken = NULL;

            if (::OpenProcessToken(hProcess, TOKEN_QUERY, &hToken))
            {
                // Get the required size
                DWORD tusize = 0;
                GetTokenInformation(hToken, TokenUser, NULL, 0, &tusize);
                TOKEN_USER* ptu = (TOKEN_USER*)new BYTE[tusize];

                if (GetTokenInformation(hToken, TokenUser, (LPVOID)ptu, tusize, &tusize))
                {
                    bSuccess = CopySid(ppSid, (SID*)ptu->User.Sid);
                }

                CloseHandle(hToken);
                delete [] ptu;
            }

            return bSuccess;
        }
};

IMPLEMENT_LOG4CXX_OBJECT(NTEventLogAppender)

NTEventLogAppender::NTEventLogAppender() : hEventLog(NULL), pCurrentUserSID(NULL)
{
}

NTEventLogAppender::NTEventLogAppender(const LogString& server, const LogString& log, const LogString& source, const LayoutPtr& layout)
    : server(server), log(log), source(source), hEventLog(NULL), pCurrentUserSID(NULL)
{
    this->layout = layout;
    Pool pool;
    activateOptions(pool);
}

NTEventLogAppender::~NTEventLogAppender()
{
    finalize();
}


void NTEventLogAppender::close()
{
    if (hEventLog != NULL)
    {
        ::DeregisterEventSource(hEventLog);
        hEventLog = NULL;
    }

    if (pCurrentUserSID != NULL)
    {
        CCtUserSIDHelper::FreeSid((::SID*) pCurrentUserSID);
        pCurrentUserSID = NULL;
    }
}

void NTEventLogAppender::setOption(const LogString& option, const LogString& value)
{
    if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SERVER"), LOG4CXX_STR("server")))
    {
        server = value;
    }
    else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("LOG"), LOG4CXX_STR("log")))
    {
        log = value;
    }
    else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SOURCE"), LOG4CXX_STR("source")))
    {
        source = value;
    }
    else
    {
        AppenderSkeleton::setOption(option, value);
    }
}

void NTEventLogAppender::activateOptions(Pool&)
{
    if (source.empty())
    {
        LogLog::warn(
            ((LogString) LOG4CXX_STR("Source option not set for appender ["))
            + name + LOG4CXX_STR("]."));
        return;
    }

    if (log.empty())
    {
        log = LOG4CXX_STR("Application");
    }

    close();

    // current user security identifier
    CCtUserSIDHelper::GetCurrentUserSID((::SID**) &pCurrentUserSID);

    addRegistryInfo();

    LOG4CXX_ENCODE_WCHAR(wsource, source);
    LOG4CXX_ENCODE_WCHAR(wserver, server);
    hEventLog = ::RegisterEventSourceW(
                    wserver.empty() ? NULL : wserver.c_str(),
                    wsource.c_str());

    if (hEventLog == NULL)
    {
        LogString msg(LOG4CXX_STR("Cannot register NT EventLog -- server: '"));
        msg.append(server);
        msg.append(LOG4CXX_STR("' source: '"));
        msg.append(source);
        LogLog::error(msg);
        LogLog::error(getErrorString(LOG4CXX_STR("RegisterEventSource")));
    }
}

void NTEventLogAppender::append(const LoggingEventPtr& event, Pool& p)
{
    if (hEventLog == NULL)
    {
        LogLog::warn(LOG4CXX_STR("NT EventLog not opened."));
        return;
    }

    LogString oss;
    layout->format(oss, event, p);
    wchar_t* msgs = Transcoder::wencode(oss, p);
    BOOL bSuccess = ::ReportEventW(
                        hEventLog,
                        getEventType(event),
                        getEventCategory(event),
                        0x1000,
                        pCurrentUserSID,
                        1,
                        0,
                        (LPCWSTR*) &msgs,
                        NULL);

    if (!bSuccess)
    {
        LogLog::error(getErrorString(LOG4CXX_STR("ReportEvent")));
    }
}

/*
 * Add this source with appropriate configuration keys to the registry.
 */
void NTEventLogAppender::addRegistryInfo()
{
    DWORD disposition = 0;
    ::HKEY hkey = 0;
    LogString subkey(LOG4CXX_STR("SYSTEM\\CurrentControlSet\\Services\\EventLog\\"));
    subkey.append(log);
    subkey.append(1, (logchar) 0x5C /* '\\' */);
    subkey.append(source);
    LOG4CXX_ENCODE_WCHAR(wsubkey, subkey);

    long stat = RegCreateKeyExW(HKEY_LOCAL_MACHINE, wsubkey.c_str(), 0, NULL,
                                REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL,
                                &hkey, &disposition);

    if (stat == ERROR_SUCCESS && disposition == REG_CREATED_NEW_KEY)
    {
        HMODULE hmodule = GetModuleHandleW(L"log4cxx");

        if (hmodule == NULL)
        {
            hmodule = GetModuleHandleW(0);
        }

        wchar_t modpath[_MAX_PATH];
        DWORD modlen = GetModuleFileNameW(hmodule, modpath, _MAX_PATH - 1);

        if (modlen > 0)
        {
            modpath[modlen] = 0;
            RegSetValueExW(hkey, L"EventMessageFile", 0, REG_SZ,
                           (LPBYTE) modpath, wcslen(modpath) * sizeof(wchar_t));
            RegSetValueExW(hkey, L"CategoryMessageFile", 0, REG_SZ,
                           (LPBYTE) modpath, wcslen(modpath) * sizeof(wchar_t));
            DWORD typesSupported = 7;
            DWORD categoryCount = 6;
            RegSetValueExW(hkey, L"TypesSupported", 0, REG_DWORD,
                           (LPBYTE)&typesSupported, sizeof(DWORD));
            RegSetValueExW(hkey, L"CategoryCount", 0, REG_DWORD,
                           (LPBYTE)&categoryCount, sizeof(DWORD));
        }
    }

    RegCloseKey(hkey);
    return;
}

WORD NTEventLogAppender::getEventType(const LoggingEventPtr& event)
{
    int priority = event->getLevel()->toInt();
    WORD type = EVENTLOG_SUCCESS;

    if (priority >= Level::INFO_INT)
    {
        type = EVENTLOG_INFORMATION_TYPE;

        if (priority >= Level::WARN_INT)
        {
            type = EVENTLOG_WARNING_TYPE;

            if (priority >= Level::ERROR_INT)
            {
                type = EVENTLOG_ERROR_TYPE;
            }
        }
    }

    return type;
}

WORD NTEventLogAppender::getEventCategory(const LoggingEventPtr& event)
{
    int priority = event->getLevel()->toInt();
    WORD category = 1;

    if (priority >= Level::DEBUG_INT)
    {
        category = 2;

        if (priority >= Level::INFO_INT)
        {
            category = 3;

            if (priority >= Level::WARN_INT)
            {
                category = 4;

                if (priority >= Level::ERROR_INT)
                {
                    category = 5;

                    if (priority >= Level::FATAL_INT)
                    {
                        category = 6;
                    }
                }
            }
        }
    }

    return category;
}

LogString NTEventLogAppender::getErrorString(const LogString& function)
{
    Pool p;
    enum { MSGSIZE = 5000 };

    wchar_t* lpMsgBuf = (wchar_t*) p.palloc(MSGSIZE * sizeof(wchar_t));
    DWORD dw = GetLastError();

    FormatMessageW(
        FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        lpMsgBuf,
        MSGSIZE, NULL );

    LogString msg(function);
    msg.append(LOG4CXX_STR(" failed with error "));
    StringHelper::toString((size_t) dw, p, msg);
    msg.append(LOG4CXX_STR(": "));
    Transcoder::decode(lpMsgBuf, msg);

    return msg;
}

#endif // WIN32