/*
 *     .============.
 *    //  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 "action.h"

#include <sstream>

#include <tbox/base/log.h>
#include <tbox/base/json.hpp>
#include <tbox/event/loop.h>
#include <tbox/event/timer_event.h>

namespace tbox {
namespace flow {

int Action::_id_alloc_counter_ = 0;

Action::Action(event::Loop &loop, const std::string &type)
  : loop_(loop)
  , id_(++_id_alloc_counter_)
  , type_(type)
{}

Action::~Action() {
  if (isUnderway()) {
    LogWarn("action %d:%s[%s] is still underway, state:%s",
            id_, type_.c_str(), label_.c_str(),
            ToString(state_).c_str());
  }

  cancelDispatchedCallback();

  CHECK_DELETE_RESET_OBJ(timer_ev_);
}

void Action::toJson(Json &js) const {
  js["id"] = id_;
  js["type"] = type_;
  if (!label_.empty())
    js["label"] = label_;
  js["state"] = ToString(state_);
  js["result"] = ToString(result_);

  if (!vars_.empty())
    vars_.toJson(js["vars"]);
}

bool Action::start() {
  if (state_ == State::kRunning)
    return true;

  if (state_ != State::kIdle) {
    LogWarn("not allow %d:%s[%s]", id_, type_.c_str(), label_.c_str());
    return false;
  }

  auto last_state = state_;

  LogDbg("start action %d:%s[%s]", id_, type_.c_str(), label_.c_str());

  is_base_func_invoked_ = false;

  onStart();

  if (!is_base_func_invoked_)
    LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

  if (last_state == state_) {
    if (timer_ev_ != nullptr)
      timer_ev_->enable();

    state_ = State::kRunning;
  }
  return true;
}

bool Action::pause() {
  if (state_ == State::kPause)
    return true;

  if (state_ != State::kRunning) {
    LogWarn("not allow %d:%s[%s]", id_, type_.c_str(), label_.c_str());
    return false;
  }

  auto last_state = state_;

  LogDbg("pause action %d:%s[%s]", id_, type_.c_str(), label_.c_str());

  is_base_func_invoked_ = false;

  onPause();

  if (!is_base_func_invoked_)
    LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

  if (last_state == state_) {
    if (timer_ev_ != nullptr)
      timer_ev_->disable();

    state_ = State::kPause;
  }
  return true;
}

bool Action::resume() {
  if (state_ == State::kRunning)
    return true;

  if (state_ != State::kPause) {
    LogWarn("not allow %d:%s[%s]", id_, type_.c_str(), label_.c_str());
    return false;
  }

  auto last_state = state_;

  LogDbg("resume action %d:%s[%s]", id_, type_.c_str(), label_.c_str());

  is_base_func_invoked_ = false;

  onResume();

  if (!is_base_func_invoked_)
    LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

  if (last_state == state_) {
    if (timer_ev_ != nullptr)
      timer_ev_->enable();

    state_ = State::kRunning;
  }
  return true;
}

bool Action::stop() {
  if (!isUnderway())
    return true;

  LogDbg("stop action %d:%s[%s]", id_, type_.c_str(), label_.c_str());

  state_ = State::kStoped;

  if (timer_ev_ != nullptr)
    timer_ev_->disable();

  is_base_func_invoked_ = false;

  onStop();

  if (!is_base_func_invoked_)
    LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

  onFinal();

  return true;
}

bool Action::finish(bool is_succ, const Reason &why, const Trace &trace) {
  if (state_ != State::kFinished && state_ != State::kStoped) {
    LogDbg("action %d:%s[%s] finished, is_succ: %s", id_, type_.c_str(), label_.c_str(),
           (is_succ? "succ" : "fail"));

    state_ = State::kFinished;

    if (timer_ev_ != nullptr)
      timer_ev_->disable();

    is_base_func_invoked_ = false;

    onFinished(is_succ, why, trace);

    if (!is_base_func_invoked_)
      LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

    onFinal();
    return true;

  } else {
    LogWarn("not allow %d:%s[%s]", id_, type_.c_str(), label_.c_str());
    return false;
  }
}

bool Action::block(const Reason &why, const Trace &trace) {
  if (state_ != State::kFinished && state_ != State::kStoped) {
    LogDbg("action %d:%s[%s] blocked", id_, type_.c_str(), label_.c_str());

    state_ = State::kPause;

    is_base_func_invoked_ = false;

    onBlock(why, trace);

    if (!is_base_func_invoked_)
      LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

    return true;

  } else {
    LogWarn("not allow %d:%s[%s]", id_, type_.c_str(), label_.c_str());
    return false;
  }
}

void Action::reset() {
  if (state_ == State::kIdle)
    return;

  LogDbg("reset action %d:%s[%s]", id_, type_.c_str(), label_.c_str());

  if (isUnderway()) {
    LogWarn("be careful, action %d:%s[%s] in state:%s",
            id_, type_.c_str(), label_.c_str(), ToString(state_).c_str());
  }

  is_base_func_invoked_ = false;

  onReset();

  if (!is_base_func_invoked_)
    LogWarn("%d:%s[%s] didn't invoke base func", id_, type_.c_str(), label_.c_str());

  if (timer_ev_ != nullptr)
    timer_ev_->disable();

  cancelDispatchedCallback();

  state_ = State::kIdle;
  result_ = Result::kUnsure;
}

void Action::setTimeout(std::chrono::milliseconds ms) {
  LogDbg("set action %d:%s[%s] timeout: %d", id_, type_.c_str(), label_.c_str(), ms.count());

  if (timer_ev_ == nullptr) {
    timer_ev_ = loop_.newTimerEvent("Action::timer_ev_");
    timer_ev_->setCallback(
      [this] {
        LogDbg("action %d:%s[%s] timeout", id_, type_.c_str(), label_.c_str());
        onTimeout();
      }
    );
  } else {
    timer_ev_->disable();
  }

  timer_ev_->initialize(ms, event::Event::Mode::kOneshot);
  if (state_ == State::kRunning)
    timer_ev_->enable();
}

void Action::resetTimeout() {
  LogDbg("reset action %d:%s[%s] timeout", id_, type_.c_str(), label_.c_str());

  if (timer_ev_ != nullptr) {
    auto tobe_delete = timer_ev_;
    timer_ev_ = nullptr;

    tobe_delete->disable();
    loop_.runNext([tobe_delete] { delete tobe_delete; }, "Action::resetTimeout, delete");
  }
}

void Action::onStart() { is_base_func_invoked_ = true; }

void Action::onPause() { is_base_func_invoked_ = true; }

void Action::onResume() { is_base_func_invoked_ = true; }

void Action::onStop() { is_base_func_invoked_ = true; }

void Action::onReset() { is_base_func_invoked_ = true; }

void Action::onBlock(const Reason &why, const Trace &trace) {
  if (block_cb_) {
    Trace new_trace(trace);
    new_trace.emplace_back(id_, type_, label_);
    block_cb_run_id_ = loop_.runNext(std::bind(block_cb_, why, new_trace),
                                     std::string("Action::block") + ToString(new_trace));
  }

  is_base_func_invoked_ = true;
}

void Action::onFinished(bool is_succ, const Reason &why, const Trace &trace) {
  result_ = is_succ ? Result::kSuccess : Result::kFail;

  if (finish_cb_) {
    Trace new_trace(trace);
    new_trace.emplace_back(id_, type_, label_);
    finish_cb_run_id_ = loop_.runNext(std::bind(finish_cb_, is_succ, why, new_trace),
                                      std::string("Action::finish") + ToString(new_trace));
  }

  is_base_func_invoked_ = true;
}

void Action::onTimeout() {
  finish(false, Reason(ACTION_REASON_ACTION_TIMEOUT, "ActionTimeout"));
}

void Action::cancelDispatchedCallback() {
  if (finish_cb_run_id_ != 0) {
    loop_.cancel(finish_cb_run_id_);
    finish_cb_run_id_ = 0;
  }

  if (block_cb_run_id_ != 0) {
    loop_.cancel(block_cb_run_id_);
    block_cb_run_id_ = 0;
  }
}

bool Action::setParent(Action *parent) {
  //! 如果之前设置过了，就不能再设置
  if (parent != nullptr && parent_ != nullptr) {
    LogWarn("%d:%s[%s] can't set %d:%s[%s] as parent. its origin parent is %d:%s[%s]",
            id_, type_.c_str(), label_.c_str(),
            parent->id_, parent->type_.c_str(), parent->label_.c_str(),
            parent_->id_, parent_->type_.c_str(), parent_->label_.c_str());
    return false;
  }

  vars_.setParent(&(parent->vars_));
  parent_ = parent;
  return true;
}

Action::Reason::Reason(const Reason &other)
  : code(other.code)
  , message(other.message)
{ }

Action::Reason& Action::Reason::operator = (const Reason &other) {
  if (this != &other) {
    code = other.code;
    message = other.message;
  }
  return *this;
}

Action::Who::Who(const Who &other)
  : id(other.id)
  , type(other.type)
  , label(other.label)
{ }

Action::Who& Action::Who::operator = (const Who &other) {
  if (this != &other) {
    id = other.id;
    type = other.type;
    label = other.label;
  }
  return *this;
}

std::string ToString(Action::State state) {
  const char *tbl[] = { "idle", "running", "pause", "finished", "stoped" };
  auto index = static_cast<size_t>(state);
  if (index < NUMBER_OF_ARRAY(tbl))
    return tbl[index];
  return "unknown";
}

std::string ToString(Action::Result result) {
  const char *tbl[] = { "unsure", "success", "fail" };
  auto index = static_cast<size_t>(result);
  if (index < NUMBER_OF_ARRAY(tbl))
    return tbl[index];
  return "unknown";
}

std::string ToString(const Action::Reason &reason) {
  std::stringstream oss;
  oss << '(' << reason.code << ':' << reason.message << ')';
  return oss.str();
}

std::string ToString(const Action::Trace &trace) {
  std::stringstream oss;
  bool is_first = true;

  for (const auto &who: trace) {
    if (!is_first)
      oss << "->";

    is_first = false;
    oss << '(' << who.id << ':' << who.type;
    if (!who.label.empty())
      oss << ',' << who.label;
    oss << ')';
  }

  return oss.str();
}

}
}