#include "config.h"

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <iostream>
#include <iomanip>
#include <string>
// #include <sstream>

#include <time.h>
#include <sys/types.h>

#include "types.h"
#include "error.h"
#include "fs.h"
#include "estring.h"
#include "strfmt.h"
#include "rmath.h"

#include "timer.h"

/** Given a timer value, return a string in the form of "YYYY.MM.DD HH:MM:SS"
 */
const std::string make_time_string_(timer::value_type a_t)
{
	std::string es;
	struct tm* l = 0;
	estring tmp_str;
	std::string str;

	l = localtime(&a_t);
	if (l == 0) {
		TRY_nomem(es = "Could not convert time_t to localtime: \"");
		TRY_nomem(es += estring(a_t));
		TRY_nomem(es += "\"");
		throw(ERROR(errno,es));
	}

	TRY(str += estring(l->tm_year + 1900).fmt_str(4,estring::right,'0','x'),
		"Error generating string from year");

	TRY_nomem(str += ".");

	TRY(str += estring(l->tm_mon + 1).fmt_str(2,estring::right,'0','x'),
		"Error generating string from month");

	TRY_nomem(str += ".");

	TRY(str += estring(l->tm_mday).fmt_str(2,estring::right,'0','x'),
		"Error generating string from day");

	TRY_nomem(str += " ");

	TRY(str += estring(l->tm_hour).fmt_str(2,estring::right,'0','x'),
		"Error generating string from hour");

	TRY_nomem(str += ":");

	TRY(str += estring(l->tm_min).fmt_str(2,estring::right,'0','x'),
		"Error generating string from minute");

	TRY_nomem(str += ":");

	TRY(str += estring(l->tm_sec).fmt_str(2,estring::right,'0','x'),
		"Error generating string from seconds");

	return(str);
}

/** C'tor */
timer::timer()
{
	clear();
	start();
}

/** C'tor */
timer::timer(const timer& a_timer)
{
	assign(a_timer);
}

/** C'tor */
timer::timer(const value_type a_start)
{
	assign(a_start);
}

/** C'tor */
timer::timer(const value_type a_start, const value_type a_stop)
{
	assign(a_start,a_stop);
}

/** Clear the timer */
void timer::clear(void)
{
	m_start = 0;
	m_stop = 0;
	m_started = false;
	m_stopped = false;
	m_duration = 0;
	m_use_localtime = true;
}

/** Set the timer start value */
void timer::mf_start_value(const timer::value_type a_t)
{
	m_start = a_t;
	m_started = true;
}

/** Set the timer stop value */
void timer::mf_stop_value(const timer::value_type a_t)
{
	m_stop = a_t;
	m_stopped = true;
}

/** Calculate the duration between start and stop */
const timer::duration_type
	timer::mf_calculate_duration(
		const timer::value_type a_start, 
		const timer::value_type a_stop
	) const
{
	duration_type duration;

	duration = difftime(a_stop,a_start);

	return(duration);
}

/** Start (or restart) the timer */
void timer::start(void)
{
	mf_start_value(time(0));
}

/** Stop the timer */
void timer::stop(void)
{
	mf_stop_value(time(0));
	m_duration = mf_calculate_duration(m_start,m_stop);
}

/** Return the timer start value */
const timer::value_type timer::start_value(void) const
{
	return(m_start);
}

/** Return the timer stop value */
const timer::value_type timer::stop_value(void) const
{
	return(m_stop);
}

/** Assign timer values from another timer instance */
void timer::assign(const timer& a_timer)
{
	clear();
	mf_start_value(a_timer.start_value());
	mf_stop_value(a_timer.stop_value());
	m_started = a_timer.is_started();
	m_stopped = a_timer.is_stopped();
	if (m_stopped)
		m_duration = mf_calculate_duration(m_start,m_stop);
}

/** Assign timer from a start value */
void timer::assign(const timer::value_type a_start)
{
	clear();
	mf_start_value(a_start);
}

/** Assign timer from start and stop values */
void timer::assign(
	const timer::value_type a_start,
	const timer::value_type a_stop)
{
	clear();
	mf_start_value(a_start);
	mf_stop_value(a_stop);
	m_duration = mf_calculate_duration(m_start,m_stop);
}

/** Assignment */
timer& timer::operator=(const timer& a_timer)
{
	assign(a_timer);

	return(*this);
}

/** Set whether to use localtime or GMT when constructing strings */
void timer::use_localtime(const bool a_switch)
{
	m_use_localtime = a_switch;
}

/** Return whether to use localtime or GMT */
const bool timer::use_localtime(void) const
{
	return(m_use_localtime);
}

/** Generate a string in a regular human-readable format */
const std::string timer::mf_make_timer_string(const value_type a_t) const
{
	std::string es;
	struct tm* l = 0;
	std::string str;
	const char* month_names[] = {
		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
		};

	if (m_use_localtime) {
		l = localtime(&a_t);
		if (l == 0) {
			TRY_nomem(es = "Could not convert time_t to localtime: \"");
			TRY_nomem(es += estring(a_t));
			TRY_nomem(es += "\"");
			throw(ERROR(errno,es));
		}
	}
	else {
		l = gmtime(&a_t);
		if (l == 0) {
			TRY_nomem(es = "Could not convert time_t to GMT: \"");
			TRY_nomem(es += estring(a_t));
			TRY_nomem(es += "\"");
			throw(ERROR(errno,es));
		}
	}

	TRY(str += estring(l->tm_year + 1900).fmt_str(4,estring::right,'0','x'),
		"Error generating string from year");

	TRY_nomem(str += " ");

	TRY(str += estring(month_names[l->tm_mon]).fmt_str(3,estring::right,' ','x'),
		"Error generating string from month");
	
	TRY_nomem(str += " ");

	TRY(str += estring(l->tm_mday).fmt_str(2,estring::right,' ','x'),
		"Error generating string from day");

	TRY_nomem(str += " ");

	TRY(str += estring(l->tm_hour).fmt_str(2,estring::right,'0','x'),
		"Error generating string from hour");

	TRY_nomem(str += ":");

	TRY(str += estring(l->tm_min).fmt_str(2,estring::right,'0','x'),
		"Error generating string from minute");

	TRY_nomem(str += ":");

	TRY(str += estring(l->tm_sec).fmt_str(2,estring::right,'0','x'),
		"Error generating string from seconds");

	return(str);
}

/** Generate a string in a timestamp format */
const std::string timer::mf_make_string(const timer::value_type a_t) const
{
	std::string str;

	TRY_nomem(str = mf_make_timer_string(a_t));

	return(str);
}

/** Generate a duration string */
const std::string timer::mf_make_string(const timer::duration_type a_d) const
{
	uint64 deciseconds = 0;
	uint64 seconds = 0;
	uint64 minutes = 0;
	uint64 hours = 0;
	uint64 days = 0;
	uint64 years = 0;
	std::string str;
	bool negative = false;

	if (a_d < 0) {
		negative = true;
		deciseconds = static_cast<uint64>(-a_d * 10.0);
	}
	else
		deciseconds = static_cast<uint64>(a_d * 10.0);

	if (deciseconds >= 10) {
		seconds = deciseconds / 10;
		deciseconds %= 10;
	}
	if (seconds >= 60) {
		minutes = seconds / 60;
		seconds %= 60;
	}
	if (minutes >= 60) {
		hours = minutes / 60;
		minutes %= 60;
	}
	if (hours >= 24) {
		days = hours / 24;
		hours %= 24;
	}
	if (days >= 365) {
		years = days / 365;
		days %= 365;
	}

	if (negative) {
		TRY_nomem(str += "-");
	}

	if (years > 0) {
		TRY_nomem(str += estring(years));
		TRY_nomem(str += "y ");
	}

	if ((years > 0) || (days > 0)) {
		TRY_nomem(str += estring(days));
		TRY_nomem(str += "d ");
	}

	if ((years > 0) || (days > 0) || (hours > 0)) {
		TRY(str += estring(hours).fmt_str(2,estring::right,'0','x'),
			"Error generating string from hours");
		TRY_nomem(str += ":");
	}

	TRY(str += estring(minutes).fmt_str(2,estring::right,'0','x'),
		"Error generating string from minutes");

	TRY_nomem(str += ":");

	TRY(str += estring(seconds).fmt_str(2,estring::right,'0','x'),
		"Error generating string from seconds");

	TRY_nomem(str += ".");

	TRY(str += estring(deciseconds).fmt_str(1,estring::right,'0','x'),
		"Error generating string from deciseconds");

	return(str);
}

/** Generate a started-at string */
const std::string timer::started_at(void) const
{
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Request for start time from an unstarted timer"));
	TRY_nomem(str = mf_make_string(m_start));

	return(str);
}

/** Generate a stopped-at string */
const std::string timer::stopped_at(void) const
{
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Request for stop time from an unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Request for stop time from a running timer"));
	TRY_nomem(str = mf_make_string(m_stop));

	return(str);
}

/** Generate a duration string */
const std::string timer::duration(void) const
{
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Request for stop time from an unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Request for duration from a running timer"));
	TRY_nomem(str = mf_make_string(m_duration));

	return(str);
}

/** Return whether or not the timer has been started */
const bool timer::is_started(void) const
{
	return(m_started);
}

/** Return whether or not the timer has been stopped */
const bool timer::is_stopped(void) const
{
	return(m_stopped);
}

/** Reutrn the duration in seconds */
const timer::duration_type timer::duration_secs(void) const
{
	if (!is_started())
		throw(INTERNAL_ERROR(0,"Request for duration from an unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Request for duration from a running timer"));
	
	return(m_duration);
}

/** Return the duration in minutes */
const timer::duration_type timer::duration_mins(void) const
{
	duration_type value;

	value = duration_secs()/static_cast<duration_type>(60.0);

	return(value);
}

/** Return the duration in hours */
const timer::duration_type timer::duration_hours(void) const
{
	duration_type value;

	value = duration_mins()/static_cast<duration_type>(60.0);

	return(value);
}

/** Return the duration in days */
const timer::duration_type timer::duration_days(void) const
{
	duration_type value;

	value = duration_hours()/static_cast<duration_type>(24.0);

	return(value);
}

/** Return the duration in years */
const timer::duration_type timer::duration_years(void) const
{
	duration_type value;

	value = duration_days()/static_cast<duration_type>(365.0);

	return(value);
}

/** Given a percent-complete for some unknown task, estimate a time to
 completion */
const std::string timer::eta(unsigned int a_percent_complete) const
{
	safe_num<duration_type> total_duration;
	safe_num<duration_type> eta;
	std::string es;
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Attempt to calculate ETA for unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Attempt to calculate ETA for a running timer"));
	if (a_percent_complete == 0) {
		TRY_nomem(str = "??:??.?");
		return(str);
	}
		
	TRY_nomem(es = "Could not calculate ETA");
	TRY(
		total_duration = m_duration;
		total_duration *= 100;
		total_duration /= a_percent_complete;
		eta = total_duration - safe_num<duration_type>(m_duration);
		,es);
	TRY_nomem(str = mf_make_string(eta.value()));

	return(str);
}

/** Given a step number complete out of some total number of steps for some
 unknown task, estimate a time to completion */
const std::string timer::eta(
	unsigned int a_complete, unsigned int a_total) const
{
	safe_num<unsigned int> percent_complete;
	std::string es;
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Attempt to calculate ETA for unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Attempt to calculate ETA for a running timer"));
	if (a_total == 0) {
		TRY_nomem(str = "??:??.?");
		return(str);
	}

	TRY_nomem(es = "Could not calculate ETA");
	TRY(
		percent_complete = a_complete;
		percent_complete *= 100;
		percent_complete /= a_total;
		,es);

	TRY_nomem(str = eta(percent_complete.value()));

	return(str);
}

/** Given a number of bytes, estimate the BPS */
const std::string timer::bps(uint64 a_bytes) const
{
	uint64 bps;
	std::string str;

	if (!is_started())
		throw(INTERNAL_ERROR(0,"Attempt to calculate bps for unstarted timer"));
	if (!is_stopped())
		throw(INTERNAL_ERROR(0,"Attempt to calculate bps for a running timer"));
	
	if (m_duration == 0)
		bps = a_bytes;
	else
		bps = static_cast<uint64>(a_bytes / m_duration);
	TRY_nomem(str = throughput_to_string(bps));

	return(str);
}

/** Return the current time */
const std::string current_time(void)
{
	std::string str;

	TRY_nomem(str = make_time_string_(time(0)));

	return(str);
}

/** Generate a timstamp string */
std::string stamp(const pid_t a_pid, const int a_indention)
{
	std::string str;
	int indent;
	pid_t this_pid;

	indent = a_indention;
	TRY_nomem(str = current_time());
	TRY_nomem(str += " [");
	if (a_pid == 0)
		this_pid = pid();
	else
		this_pid = a_pid;
	
	/*
	 * pid_t has to be static_cast because some compilers wind up calling
	 * estring(const long& ...) instead of estring(const unsigned long& ...),
	 * and then the value in estring can wind up being misinterpreted as a
	 * negative number.
	 *
	 * 4 digits is just a guess.  I've never seen a PID over four digits.  Is
	 * there an easy, portable way to determine how many digits pid_t could wind
	 * up being?  If gcc 2.95.x had numeric_limits<> then it would be...
	 */
	TRY_nomem(str += 
		estring(static_cast<unsigned long>(this_pid)).fmt_str(
			6,estring::right,' ',' '
			)
		);

	TRY_nomem(str += "]");
	TRY_nomem(str += "> ");
	for (; indent > 0; str += "  ", --indent);

	return(str);
}