/*
 * This file defines a signal handler used by VPR to catch SIGINT signals
 * (ctrl-C from terminal) on POSIX systems. It is only active if
 * VPR_USE_SIGACTION is defined.
 *
 * If a SIGINT occur the handler sets the 'forced_pause' flag of the VPR
 * context.  If 'forced_pause' is still true when another SIGINT occurs an
 * exception is thrown (typically ending the program).
 */
#include "vtr_log.h"
#include "vtr_time.h"

#include "vpr_signal_handler.h"
#include "vpr_exit_codes.h"
#include "vpr_error.h"
#include "globals.h"

#include "read_place.h"
#include "route_export.h"
#include <atomic>

#ifdef VPR_USE_SIGACTION
#include <csignal>
#endif

void vpr_signal_handler(int signal);
void checkpoint();

std::atomic<int> uncleared_sigint_count(0);

#ifdef VPR_USE_SIGACTION

    void vpr_install_signal_handler() {
        //Install the signal handler for SIGINT (i.e. ctrl+C from the terminal)
        struct sigaction sa;
        sa.sa_handler = vpr_signal_handler;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = 0; //Make sure the flags are cleared
        sigaction(SIGINT, &sa, nullptr); //Keyboard interrupt (1 pauses, 2 quits)
        sigaction(SIGHUP, &sa, nullptr); //Hangup (attempts to checkpoint)
        sigaction(SIGTERM, &sa, nullptr); //Terminate (attempts to checkpoint, then exit)
    }

    void vpr_signal_handler(int signal) {
        if (signal == SIGINT) {
            if (g_vpr_ctx.forced_pause()) {
                uncleared_sigint_count++; //Previous SIGINT uncleared
            } else {
                uncleared_sigint_count.store(1); //Only this SIGINT outstanding
            }

            if (uncleared_sigint_count == 1) {
                //Request a pause at the next reasonable point (e.g. to resume the GUI)
                VTR_LOG("Recieved SIGINT: Attempting to pause...\n");
                g_vpr_ctx.set_forced_pause(true);
            } else if (uncleared_sigint_count == 2) {
                VTR_LOG("Recieved two uncleared SIGINTs: Attempting to checkpoint and exit...\n");
                checkpoint();
                std::quick_exit(INTERRUPTED_EXIT_CODE);
            } else if (uncleared_sigint_count == 3) {
                //Really exit (e.g. SIGINT while checkpointing)
                VTR_LOG("Recieved three uncleared SIGINTs: Exiting...\n");
                std::quick_exit(INTERRUPTED_EXIT_CODE);
            }
        } else if (signal == SIGHUP) {
            VTR_LOG("Recieved SIGHUP: Attempting to checkpoint...\n");
            checkpoint();
        } else if (signal == SIGTERM) {
            VTR_LOG("Recieved SIGTERM: Attempting to checkpoint then exit...\n");
            checkpoint();
            std::quick_exit(INTERRUPTED_EXIT_CODE);
        }
    }

#else
    //No signal support all operations are no-ops

    void vpr_install_signal_handler() {
        //Do nothing
    }

    void vpr_signal_handler(int /*signal*/) {
        //Do nothing
    }

#endif

void checkpoint() {
    //Dump the current placement and routing state
    vtr::ScopedStartFinishTimer timer("Checkpointing");

    std::string placer_checkpoint_file = "placer_checkpoint.place";
    VTR_LOG("Attempting to checkpoint current placement to file: %s\n", placer_checkpoint_file.c_str());
    print_place(nullptr, nullptr, placer_checkpoint_file.c_str());

    std::string router_checkpoint_file = "router_checkpoint.route";
    VTR_LOG("Attempting to checkpoint current routing to file: %s\n", router_checkpoint_file.c_str());
    print_route(nullptr, router_checkpoint_file.c_str());
}