#include "stdafx.h"
#include "Config.h"
#include "Peer.h"
#include "DBManager.h"
#include "ClientManager.h"
#include "GuildManager.h"
#include "ItemAwardManager.h"
#include "HB.h"
#include "PrivManager.h"
#include "MoneyLog.h"
#include "Marriage.h"
#include "Monarch.h"
#include "BlockCountry.h"
#include "ItemIDRangeManager.h"
#ifdef __AUCTION__
#include "AuctionManager.h"
#endif
#include <signal.h>
#include "Main.h"

void SetPlayerDBName(const char* c_pszPlayerDBName);
void SetTablePostfix(const char* c_pszTablePostfix);
int Start();
std::string g_stLocaleNameColumn = "name";
std::string g_stPlayerDBName;
//uint32_t g_cache_flush_limit_per_second;
bool g_bHotBackup;
//bool g_test_server;
//bool iDisableHotBackup;
int g_iItemCacheFlushSeconds;
int g_iLogoutSeconds = 60*10;
int iRetry = 5;

#if defined(__FreeBSD__) && defined(__FreeBSD_version) && __FreeBSD_version<1000000
extern const char * _malloc_options;
#endif

extern void WriteVersion();

void emergency_sig(int sig)
{
    if (sig == SIGSEGV)
        sys_log(0, "SIGNAL: SIGSEGV");
    else if (sig == SIGUSR1)
        sys_log(0, "SIGNAL: SIGUSR1");

    if (sig == SIGSEGV)
        abort();
}

int main()
{
    WriteVersion();

#if defined(__FreeBSD__) && defined(__FreeBSD_version) && __FreeBSD_version<1000000
    _malloc_options = "A";
#endif

    CConfig Config;
    CNetPoller poller;
    CDBManager DBManager;
    CClientManager ClientManager;
    PlayerHB player_hb;
    CGuildManager GuildManager;
    CPrivManager PrivManager;
    CMoneyLog MoneyLog;
    ItemAwardManager ItemAwardManager;
    marriage::CManager MarriageManager;
    CMonarch Monarch;
    CBlockCountry   BlockCountry;
    CItemIDRangeManager ItemIDRangeManager;
#ifdef __AUCTION__
    AuctionManager auctionManager;
#endif
    if (!Start())
        return 1;

    GuildManager.Initialize();
    MarriageManager.Initialize();
    BlockCountry.Load();
    ItemIDRangeManager.Build();
#ifdef __AUCTION__
    AuctionManager::instance().Initialize();
#endif
    sys_log(0, "Metin2DBCacheServer Start\n");

    CClientManager::instance().MainLoop();

    signal_timer_disable();

    DBManager.Quit();
    int iCount;

    while (1)
    {
        iCount = 0;

        iCount += CDBManager::instance().CountReturnQuery(SQL_PLAYER);
        iCount += CDBManager::instance().CountAsyncQuery(SQL_PLAYER);

        if (iCount == 0)
            break;

        usleep(1000);
        sys_log(0, "WAITING_QUERY_COUNT %d", iCount);
    }

    return 1;
}

void emptybeat(LPHEART heart, int pulse)
{
    if (!(pulse % heart->passes_per_sec))
    {
        return;
    }
}

int Start()
{
    thecore_init(heart_beat_value, emptybeat);
    signal_timer_enable(60);
    SetTablePostfix(g_stTablePostfix);
    CClientManager::instance().SetPlayerIDStart(g_iIDStart);
    {
        {
            int iRetry = 5;
            do
            {
                if (CDBManager::Instance().Connect(SQL_PLAYER,
                    sz_hostname, sz_port,
                    sz_player, sz_user,
                    sz_password)
                    )
                {
                    sys_log(0, "Connected to %s database!", sz_player);
                    break;
                }
                sys_err("Error to connect : %s", sz_player);
                sleep(5);
            } while (iRetry--);
        }
        {
            int iRetry = 5;
            do
            {
                if (CDBManager::Instance().Connect(SQL_PLAYER,
                    sz_hostname,
                    sz_port,
                    sz_account,
                    sz_user,
                    sz_password)
                    )
                {
                    sys_log(0, "Connected to %s database!", sz_account);
                    break;
                }
                sys_err("Error to connect : %s", sz_account);
                sleep(5);
            } while (iRetry--);
        }
        {
            int iRetry = 5;
            do
            {
                if (CDBManager::Instance().Connect(SQL_COMMON,
                    sz_hostname,
                    sz_port,
                    sz_common,
                    sz_user,
                    sz_password)
                    )
                {
                    sys_log(0, "Connected to %s database!", sz_common);
                    break;
                }
                sys_err("Error to connect : %s", sz_common);
                sleep(5);
            } while (iRetry--);
        }
        {
            int iRetry = 5;
            do
            {
                if (CDBManager::Instance().Connect(SQL_HOTBACKUP,
                    sz_hostname,
                    sz_port,
                    sz_hotbackup,
                    sz_user, sz_password))
                {
                    sys_log(0, "Connected to %s database!", sz_hotbackup);
                    break;
                }
                sys_err("Error to connect : %s", sz_hotbackup);
                sleep(5);
            } while (iRetry--);
        }
    }

    SetPlayerDBName(sz_player);

    if (!CNetPoller::instance().Create())
    {
        sys_err("Cannot create network poller");
        return false;
    }

    sys_log(0, "ClientManager initialization.. ");

    if (!CClientManager::instance().Initialize())
    {
        sys_log(0, "   failed");
        return false;
    }

    sys_log(0, "   OK");

    if (!PlayerHB::instance().Initialize())
    {
        sys_err("cannot initialize player hotbackup");
        return false;
    }

#ifndef __WIN32__
    signal(SIGUSR1, emergency_sig);
#endif
    signal(SIGSEGV, emergency_sig);
    return true;
}

void SetTablePostfix(const char* c_pszTablePostfix)
{
    if (!c_pszTablePostfix || !*c_pszTablePostfix)
        g_stTablePostfix = "";
    else
        g_stTablePostfix = c_pszTablePostfix;
}

const char * GetTablePostfix()
{
    return g_stTablePostfix;
}

void SetPlayerDBName(const char* c_pszPlayerDBName)
{
    if (! c_pszPlayerDBName || ! *c_pszPlayerDBName)
        g_stPlayerDBName = "";
    else
    {
        g_stPlayerDBName = c_pszPlayerDBName;
        g_stPlayerDBName += ".";
    }
}

const char * GetPlayerDBName()
{
    return g_stPlayerDBName.c_str();
}