#include "Time.hpp"
#include <thread>
#include "../vendor/TermColor.hpp"
#include "../io/IOHandlers.hpp"

#define __get_local_time() \
		std::time_t __cur_t = std::time(0); \
		std::tm* __now_t = std::localtime(&__cur_t);

namespace ostd
{
	GameClock::GameClock(void)
	{
		minutes = 0;
		hours = 0;
		days = 0;
		months = 0;
		years = 2022;
		m_timeOfDay = 0.0f;
		m_totalSeconds = 0.0f;
	}

	const f32& GameClock::start(void)
	{
		m_rtClock.start(false, "", eTimeUnits::Seconds);
		m_timeOfDay = CAP((1.0f / ((f32)(TM_G_MINUTES_FOR_G_HOUR * TM_G_HOURS_FOR_G_DAY))) * ((hours * TM_G_MINUTES_FOR_G_HOUR) + (minutes)), 1.0f);
		return m_timeOfDay;
	}

	String GameClock::asString(void)
	{
		std::ostringstream ss;
		ss << "Time: " << getFormattedTime() << " / ";
		ss << (i32)(days + 1) << " " << convertMonth() << " " << (i32)(years);
		return String(ss.str());
	}

	void GameClock::update(void)
	{
		i64 elapsed = m_rtClock.start(false, "", eTimeUnits::Seconds);
		if (hours == 255)
			hours = TM_G_HOURS_FOR_G_DAY - 1;
		else if (hours >= TM_G_HOURS_FOR_G_DAY)
			hours = 0;
		if (elapsed >= TM_R_SECONDS_FOR_G_MINUTE)
		{
			minutes++;
			if (minutes >= TM_G_MINUTES_FOR_G_HOUR)
			{
				hours++;
				if (hours >= TM_G_HOURS_FOR_G_DAY)
				{
					days++;
					if ((months == (u8)eMonths::January || months == (u8)eMonths::March ||
						months == (u8)eMonths::May || months == (u8)eMonths::July ||
						months == (u8)eMonths::August || months == (u8)eMonths::October ||
						months == (u8)eMonths::December) && days >= TM_G_DAYS_FOR_G_LONG_MONTH)
					{
						months++;
						if (months > (u8)eMonths::December)
						{
							years++;
							months = (u8)eMonths::January;
						}
						days = 0;
					}
					else if ((months == (u8)eMonths::April || months == (u8)eMonths::June ||
							months == (u8)eMonths::September || months == (u8)eMonths::November) && days >= TM_G_DAYS_FOR_G_MEDIUM_MONTH)
					{
						months++;
						days = 0;
					}
					else if (months == (u8)eMonths::February)
					{
						if ((years % 4 == 0 && days >= TM_G_DAYS_FOR_G_SHORT_MONTH + 1) ||
							(years % 4 != 0 && days >= TM_G_DAYS_FOR_G_SHORT_MONTH))
						{
							months++;
							days = 0;
						}
					}
					hours = 0;
				}
				minutes = 0;
			}
			m_totalSeconds += elapsed;
			m_rtClock.start(false, "", eTimeUnits::Seconds);
			m_timeOfDay = CAP((1.0f / ((f32)(TM_G_MINUTES_FOR_G_HOUR * TM_G_HOURS_FOR_G_DAY))) * ((hours * TM_G_MINUTES_FOR_G_HOUR) + (minutes)), 1.0f);
		}
	}

	String GameClock::getFormattedTime(void)
	{
		bool zh = (i32)(hours / 10) < 1;
		bool zm = (i32)(minutes / 10) < 1;
		std::ostringstream ss;
		ss << (zh ? "0" : "") << (i32)hours << ":" << (zm ? "0" : "") << (i32)minutes;
		return String(ss.str());
	}

	String GameClock::convertMonth(void)
	{
		switch (months)
		{
			case (u8)eMonths::January:
				return "January";
			case (u8)eMonths::February:
				return "February";
			case (u8)eMonths::March:
				return "March";
			case (u8)eMonths::April:
				return "April";
			case (u8)eMonths::May:
				return "May";
			case (u8)eMonths::June:
				return "June";
			case (u8)eMonths::July:
				return "July";
			case (u8)eMonths::August:
				return "August";
			case (u8)eMonths::September:
				return "September";
			case (u8)eMonths::October:
				return "October";
			case (u8)eMonths::November:
				return "November";
			case (u8)eMonths::December:
				return "December";
			default:
				break;
		}
		return "_MONTH_";
	}



	String LocalTime::getFullString(bool include_date, bool include_time, bool day_name, bool month_as_name, bool include_seconds) const
	{
		std::ostringstream ss;
		if (include_date)
		{
			if (day_name) ss << sWeekDay(true) << " ";
			ss << sday(true);
			if (month_as_name) ss << " " << smonth(false, true) << " ";
			else ss << "." << smonth(true, false) << ".";
			ss << syear();
		}
		if (include_time)
		{
			if (include_date) ss << " - ";
			ss << shours(true) << ":" << sminutes(true);
			if (include_seconds) ss << ":" << sseconds(true);
		}
		return ss.str();
	}

	i32 LocalTime::hours(void) const
	{
		__get_local_time();
		return __now_t->tm_hour;
	}

	i32 LocalTime::minutes(void) const
	{
		__get_local_time();
		return __now_t->tm_min;
	}

	i32 LocalTime::seconds(void) const
	{
		__get_local_time();
		return __now_t->tm_sec;
	}

	i32 LocalTime::day(void) const
	{
		__get_local_time();
		return __now_t->tm_mday;
	}

	i32 LocalTime::month(void) const
	{
		__get_local_time();
		return __now_t->tm_mon + 1;
	}

	i32 LocalTime::year(void) const
	{
		__get_local_time();
		return __now_t->tm_year + 1900;
	}

	i32 LocalTime::weekDay(void) const
	{
		__get_local_time();
		return __now_t->tm_wday;
	}

	String LocalTime::shours(bool leading_zero) const
	{
		std::ostringstream ss;
		i32 h = hours();
		if (leading_zero && h < 10)
			ss << "0" << (i32)h;
		else
			ss << (i32)h;
		return ss.str();
	}

	String LocalTime::sminutes(bool leading_zero) const
	{
		std::ostringstream ss;
		i32 h = minutes();
		if (leading_zero && h < 10)
			ss << "0" << (i32)h;
		else
			ss << (i32)h;
		return ss.str();
	}

	String LocalTime::sseconds(bool leading_zero) const
	{
		std::ostringstream ss;
		i32 h = seconds();
		if (leading_zero && h < 10)
			ss << "0" << (i32)h;
		else
			ss << (i32)h;
		return ss.str();
	}

	String LocalTime::sday(bool leading_zero) const
	{
		std::ostringstream ss;
		i32 h = day();
		if (leading_zero && h < 10)
			ss << "0" << (i32)h;
		else
			ss << (i32)h;
		return ss.str();
	}

	String LocalTime::smonth(bool leading_zero, bool month_name) const
	{
		i32 h = month();
		if (month_name) return monthToText(h);
		std::ostringstream ss;
		if (leading_zero && h < 10)
			ss << "0" << (i32)h;
		else
			ss << (i32)h;
		return ss.str();
	}

	String LocalTime::syear(void) const
	{
		std::ostringstream ss;
		i32 h = year();
		ss << (i32)h;
		return ss.str();
	}

	String LocalTime::sWeekDay(bool day_name) const
	{
		i32 h = weekDay();
		if (day_name)
			return weekDayToText(h);
		std::ostringstream ss;
		ss << (i32)h;
		return ss.str();
	}

	String LocalTime::monthToText(i32 month) const
	{
		switch (month)
		{
			case 1: return "January";
			case 2: return "February";
			case 3: return "March";
			case 4: return "April";
			case 5: return "May";
			case 6: return "June";
			case 7: return "July";
			case 8: return "August";
			case 9: return "September";
			case 10: return "October";
			case 11: return "November";
			case 12: return "December";
			default: return "Unknown Month";
		}
	}

	String LocalTime::weekDayToText(i32 day) const
	{
		switch (day)
		{
			case 0: return "Sun";
			case 1: return "Mon";
			case 2: return "Tue";
			case 3: return "Wed";
			case 4: return "Thu";
			case 5: return "Fri";
			case 6: return "Sat";
			default: return "Unknown Day";
		}
	}

	String LocalTime_IT::monthToText(i32 month) const
	{
		switch (month)
		{
			case 1: return "Gennaio";
			case 2: return "Febraio";
			case 3: return "Marzo";
			case 4: return "Aprile";
			case 5: return "Maggio";
			case 6: return "Giugno";
			case 7: return "Luglio";
			case 8: return "Agosto";
			case 9: return "Settembre";
			case 10: return "Ottobre";
			case 11: return "Novembre";
			case 12: return "Dicembre";
			default: return "Mese sconosciuto";
		}
	}

	String LocalTime_IT::weekDayToText(i32 day) const
	{
		switch (day)
		{
			case 0: return "Dom";
			case 1: return "Lun";
			case 2: return "Mar";
			case 3: return "Mer";
			case 4: return "Gio";
			case 5: return "Ven";
			case 6: return "Sab";
			default: return "Giorno Sconosciuto";
		}
	}

	String LocalTime_ES::monthToText(i32 month) const
	{
		switch (month)
		{
			case 1: return "Enero";
			case 2: return "Febrero";
			case 3: return "Marzo";
			case 4: return "Abril";
			case 5: return "Mayo";
			case 6: return "Junio";
			case 7: return "Julio";
			case 8: return "Agosto";
			case 9: return "Septiembre";
			case 10: return "Octubre";
			case 11: return "Noviembre";
			case 12: return "Diciembre";
			default: return "Mes desconocido";
		}
	}

	String LocalTime_ES::weekDayToText(i32 day) const
	{
		switch (day)
		{
			case 0: return "Domingo";
			case 1: return "Lunes";
			case 2: return "Martes";
			case 3: return "Miercoles";
			case 4: return "Jueves";
			case 5: return "Viernes";
			case 6: return "Sabado";
			default: return "Dia desconoscido";
		}
	}

	String LocalTime_DE::monthToText(i32 month) const
	{
		switch (month)
		{
			case 1: return "Januar";
			case 2: return "Februar";
			case 3: return "Marz";
			case 4: return "April";
			case 5: return "May";
			case 6: return "Juni";
			case 7: return "July";
			case 8: return "August";
			case 9: return "September";
			case 10: return "Oktuber";
			case 11: return "November";
			case 12: return "Dizember";
			default: return "Unknown day";
		}
	}

	String LocalTime_DE::weekDayToText(i32 day) const
	{
		switch (day)
		{
			case 0: return "So";
			case 1: return "Mo";
			case 2: return "Di";
			case 3: return "Mi";
			case 4: return "Do";
			case 5: return "Fr";
			case 6: return "Sa";
			default: return "Unknown day";
		}
	}



	u64 Counter::start(bool print, const String& name, eTimeUnits timeUnit, OutputHandlerBase* __destination)
	{
		m_timeUnit = timeUnit;
		m_started = true;
		m_name = name;
		if (print)
		{
			if (__destination == nullptr)
			{
				std::cout << "\n" << termcolor::magenta << "====>   ";
				std::cout << termcolor::cyan << "Starting test for [";
				std::cout << termcolor::green << m_name;
				std::cout << termcolor::cyan << "]";
				std::cout << termcolor::magenta << "   <====";
				std::cout << termcolor::reset << "\n";
			}
			else
			{
				m_dest = __destination;
				m_dest->nl().fg("magenta").p("====>   ");
				m_dest->fg("cyan").p("Starting test for [");
				m_dest->fg("green").p(m_name);
				m_dest->fg("cyan").p("]");
				m_dest->fg("magenta").p("   <====");
				m_dest->reset().nl();
			}
		}
		switch (m_timeUnit)
		{
			case eTimeUnits::Nanoseconds:
				m_current = std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Microseconds:
				m_current = std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Milliseconds:
				m_current = std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Seconds:
				m_current = std::chrono::duration_cast<std::chrono::seconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			default: m_started = false; return 0;
		}
		m_started = false;
		return 0;
	}

	u64 Counter::startCount(eTimeUnits timeUnit)
	{
		m_timeUnit = timeUnit;
		m_started = true;
		switch (m_timeUnit)
		{
			case eTimeUnits::Nanoseconds:
				m_current = std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Microseconds:
				m_current = std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Milliseconds:
				m_current = std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			case eTimeUnits::Seconds:
				m_current = std::chrono::duration_cast<std::chrono::seconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				return m_current;
			default: m_started = false; return 0;
		}
		m_started = false;
		return 0;
	}

	u64 Counter::end(bool print)
	{
		if (!m_started) return 0;
		m_started = false;
		m_dest = nullptr;
		i64 diff;
		String unit;
		switch (m_timeUnit)
		{
			case eTimeUnits::Nanoseconds:
				diff = std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				unit = " ns";
			break;
			case eTimeUnits::Microseconds:
				diff = std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				unit = " us";
			break;
			case eTimeUnits::Milliseconds:
				diff = std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				unit = " ms";
			break;
			case eTimeUnits::Seconds:
				diff = std::chrono::duration_cast<std::chrono::seconds> (std::chrono::system_clock::now().time_since_epoch()).count();
				unit = " s";
			break;
			default: return 0;
		}
		diff -= m_current;
		if (print)
		{
			if (m_dest == nullptr)
			{
				std::cout << termcolor::magenta << "====>   ";
				std::cout << termcolor::cyan << "Test for [";
				std::cout << termcolor::green << m_name;
				std::cout << termcolor::cyan << "] took ";
				std::cout << termcolor::bright_blue << diff << unit;
				std::cout << termcolor::magenta << "   <====";
				std::cout << termcolor::reset << "\n";
			}
			else
			{
				m_dest->fg("magenta").p("====>   ");
				m_dest->fg("cyan").p("Test for [");
				m_dest->fg("green").p(m_name);
				m_dest->fg("cyan").p("] took ");
				m_dest->fg("b-blue").p(diff).p(unit);
				m_dest->nl().nl().fg("magenta").p("   <====");
				m_dest->reset().nl();
			}
		}
		return diff;
	}

	u64 Counter::endCount(bool stop)
	{
		if (!m_started) return 0;
		m_started = !stop;
		i64 diff;
		switch (m_timeUnit)
		{
			case eTimeUnits::Nanoseconds:
				diff = std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Microseconds:
				diff = std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Milliseconds:
				diff = std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Seconds:
				diff = std::chrono::duration_cast<std::chrono::seconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			default: return 0;
		}
		diff -= m_current;
		return diff;
	}

	u64 Counter::restart(eTimeUnits timeUnit)
	{
		if (!m_started)
		{
			startCount(timeUnit);
			return 0;
		}
		u64 elapsed = endCount();
		startCount(timeUnit);
		return elapsed;
	}

	u64 Counter::getEpoch(eTimeUnits timeUnit)
	{
		switch (timeUnit)
		{
			case eTimeUnits::Nanoseconds:
				return std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Microseconds:
				return std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Milliseconds:
				return std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			case eTimeUnits::Seconds:
				return std::chrono::duration_cast<std::chrono::seconds> (std::chrono::system_clock::now().time_since_epoch()).count();
			break;
			default: return 0;
		}
		return 0;
	}



	StepTimer& StepTimer::create(f64 updatesPerSecond, StepTimer::Callback callback, bool stopped)
	{
		m_targetDt = 1.0 / updatesPerSecond;
		m_callback = std::move(callback);
		m_prevTime = Clock::now();
		m_accumulator = 0.0;
		m_stopped = stopped;
		m_valid = true;
		return *this;
	}

	void StepTimer::update(void)
	{
		if (!m_valid || m_stopped || !m_callback) return;
		if (m_stopCondition && m_stopCondition())
		{
			m_stopped = true;
			if (m_stopCallback)
				m_stopCallback();
			return;
		}

		TimePoint currentTime = Clock::now();
		Duration frameDuration = currentTime - m_prevTime;
		m_prevTime = currentTime;

		// Convert to seconds
		f64 frameTime = std::chrono::duration<f64>(frameDuration).count();

		// Clamp to prevent spiral of death (5 FPS minimum)
		constexpr f64 MAX_FRAME_TIME = 0.2;
		if (frameTime > MAX_FRAME_TIME)
			frameTime = MAX_FRAME_TIME;

		m_accumulator += frameTime;

		while (m_accumulator >= m_targetDt)
		{
			m_callback(m_targetDt);
			m_accumulator -= m_targetDt;
		}
	}

	void StepTimer::reset(void)
	{
		if (m_valid)
		{
			m_accumulator = 0.0;
			m_prevTime = Clock::now();
			m_stopped = false;
		}
	}




	void Time::startRunningTimer(void)
	{
		s_startTime_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
	}

	void Time::sleep(u32 __time, eTimeUnits __unit)
	{
		switch (__unit)
		{
		case eTimeUnits::Seconds:
			std::this_thread::sleep_for(std::chrono::seconds(__time));
			break;
		case eTimeUnits::Milliseconds:
			std::this_thread::sleep_for(std::chrono::milliseconds(__time));
			break;
		case eTimeUnits::Microseconds:
			std::this_thread::sleep_for(std::chrono::microseconds(__time));
			break;
		case eTimeUnits::Nanoseconds:
			std::this_thread::sleep_for(std::chrono::nanoseconds(__time));
			break;
		default: break;
		}
	}

	u64 Time::getRunningTime_ms(void)
	{
		return std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now().time_since_epoch()).count() - s_startTime_ms;
	}

	String Time::secondsToFormattedString(i32 totalSeconds)
	{
			i32 hours   = totalSeconds / 3600;
			i32 minutes = (totalSeconds % 3600) / 60;
			i32 seconds = totalSeconds % 60;
			String fmtstr = "";
			fmtstr.add(String("").add(hours).addLeftPadding(2, '0')).add(":");
			fmtstr.add(String("").add(minutes).addLeftPadding(2, '0')).add(":");
			fmtstr.add(String("").add(seconds).addLeftPadding(2, '0'));
			return fmtstr;
	}
}