#include "stdafx.h"
#include "ProductionStats.h"

#include <algorithm>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <unordered_map>

#include "Configuration.h"
#include "Log.h"
#include "sqlite3.h"

#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif

static std::string FormatLocal(const std::chrono::system_clock::time_point& tp)
{
	const std::time_t tt = std::chrono::system_clock::to_time_t(tp);
	std::tm tm{};
	localtime_s(&tm, &tt);
	std::ostringstream oss;
	oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
	return oss.str();
}

static std::string FormatUtcIso(const std::chrono::system_clock::time_point& tp)
{
	const std::time_t tt = std::chrono::system_clock::to_time_t(tp);
	std::tm tm{};
	gmtime_s(&tm, &tt);
	std::ostringstream oss;
	oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
	return oss.str();
}

static bool TryParseLocalTime(const std::string& text, std::chrono::system_clock::time_point& outTp)
{
	if (text.empty()) return false;
	std::tm tm{};
	std::istringstream iss(text);
	iss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
	if (iss.fail()) return false;
	tm.tm_isdst = -1;
	const std::time_t tt = mktime(&tm);
	if (tt == (time_t)-1) return false;
	outTp = std::chrono::system_clock::from_time_t(tt);
	return true;
}

static std::string GetExeDir()
{
	char path[MAX_PATH] = {};
	GetModuleFileNameA(nullptr, path, MAX_PATH);
	std::string exePath(path);
	const size_t pos = exePath.find_last_of("\\/");
	return (pos == std::string::npos) ? std::string() : exePath.substr(0, pos);
}

static bool FileExistsA(const std::string& path)
{
	const DWORD attr = GetFileAttributesA(path.c_str());
	return (attr != INVALID_FILE_ATTRIBUTES) && ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0);
}

static std::string PickDbPath(const std::string& rel1, const std::string& rel2)
{
	const std::string base = GetExeDir();
	const std::string p1 = base + "\\" + rel1;
	if (FileExistsA(p1)) return p1;
	return base + "\\" + rel2;
}

static void ComputeOutputFromProcessDb(
	const ProductionShiftWindow& win,
	ProductionOutputSummary& out)
{
	const std::string dbPath = PickDbPath("db\\process.db", "DB\\process.db");

	sqlite3* db = nullptr;
	if (sqlite3_open_v2(dbPath.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nullptr) != SQLITE_OK) {
		if (db) sqlite3_close(db);
		return;
	}

	const char* sql =
		"SELECT class_id, buddy_id, aoi_result, "
		"IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_start, 'localtime'), ''),"
		"IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_end,   'localtime'), '') "
		"FROM glass_log "
		"WHERE t_end IS NOT NULL AND t_end >= ? AND t_end < ?;";

	sqlite3_stmt* stmt = nullptr;
	if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
		sqlite3_close(db);
		return;
	}

	sqlite3_bind_text(stmt, 1, win.startUtcIso.c_str(), -1, SQLITE_TRANSIENT);
	sqlite3_bind_text(stmt, 2, win.endUtcIso.c_str(), -1, SQLITE_TRANSIENT);

	struct PairAgg {
		bool hasPass = false;
		bool hasFail = false;
		bool hasNo = false;
		long long maxTaktSeconds = -1;
	};
	std::unordered_map<std::string, PairAgg> pairs;

	for (;;) {
		const int rc = sqlite3_step(stmt);
		if (rc == SQLITE_ROW) {
			const char* classId = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
			const char* buddyId = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
			const int aoi = sqlite3_column_int(stmt, 2);
			const char* sStart = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3));
			const char* sEnd = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 4));

			const std::string a = classId ? classId : "";
			const std::string b = buddyId ? buddyId : "";
			std::string key;
			if (!b.empty()) {
				if (a <= b) key = a + "|" + b;
				else key = b + "|" + a;
			}
			else {
				key = a;
			}

			auto& agg = pairs[key];
			if (aoi == 1) agg.hasPass = true;
			else if (aoi == 2) agg.hasFail = true;
			else agg.hasNo = true;

			std::chrono::system_clock::time_point tpStart{}, tpEnd{};
			if (TryParseLocalTime(sStart ? sStart : "", tpStart) && TryParseLocalTime(sEnd ? sEnd : "", tpEnd) && tpEnd > tpStart) {
				const auto secs = std::chrono::duration_cast<std::chrono::seconds>(tpEnd - tpStart).count();
				if (secs > agg.maxTaktSeconds) agg.maxTaktSeconds = secs;
			}
		}
		else if (rc == SQLITE_DONE) {
			break;
		}
		else {
			break;
		}
	}

	sqlite3_finalize(stmt);
	sqlite3_close(db);

	out.pairsTotal = static_cast<long long>(pairs.size());
	long long sumTakt = 0;
	long long cntTakt = 0;
	for (const auto& kv : pairs) {
		const auto& agg = kv.second;
		if (agg.hasFail) out.pairsFail++;
		else if (agg.hasPass) out.pairsPass++;
		else out.pairsNoResult++;

		if (agg.maxTaktSeconds >= 0) {
			sumTakt += agg.maxTaktSeconds;
			cntTakt += 1;
		}
	}
	const long long denom = out.pairsPass + out.pairsFail;
	out.yield = (denom > 0) ? (static_cast<double>(out.pairsPass) / static_cast<double>(denom)) : 0.0;
	out.taktSamplePairs = cntTakt;
	out.avgTaktSeconds = (cntTakt > 0) ? (static_cast<double>(sumTakt) / static_cast<double>(cntTakt)) : 0.0;
}

static void ComputeAlarmSummaryFromDb(
	const ProductionShiftWindow& win,
	ProductionAlarmSummary& out)
{
	const std::string dbPath = PickDbPath("DB\\AlarmManager.db", "DB\\AlarmManager.db");
	sqlite3* db = nullptr;
	if (sqlite3_open_v2(dbPath.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nullptr) != SQLITE_OK) {
		if (db) sqlite3_close(db);
		return;
	}

	// 1) triggered within shift
	{
		const char* sql =
			"SELECT COUNT(1) FROM alarms "
			"WHERE start_time >= ? AND start_time < ?;";
		sqlite3_stmt* stmt = nullptr;
		if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
			sqlite3_bind_text(stmt, 1, win.startLocal.c_str(), -1, SQLITE_TRANSIENT);
			sqlite3_bind_text(stmt, 2, win.endLocal.c_str(), -1, SQLITE_TRANSIENT);
			if (sqlite3_step(stmt) == SQLITE_ROW) out.alarmsTriggered = sqlite3_column_int(stmt, 0);
			sqlite3_finalize(stmt);
		}
	}

	// 2) overlapping (including active)
	{
		const char* sql =
			"SELECT severity_level, start_time, end_time "
			"FROM alarms "
			"WHERE start_time < ? AND (end_time IS NULL OR end_time >= ?);";
		sqlite3_stmt* stmt = nullptr;
		if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
			sqlite3_bind_text(stmt, 1, win.endLocal.c_str(), -1, SQLITE_TRANSIENT);
			sqlite3_bind_text(stmt, 2, win.startLocal.c_str(), -1, SQLITE_TRANSIENT);

			const auto now = std::chrono::system_clock::now();
			for (;;) {
				const int rc = sqlite3_step(stmt);
				if (rc == SQLITE_ROW) {
					const int severity = sqlite3_column_int(stmt, 0);
					const char* sStart = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
					const char* sEnd = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
					std::chrono::system_clock::time_point aStart{};
					if (!TryParseLocalTime(sStart ? sStart : "", aStart)) continue;
					std::chrono::system_clock::time_point aEnd{};
					bool hasEnd = TryParseLocalTime(sEnd ? sEnd : "", aEnd);
					if (!hasEnd) aEnd = std::min(now, win.end);

					const auto clipStart = std::max(aStart, win.start);
					const auto clipEnd = std::min(aEnd, win.end);
					if (clipEnd > clipStart) {
						const auto secs = std::chrono::duration_cast<std::chrono::seconds>(clipEnd - clipStart).count();
						out.downtimeMinutes += static_cast<double>(secs) / 60.0;
					}

					out.bySeverity[severity] += 1;
					out.alarmsOverlapping += 1;
				}
				else if (rc == SQLITE_DONE) {
					break;
				}
				else {
					break;
				}
			}

			sqlite3_finalize(stmt);
		}
	}

	sqlite3_close(db);
}

static void ComputeTransferSummaryFromDb(
	const ProductionShiftWindow& win,
	ProductionTransferSummary& out)
{
	const std::string dbPath = PickDbPath("DB\\TransferManager.db", "DB\\TransferManager.db");
	sqlite3* db = nullptr;
	if (sqlite3_open_v2(dbPath.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nullptr) != SQLITE_OK) {
		if (db) sqlite3_close(db);
		return;
	}

	const char* sql =
		"SELECT status, create_time, end_time "
		"FROM transfers "
		"WHERE end_time >= ? AND end_time < ? AND end_time != '';";
	sqlite3_stmt* stmt = nullptr;
	if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
		sqlite3_close(db);
		return;
	}

	sqlite3_bind_text(stmt, 1, win.startLocal.c_str(), -1, SQLITE_TRANSIENT);
	sqlite3_bind_text(stmt, 2, win.endLocal.c_str(), -1, SQLITE_TRANSIENT);

	long long totalSecs = 0;
	long long cntSecs = 0;

	for (;;) {
		const int rc = sqlite3_step(stmt);
		if (rc == SQLITE_ROW) {
			const char* sStatus = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
			const char* sCreate = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
			const char* sEnd = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));

			const std::string status = sStatus ? sStatus : "";
			out.byStatus[status] += 1;
			out.transfersFinished += 1;

			std::chrono::system_clock::time_point tpCreate{}, tpEnd{};
			if (TryParseLocalTime(sCreate ? sCreate : "", tpCreate) && TryParseLocalTime(sEnd ? sEnd : "", tpEnd) && tpEnd > tpCreate) {
				totalSecs += std::chrono::duration_cast<std::chrono::seconds>(tpEnd - tpCreate).count();
				cntSecs += 1;
			}
		}
		else if (rc == SQLITE_DONE) {
			break;
		}
		else {
			break;
		}
	}

	sqlite3_finalize(stmt);
	sqlite3_close(db);

	out.avgCreateToEndSeconds = (cntSecs > 0) ? (static_cast<double>(totalSecs) / static_cast<double>(cntSecs)) : 0.0;
}

bool ProductionStats::GetCurrentShiftWindow(CConfiguration& config, ProductionShiftWindow& outWindow)
{
	int dayMin = 8 * 60;
	int nightMin = 20 * 60;
	config.getProductionShiftStartMinutes(dayMin, nightMin);

	const auto now = std::chrono::system_clock::now();
	const std::time_t ttNow = std::chrono::system_clock::to_time_t(now);
	std::tm tmNow{};
	localtime_s(&tmNow, &ttNow);
	std::tm tmMid = tmNow;
	tmMid.tm_hour = 0;
	tmMid.tm_min = 0;
	tmMid.tm_sec = 0;
	tmMid.tm_isdst = -1;
	const std::time_t ttMid = mktime(&tmMid);
	if (ttMid == (time_t)-1) return false;

	const auto midnight = std::chrono::system_clock::from_time_t(ttMid);
	const auto startDayToday = midnight + std::chrono::minutes(dayMin);
	const auto startNightToday = midnight + std::chrono::minutes(nightMin);

	const auto startDay = (now >= startDayToday) ? startDayToday : (startDayToday - std::chrono::hours(24));
	const auto startNight = (now >= startNightToday) ? startNightToday : (startNightToday - std::chrono::hours(24));

	ProductionShiftType type = ProductionShiftType::Day;
	auto start = startDay;
	if (startNight > startDay) {
		type = ProductionShiftType::Night;
		start = startNight;
	}

	const int durationMin =
		(type == ProductionShiftType::Day)
		? ((nightMin - dayMin + 24 * 60) % (24 * 60))
		: ((dayMin - nightMin + 24 * 60) % (24 * 60));
	if (durationMin <= 0) return false;

	outWindow.type = type;
	outWindow.start = start;
	outWindow.end = start + std::chrono::minutes(durationMin);
	outWindow.startLocal = FormatLocal(outWindow.start);
	outWindow.endLocal = FormatLocal(outWindow.end);
	outWindow.startUtcIso = FormatUtcIso(outWindow.start);
	outWindow.endUtcIso = FormatUtcIso(outWindow.end);
	return true;
}

bool ProductionStats::ComputeCurrentShiftSummary(CConfiguration& config, ProductionShiftSummary& outSummary)
{
	ProductionShiftWindow win;
	if (!GetCurrentShiftWindow(config, win)) return false;

	outSummary = ProductionShiftSummary{};
	outSummary.window = win;

	ComputeOutputFromProcessDb(win, outSummary.output);
	ComputeAlarmSummaryFromDb(win, outSummary.alarms);
	ComputeTransferSummaryFromDb(win, outSummary.transfers);
	return true;
}

void ProductionStats::LogCurrentShiftSummary(CConfiguration& config)
{
	ProductionShiftSummary s;
	if (!ComputeCurrentShiftSummary(config, s)) {
		LOGE("<ProductionStats>Failed to compute shift summary.");
		return;
	}

	const char* shiftName = (s.window.type == ProductionShiftType::Day) ? "Day" : "Night";
	LOGI("<ProductionStats>Shift=%s, [%s ~ %s]", shiftName, s.window.startLocal.c_str(), s.window.endLocal.c_str());
	LOGI("<ProductionStats>Output(pairs): total=%lld, pass=%lld, fail=%lld, no_result=%lld, yield=%.2f%%",
		s.output.pairsTotal, s.output.pairsPass, s.output.pairsFail, s.output.pairsNoResult, s.output.yield * 100.0);
	LOGI("<ProductionStats>Takt: avg=%.1fs, samples=%lld", s.output.avgTaktSeconds, s.output.taktSamplePairs);
	LOGI("<ProductionStats>Alarms: triggered=%d, overlapping=%d, downtime=%.1f min",
		s.alarms.alarmsTriggered, s.alarms.alarmsOverlapping, s.alarms.downtimeMinutes);
	if (!s.alarms.bySeverity.empty()) {
		std::ostringstream oss;
		oss << "<ProductionStats>AlarmsBySeverity:";
		for (const auto& kv : s.alarms.bySeverity) oss << " L" << kv.first << "=" << kv.second;
		LOGI("%s", oss.str().c_str());
	}
	LOGI("<ProductionStats>Transfers: finished=%d, avg(create->end)=%.1fs", s.transfers.transfersFinished, s.transfers.avgCreateToEndSeconds);
	if (!s.transfers.byStatus.empty()) {
		std::ostringstream oss;
		oss << "<ProductionStats>TransfersByStatus:";
		for (const auto& kv : s.transfers.byStatus) oss << " " << kv.first << "=" << kv.second;
		LOGI("%s", oss.str().c_str());
	}
}

bool ProductionStats::ComputeDayNightSummaries(CConfiguration& config, ProductionShiftSummary& outDay, ProductionShiftSummary& outNight)
{
	ProductionShiftSummary cur;
	if (!ComputeCurrentShiftSummary(config, cur)) return false;

	// Determine previous adjacent window for the other shift.
	ProductionShiftSummary other = cur;
	if (cur.window.type == ProductionShiftType::Day) {
		other.window.type = ProductionShiftType::Night;
		other.window.end = cur.window.start;
		other.window.start = cur.window.start - (cur.window.end - cur.window.start);
	}
	else {
		other.window.type = ProductionShiftType::Day;
		other.window.end = cur.window.start;
		other.window.start = cur.window.start - (cur.window.end - cur.window.start);
	}
	other.window.startLocal = FormatLocal(other.window.start);
	other.window.endLocal = FormatLocal(other.window.end);
	other.window.startUtcIso = FormatUtcIso(other.window.start);
	other.window.endUtcIso = FormatUtcIso(other.window.end);

	other.output = ProductionOutputSummary{};
	other.alarms = ProductionAlarmSummary{};
	other.transfers = ProductionTransferSummary{};
	ComputeOutputFromProcessDb(other.window, other.output);
	ComputeAlarmSummaryFromDb(other.window, other.alarms);
	ComputeTransferSummaryFromDb(other.window, other.transfers);

	if (cur.window.type == ProductionShiftType::Day) {
		outDay = std::move(cur);
		outNight = std::move(other);
	}
	else {
		outNight = std::move(cur);
		outDay = std::move(other);
	}
	return true;
}