// Copyright (c) 2016 The Zcash developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include "asyncrpcoperation.h"

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>

#include <string>
#include <ctime>
#include <chrono>

using namespace std;
using namespace json_spirit;

static boost::uuids::random_generator uuidgen;

std::map<OperationStatus, std::string> OperationStatusMap = {
    {OperationStatus::READY, "queued"},
    {OperationStatus::EXECUTING, "executing"},
    {OperationStatus::CANCELLED, "cancelled"},
    {OperationStatus::FAILED, "failed"},
    {OperationStatus::SUCCESS, "success"}
};

/**
 * Every operation instance should have a globally unique id
 */
AsyncRPCOperation::AsyncRPCOperation() : error_code_(0), error_message_() {
    // Set a unique reference for each operation
    boost::uuids::uuid uuid = uuidgen();
    std::string s = "opid-" + boost::uuids::to_string(uuid);
    set_id(s);
    
    set_state(OperationStatus::READY);
    creation_time_ = (int64_t)time(NULL);
}

AsyncRPCOperation::AsyncRPCOperation(const AsyncRPCOperation& o) : id_(o.id_), creation_time_(o.creation_time_), state_(o.state_.load())
{
}

AsyncRPCOperation& AsyncRPCOperation::operator=( const AsyncRPCOperation& other ) {
    this->id_ = other.getId();
    this->creation_time_ = other.creation_time_;
    this->state_.store(other.state_.load());
    return *this;
}


AsyncRPCOperation::~AsyncRPCOperation() {
}

/**
 * Override this cancel() method if you can interrupt main() when executing.
 */
void AsyncRPCOperation::cancel() {
    if (isReady()) {
        set_state(OperationStatus::CANCELLED);
    }
}

/**
 * Start timing the execution run of the code you're interested in
 */
void AsyncRPCOperation::start_execution_clock() {
    start_time_ = std::chrono::system_clock::now();
}

/**
 * Stop timing the execution run
 */
void AsyncRPCOperation::stop_execution_clock() {
    end_time_ = std::chrono::system_clock::now();
}

/**
 * Implement this virtual method in any subclass.  This is just an example implementation.
 */
void AsyncRPCOperation::main() {
    if (isCancelled()) {
        return;
    }
    
    set_state(OperationStatus::EXECUTING);

    start_execution_clock();

    // Do some work here..

    stop_execution_clock();

    // If there was an error, you might set it like this:
    /*
    setErrorCode(123);
    setErrorMessage("Murphy's law");
    setState(OperationStatus::FAILED);
    */

    // Otherwise, if the operation was a success:
    Value v("We have a result!");
    set_result(v);
    set_state(OperationStatus::SUCCESS);
}

/**
 * Return the error of the completed operation as a Value object.
 */
Value AsyncRPCOperation::getError() const {
    if (!isFailed()) {
        return Value::null;
    }

    Object error;
    error.push_back(Pair("code", this->error_code_));
    error.push_back(Pair("message", this->error_message_));
    return Value(error);
}

/**
 * Return the result of the completed operation as a Value object.
 */
Value AsyncRPCOperation::getResult() const {
    if (!isSuccess()) {
        return Value::null;
    }

    return this->result_;
}


/**
 * Returns a status Value object.
 * If the operation has failed, it will include an error object.
 * If the operation has succeeded, it will include the result value.
 */
Value AsyncRPCOperation::getStatus() const {
    OperationStatus status = this->getState();
    Object obj;
    obj.push_back(Pair("id", this->getId()));
    obj.push_back(Pair("status", OperationStatusMap[status]));
    obj.push_back(Pair("creation_time", this->creation_time_));
    // creation, exec time, duration, exec end, etc.
    Value err = this->getError();
    if (!err.is_null()) {
        obj.push_back(Pair("error", err.get_obj()));
    }
    Value result = this->getResult();
    if (!result.is_null()) {
        obj.push_back(Pair("result", result));

        // Include execution time for successful operation
        std::chrono::duration<double> elapsed_seconds = end_time_ - start_time_;
        obj.push_back(Pair("execution_secs", elapsed_seconds.count()));

    }
    return Value(obj);
}

/**
 * Return the operation state in human readable form.
 */
std::string AsyncRPCOperation::getStateAsString() const {
    OperationStatus status = this->getState();
    return OperationStatusMap[status];
}