// ConvertLogToRow.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"
#include <atldbcli.h>
#include <sqloledb.h>
#include <Log/ServerLog.h>
#include <Log/ParseLog.h>
#include <Log/LogCommands.h>

#include <set>
#include <string>
#include <algorithm>
#include <ctime>

#define LOG_CONVERT0(str) { ERRLOG0(g_Log, (str)); printf(str "\n"); }
#define LOG_CONVERT1(str, arg1) { ERRLOG1(g_Log, (str), (arg1)); printf(str "\n", (arg1)); }
#define LOG_CONVERT2(str, arg1, arg2) { ERRLOG2(g_Log, (str), (arg1), (arg2)); printf(str "\n", (arg1), (arg2)); }


class CProcessLogToRow
{
public:

    typedef ATL::CCommand<ATL::CDynamicParameterAccessor> LogCommand;

    CProcessLogToRow(ATL::CSession& session) : m_Session(session) { }
    ~CProcessLogToRow() { }

    HRESULT Initialize();
    HRESULT Process(const TCHAR* szLogFileName);

private:

    HRESULT LogMonsterDead(__int64 nLogKey, const GAMELOG::sMonsterDeadLog* lpLog);

    ATL::CSession& m_Session;    

    LogCommand m_MonsterDeadCmd;
    LogCommand m_MonsterDropCmd;
};


int _tmain(int argc, _TCHAR* argv[])
{
    // DB에 연결한다.
    // 테이블을 날리고 다시 만든다.
    // 로그를 분석해서 테이블에 Row를 넣는다.
    // 현재는 몇몇 Log만 분석해서 테이블에 넣도록 한다. 나중에 차차 추가한다.

    if (6 != argc)
    {
        return false;
    }

    CoInitialize(0);

    HRESULT hr = S_OK;

    ATL::CDataSource    ds;
    ATL::CSession       session;
    ATL::CDBPropSet     dsPropSet;

    dsPropSet.SetGUID(DBPROPSET_DBINIT);    
    dsPropSet.AddProperty(DBPROP_INIT_DATASOURCE,   argv[1]);
    dsPropSet.AddProperty(DBPROP_INIT_CATALOG,      argv[2]);
    dsPropSet.AddProperty(DBPROP_AUTH_USERID,       argv[3]);
    dsPropSet.AddProperty(DBPROP_AUTH_PASSWORD,     argv[4]);

    // 데이터베이스 오픈        
    if (FAILED(hr = ds.Open(CLSID_SQLOLEDB, &dsPropSet, 1)))
    {
        LOG_CONVERT1("DB연결 실패 : hr:0%08x", hr);
    }
    else if (FAILED(hr = session.Open(ds)))
    {
        LOG_CONVERT1("세션 연결 실패 : hr:0x%08x", hr);
    }
    else 
    {
        CProcessLogToRow logToLow(session);

        if (FAILED(hr = logToLow.Initialize()))
        {
            LOG_CONVERT1("로그 초기화 실패 : hr:0x%08x", hr);
        }
        else if (FAILED(hr = logToLow.Process(argv[5])))
        {
            LOG_CONVERT1("로그 처리 실패 : hr:0x%08x", hr);
        }
    }

    session.Close();
    ds.Close();

    CoUninitialize();
	return 0;
}

HRESULT CreateCommand(ATL::CSession& Session, CProcessLogToRow::LogCommand& Cmd, 
                      LPCTSTR szQuery, LPCTSTR szCommandName)
{
    HRESULT hr = S_OK;
    void* pDummy = 0;

    if (FAILED(hr = Cmd.Create(Session, szQuery)))
    {
        LOG_CONVERT2("%s 커맨드 생성 실패 : hr:0x%08x", szCommandName, hr);
    }
    else if (FAILED(hr = Cmd.Prepare()))
    {
        LOG_CONVERT2("%s 커맨드 준비 실패 : hr:0x%08x", szCommandName, hr);
    }
    else if (FAILED(hr = Cmd.BindParameters( 
        &(Cmd.m_hParameterAccessor), Cmd.m_spCommand, &pDummy, true, true )))
    {
        LOG_CONVERT2("%s 커맨드 파라미터 바인딩 실패 : hr:0x%08x", szCommandName, hr);
    }

    return hr;
}

HRESULT CProcessLogToRow::Initialize()
{
    HRESULT hr = S_OK;
    ATL::CCommand<> tableCommand;

    tableCommand.Open(m_Session, "DROP TABLE RYLMonsterDropLog");
    tableCommand.Open(m_Session, "DROP TABLE RYLMonsterDeadLog");
    tableCommand.Open(m_Session, "DROP TABLE RYLLog");
    tableCommand.Open(m_Session, "DROP PROC InsertRYLLog");
    
    if (FAILED(hr = tableCommand.Open(m_Session, 
        "CREATE TABLE RYLLog ("
        "LogID bigint PRIMARY KEY IDENTITY(1000000, 1), "
        "UID int, "
        "CID int, "
        "PosX smallint, "
        "PosZ smallint, "
        "Time smalldatetime, "
        "Cmd tinyint, "
        "Err tinyint) ")))
    {
        LOG_CONVERT1("로그 테이블 생성 실패 : hr:0x%08x", hr);
    }
    else if (FAILED(hr = tableCommand.Open(m_Session,
        "CREATE PROC InsertRYLLog @UID int, @CID int, @PosX smallint,  "
        "@PosZ smallint, @Time smalldatetime, @Cmd tinyint, @Err tinyint, @LogUID bigint output \n"
        "AS \n"        
        "	INSERT INTO RYLLog (UID, CID, PosX, PosZ, Time, Cmd, Err) "
        "	values (@UID, @CID, @PosX,  @PosZ, @Time, @Cmd, @Err)  \n"
        "	SET @LogUID = SCOPE_IDENTITY() \n")))
    {
        LOG_CONVERT1("로그 프로시저 생성 실패 : hr:0x%08x", hr);
    }
    else if (FAILED(hr = tableCommand.Open(m_Session,
        "CREATE TABLE RYLMonsterDropLog ("
        "LogID bigint, "
        "PrototypeID int, "
        "FOREIGN KEY (LogID) REFERENCES RYLLog(LogID))")))
    {
        LOG_CONVERT1("몬스터 드랍 테이블 생성 실패 : hr:0x%08x", hr);
    }
    else if (FAILED(hr = tableCommand.Open(m_Session,
        "CREATE TABLE RYLMonsterDeadLog ("
        "LogID bigint, "
        "MonsterCID int, "
        "MonsterLevel tinyint, "
        "FOREIGN KEY (LogID) REFERENCES RYLLog(LogID))")))
    {
        LOG_CONVERT1("몬스터 사망 테이블 생성 실패 : hr:0x%08x", hr);
    }  
    // 커맨드 생성
    else if (FAILED(hr = CreateCommand(m_Session, m_MonsterDeadCmd, 
        "INSERT INTO RYLMonsterDeadLog (LogID, MonsterCID, MonsterLevel) values (?, ?, ?)",
        "몬스터 사망 삽입")))
    {
        LOG_CONVERT1("몬스터 사망 삽입 커맨드 생성 실패 : hr:0x%08x", hr);
    }
    else if (FAILED(hr = CreateCommand(m_Session, m_MonsterDropCmd, 
        "INSERT INTO RYLMonsterDropLog (LogID, PrototypeID) values (?, ?)",
        "몬스터 아이템 드롭 삽입")))
    {
        LOG_CONVERT1("몬스터 사망 삽입 커맨드 생성 실패 : hr:0x%08x", hr);
    }

    return hr;
}

HRESULT CProcessLogToRow::Process(const TCHAR* szLogFileName)
{
    HRESULT hr = S_OK;

    typedef std::set<std::string> LogFileSet;
    LogFileSet logFileSet;

    WIN32_FIND_DATA findData;
    memset(&findData, 0, sizeof(WIN32_FIND_DATA));

    HANDLE hFileFind = FindFirstFile(szLogFileName, &findData);

    if (INVALID_HANDLE_VALUE != hFileFind)
    {
        do
        {
            logFileSet.insert(findData.cFileName);
        }
        while (FindNextFile(hFileFind, &findData));

        FindClose(hFileFind);
    }

    LogFileSet::iterator pos = logFileSet.begin();
    LogFileSet::iterator end = logFileSet.end();

    CParseLog parseLog;
    CProcessLogToRow::LogCommand dynamicCommand;
    
    if (FAILED(hr = CreateCommand(m_Session, dynamicCommand, 
        "exec InsertRYLLog ?, ?, ?, ?, ?, ?, ?, ? output",
        "로그 삽입")))
    {
        LOG_CONVERT1("로그 삽입 커맨드 생성 실패: hr:0x%08x", hr);
    }
    else
    {
        int nFileCount = 0;

        for (; pos != end; ++pos, ++nFileCount)
        {
            if (!parseLog.LoadFile(pos->c_str()))
            {
                LOG_CONVERT1("로그 읽기 실패 : 파일명:%s", pos->c_str());
            }
            else
            {
                const CParseLog::LogPtrArray& logPtrArray = parseLog.GetLogPtrArray();

                CParseLog::LogPtrArray::const_iterator ptr_pos = logPtrArray.begin();
                CParseLog::LogPtrArray::const_iterator ptr_end = logPtrArray.end();

                int nCount = 0;
                for (; ptr_pos != ptr_end; ++ptr_pos, ++nCount)
                {
                    const GAMELOG::sLogBase* lpLog = *ptr_pos;

                    // 항목을 삽입한 후 SCOPED_IDENTITY로 key값을 가져온다.
                    // 로그 타입에 따라서 추가적으로 다른 테이블에 값을 넣는다.

                    DBTIMESTAMP timeStamp;
                    tm* lpTime = localtime(&lpLog->m_time);

                    if (0 != lpTime && GAMELOG::CMD::MONSTER_DEAD == lpLog->m_cCmd)
                    {
                        timeStamp.year      = lpTime->tm_year + 1900;
                        timeStamp.month     = lpTime->tm_mon + 1;
                        timeStamp.day       = lpTime->tm_mday;
                        timeStamp.hour      = lpTime->tm_hour;
                        timeStamp.minute    = lpTime->tm_min;
                        timeStamp.second    = lpTime->tm_sec;
                        timeStamp.fraction  = 0;

                        __int64 logKey = 0LL;

                        dynamicCommand.SetParam(1, &lpLog->m_dwUID);
                        dynamicCommand.SetParam(2, &lpLog->m_dwCID);
                        dynamicCommand.SetParam(3, &lpLog->m_usXPos);
                        dynamicCommand.SetParam(4, &lpLog->m_usZPos);
                        dynamicCommand.SetParam(5, &timeStamp);
                        dynamicCommand.SetParam(6, &lpLog->m_cCmd);
                        dynamicCommand.SetParam(7, &lpLog->m_cErr);
                        dynamicCommand.SetParam(8, &logKey);

                        if (FAILED(hr = dynamicCommand.Open()))
                        {
                            LOG_CONVERT1("DB에 로그 삽입 실패 : hr:0x%08x", hr);
                        }
                        else if (dynamicCommand.GetParam(8, &logKey))
                        {
                            // 나머지를 삽입한다.
                           switch (lpLog->m_cCmd)
                           {
                           case GAMELOG::CMD::MONSTER_DEAD: 
                               LogMonsterDead(logKey, static_cast<const GAMELOG::sMonsterDeadLog*>(lpLog));
                               break;
                           }
                        }

                        // 로그 출력
                        if (0 == (nCount % 1000))
                        {
                            printf("(%d/%d)%s (%d/%d)\n", 
                                nFileCount, logFileSet.size(), 
                                pos->c_str(), nCount, logPtrArray.size());
                        }
                    }
                }

                printf("(%d/%d)%s (%d/%d)\n", 
                    nFileCount, logFileSet.size(), 
                    pos->c_str(), nCount, logPtrArray.size());
            }
        }
    }

    return hr;
}

HRESULT CProcessLogToRow::LogMonsterDead(__int64 nLogKey, const GAMELOG::sMonsterDeadLog* lpLog)
{
    HRESULT hr = S_OK;

    m_MonsterDeadCmd.SetParam(1, &nLogKey);
    m_MonsterDeadCmd.SetParam(2, &lpLog->m_dwMonsterCID);
    m_MonsterDeadCmd.SetParam(3, &lpLog->m_cMonsterLevel);

    if (FAILED(hr = m_MonsterDeadCmd.Open()))
    {
        LOG_CONVERT1("몬스터 사망 삽입 실패 : hr:0x%08x", hr);
    }
    else
    {
        for (int nCount = 0; nCount < lpLog->m_cDropItemNum; ++nCount)
        {
            m_MonsterDropCmd.SetParam(1, &nLogKey);
            m_MonsterDropCmd.SetParam(2, reinterpret_cast<const int*>(lpLog+1) + nCount);

            if (FAILED(hr = m_MonsterDropCmd.Open()))
            {
                LOG_CONVERT1("몬스터 아이템 드롭 삽입 실패 : hr:0x%08x", hr);
                break;
            }
        }
    }

    return hr;
}