/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include <signal.h>

#include <cstring>
#include <iostream>
#include <sstream>
#include <functional>
#include <map>

#include <tbox/base/log.h>
#include <tbox/base/scope_exit.hpp>
#include <tbox/base/backtrace.h>

#define TBOX_USE_SIGACTION

int main(int argc, char **argv);

namespace tbox {
namespace main {

extern void AbnormalExit();

namespace {

#ifdef  TBOX_USE_SIGACTION
using SignalHandler = struct sigaction;
#else
using SignalHandler = void (*) (int);
#endif

std::map<int, SignalHandler> _old_handler_map;

bool _is_recursion_call = false;

#ifdef  TBOX_USE_SIGACTION
void InvokeOldHandler(int signo, siginfo_t *siginfo, void *context)
#else
void InvokeOldHandler(int signo)
#endif
{
    auto iter = _old_handler_map.find(signo);
    if (iter == _old_handler_map.end())
        return;

    const auto &old_handler = iter->second;

#ifdef  TBOX_USE_SIGACTION
    if (old_handler.sa_flags & SA_SIGINFO) {
        if (old_handler.sa_sigaction)
            old_handler.sa_sigaction(signo, siginfo, context);
    } else {
        if (SIG_ERR != old_handler.sa_handler &&
            SIG_IGN != old_handler.sa_handler &&
            SIG_DFL != old_handler.sa_handler)
            old_handler.sa_handler(signo);
    }
#else
    if (SIG_ERR != old_handler &&
        SIG_IGN != old_handler &&
        SIG_DFL != old_handler)
        old_handler(signo);
#endif
}

//! 处理程序运行异常信号
#ifdef TBOX_USE_SIGACTION
void OnErrorSignal(int signo, siginfo_t *siginfo, void *context)
#else
void OnErrorSignal(int signo)
#endif
{
#ifdef TBOX_USE_SIGACTION
    InvokeOldHandler(signo, siginfo, context);
#else
    InvokeOldHandler(signo);
#endif

    if (!_is_recursion_call) {
        _is_recursion_call = true;

        LogFatal("Receive signal %d", signo);

        const std::string &stack_str = DumpBacktrace();
        LogFatal("main: <%p>\n-----call stack-----\n%s", ::main, stack_str.c_str());

        _is_recursion_call = false;

    } else {
        LogFatal("Recursion signal %d", signo);
    }

    AbnormalExit();
}

bool InstallSignal(int signo)
{
    SignalHandler old_handler;
    bool is_succ = false;

#ifdef TBOX_USE_SIGACTION
    struct sigaction new_handler;
    memset(&new_handler, 0, sizeof(new_handler));
    sigemptyset(&new_handler.sa_mask);
    new_handler.sa_sigaction = OnErrorSignal;
    new_handler.sa_flags = SA_SIGINFO;
    ssize_t ret = ::sigaction(signo, &new_handler, &old_handler);
    is_succ = (ret != -1);
#else
    old_handler = ::signal(signo, OnErrorSignal);
    is_succ = (SIG_ERR != old_handler);
#endif

    _old_handler_map[signo] = old_handler;
    return is_succ;
}

}

void InstallErrorSignals()
{
    //! 要禁止信号触发
    sigset_t new_sigmask, old_sigmask;
    sigfillset(&new_sigmask);
    sigprocmask(SIG_BLOCK, &new_sigmask, &old_sigmask);
    SetScopeExitAction([&] { sigprocmask(SIG_SETMASK, &old_sigmask, 0); });

    //! 注册信号处理函数
    InstallSignal(SIGSEGV);
    InstallSignal(SIGILL);
    InstallSignal(SIGABRT);
    InstallSignal(SIGBUS);
    InstallSignal(SIGFPE);
    InstallSignal(SIGSYS);
}

void UninstallErrorSignals()
{
    //! 要禁止信号触发
    sigset_t new_sigmask, old_sigmask;
    sigfillset(&new_sigmask);
    sigprocmask(SIG_BLOCK, &new_sigmask, &old_sigmask);
    SetScopeExitAction([&] { sigprocmask(SIG_SETMASK, &old_sigmask, 0); });

    for (auto &item : _old_handler_map) {
        int signo = item.first;
        auto &old_handler = item.second;

#ifdef TBOX_USE_SIGACTION
        ::sigaction(signo, &old_handler, nullptr);
#else
        if (old_handler != SIG_ERR)
            ::signal(signo, old_handler);
#endif
    }
    _old_handler_map.clear();
}

}
}