// SrmRequestStatus.cxx

#include "dial_ws_srm/SrmRequestStatus.h"
#include <time.h>

using std::string;
using std::vector;
using std::ostream;
using dial::SrmRequestStatus;
using dial::SrmRequestFileStatus;

typedef SrmRequestStatus::Name Name;
typedef SrmRequestStatus::State State;
typedef SrmRequestStatus::Id Id;
typedef SrmRequestStatus::Time Time;
typedef SrmRequestStatus::FileStatusList FileStatusList;
typedef SrmRequestFileStatus::GsoapRequestFileStatus
        GsoapRequestFileStatus;
typedef vector<GsoapRequestFileStatus*> GsoapFileStatusList;

//*********************************************************************
// Local definitions.
//*********************************************************************

namespace {

// Time to string conversion.

string stime(Time tim) {
  const char* fmt = "%Y %B %d %X";
  char ctim[256];
  strftime(ctim, 256, fmt, localtime(&tim));
  return ctim;
}

}  // end unnamed namespace

//*********************************************************************
// Methods.
//*********************************************************************

// Default constructor.

SrmRequestStatus::SrmRequestStatus() { }

//*********************************************************************

// Gsoap constructor.

SrmRequestStatus::SrmRequestStatus(const GsoapRequestStatus& grs)
:  m_id(grs.requestId) {
  // Strings.
  if ( grs.type != 0 ) m_type = *grs.type;
  if ( grs.state != 0 ) m_state = *grs.state;
  if ( grs.errorMessage != 0 ) m_emsg = *grs.errorMessage;
  // Times.
  time(&m_tup);
  if ( grs.submitTime != 0 ) m_tsubmit = *grs.submitTime;
  if ( grs.startTime != 0 ) m_tstart = *grs.startTime;
  if ( grs.finishTime != 0 ) m_tfinish = *grs.finishTime;
  // Cancellation time: convert delta to absolute.
  m_tcancel = grs.retryDeltaTime;
  if ( is_pending() && m_tcancel) {
    m_tcancel += m_tup;
  } else {
    m_tcancel = 0;
  }
  // Estimated start time: convert delta to absolute.
  m_tready = grs.estTimeToStart;
  if ( is_pending() && m_tready ) {
    m_tready += m_tup;
  } else {
    m_tready = 0;
  }
  // File statuses.
  const GsoapFileStatusList& gstats = grs.fileStatuses;
  for ( GsoapFileStatusList::const_iterator igst=gstats.begin();
        igst!=gstats.end(); ++igst ) {
    SrmRequestFileStatus fstat(**igst);
    assert( fstat.is_valid() );
    m_fstats.push_back(fstat);
  }
}

//*********************************************************************

// Validity.

bool SrmRequestStatus::is_valid() const {
  bool ok = is_pending() || is_done() || is_active() || is_failed();
  ok &= type().size();
  return ok;
}

//*********************************************************************

// Id.

Id SrmRequestStatus::id() const {
  return m_id;
}

//*********************************************************************

// State.

Name SrmRequestStatus::type() const {
  return m_type;
}

//*********************************************************************

// State.

State SrmRequestStatus::state() const {
  return m_state;
}

//*********************************************************************

// Pending.

bool SrmRequestStatus::is_pending() const {
  return m_state == "Pending";
}

//*********************************************************************

// Done.

bool SrmRequestStatus::is_done() const {
  return m_state == "Done";
}

//*********************************************************************

// Is active.

bool SrmRequestStatus::is_active() const {
  return m_state == "Active";
}

//*********************************************************************

// Is failed.

bool SrmRequestStatus::is_failed() const {
  return m_state == "Failed";
}

//*********************************************************************

// Update time.

Time SrmRequestStatus::update_time() const {
  return m_tup;
}

//*********************************************************************

// Submit time.

Time SrmRequestStatus::submit_time() const {
  return m_tsubmit;
}

//*********************************************************************

// Start time.

Time SrmRequestStatus::start_time() const {
  return m_tstart;
}

//*********************************************************************

// Finish time.

Time SrmRequestStatus::finish_time() const {
  return m_tfinish;
}

//*********************************************************************

// Cancellation time.

Time SrmRequestStatus::cancel_time() const {
  return m_tcancel;
}

//*********************************************************************

// Update time.

Time SrmRequestStatus::ready_time() const {
  return m_tready;
}

//*********************************************************************

// List of file statuses.

const FileStatusList& SrmRequestStatus::file_statuses() const {
  return m_fstats;
}

//*********************************************************************

// Error message.

string SrmRequestStatus::error_message() const {
  return m_emsg;
}

//*********************************************************************
// Free functions.
//*********************************************************************

// Output stream.

ostream&
operator<<(ostream& lhs, const SrmRequestStatus& rhs) {
  Name type = rhs.type();
  Name state = rhs.state();
  // Handle invalid object.
  if ( ! rhs.is_valid() ) {
    lhs << "Invalid SRM request status (type ";
    if ( type.size() ) {
      lhs << "= \"" << type << "\"";
    } else {
      lhs << "is undefined";
    }
    lhs << "; state ";
    if ( state.size() ) {
      lhs << "= \"" << state << "\"";
    } else {
      lhs << "is undefined";
    }
    lhs << ")";
    return lhs;
  }
  // Type and state.
  lhs << "SRM request status of type " << type << " is " << state;
  // Times.
  Time tup = rhs.update_time();
  Time tsub = rhs.submit_time();
  Time tsta = rhs.start_time();
  Time tfin = rhs.finish_time();
  Time tcan = rhs.cancel_time();
  if (  tup != 0 ) lhs << "\n  Update time: " << stime(tup);
  if ( tsub != 0 ) lhs << "\n  Submit time: " << stime(tsub);
  if ( tsta != 0 ) lhs << "\n   Start time: " << stime(tsub);
  if ( tfin != 0 ) lhs << "\n  Finish time: " << stime(tfin);
  if ( tcan != 0 ) lhs << "\n  Cancel time: " << stime(tcan);
  if ( rhs.is_pending() ) {
    lhs << "\n   Ready time";
    Time tr = rhs.ready_time();
    if ( tr ) {
      lhs << ": " << stime(tr);
    } else {
      lhs << " is undefined";
    }
  }
  // File statuses.
  const FileStatusList& fstats = rhs.file_statuses();
  FileStatusList::size_type nstat = fstats.size();
  lhs << "\n  Request has " << nstat << " file";
  if ( nstat != 1 ) lhs << "s";
  if ( nstat != 0 ) lhs << ":";
  for ( FileStatusList::const_iterator ista=fstats.begin();
        ista!=fstats.end(); ++ista ) {
    const SrmRequestFileStatus& fstat = *ista;
    if ( fstat.is_valid() ) {
      lhs << "\n    " << fstat.surl() << " is " << fstat.state();
    }
  }
  // Error message.
  string emsg = rhs.error_message();
  if ( emsg.size() ) lhs << "\n  Error: " << emsg;
  return lhs;
}

//*********************************************************************