433 lines
22 KiB
C#
433 lines
22 KiB
C#
using Flurl.Http;
|
||
using InnovEnergy.App.Backend.Database;
|
||
using InnovEnergy.App.Backend.DataTypes;
|
||
using Newtonsoft.Json;
|
||
|
||
namespace InnovEnergy.App.Backend.Services;
|
||
|
||
public static class WeeklyReportService
|
||
{
|
||
private static readonly string TmpReportDir = Environment.CurrentDirectory + "/tmp_report/";
|
||
|
||
// ── Calendar Week Helpers ──────────────────────────────────────────
|
||
|
||
/// <summary>
|
||
/// Returns the last completed calendar week (Mon–Sun).
|
||
/// Example: called on Wednesday 2026-03-11 → returns (2026-03-02, 2026-03-08).
|
||
/// </summary>
|
||
public static (DateOnly Monday, DateOnly Sunday) LastCalendarWeek()
|
||
{
|
||
var today = DateOnly.FromDateTime(DateTime.UtcNow);
|
||
// DayOfWeek: Sun=0, Mon=1, ..., Sat=6
|
||
// daysSinceMonday: Mon=0, Tue=1, ..., Sun=6
|
||
var daysSinceMonday = ((Int32)today.DayOfWeek + 6) % 7;
|
||
var thisMonday = today.AddDays(-daysSinceMonday);
|
||
var lastMonday = thisMonday.AddDays(-7);
|
||
var lastSunday = thisMonday.AddDays(-1);
|
||
return (lastMonday, lastSunday);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns the calendar week before last (for comparison).
|
||
/// </summary>
|
||
private static (DateOnly Monday, DateOnly Sunday) PreviousCalendarWeek()
|
||
{
|
||
var (lastMon, _) = LastCalendarWeek();
|
||
return (lastMon.AddDays(-7), lastMon.AddDays(-1));
|
||
}
|
||
|
||
// ── Report Generation ──────────────────────────────────────────────
|
||
|
||
/// <summary>
|
||
/// Generates a full weekly report for the given installation.
|
||
/// Data source priority:
|
||
/// 1. DailyEnergyRecord rows in SQLite (populated by DailyIngestionService)
|
||
/// 2. xlsx file fallback (if DB not yet populated for the target week)
|
||
/// Cache is keyed to the calendar week — invalidated when the week changes.
|
||
/// Pass weekStartOverride to generate a report for a specific historical week (disables cache).
|
||
/// </summary>
|
||
public static async Task<WeeklyReportResponse> GenerateReportAsync(
|
||
long installationId, string installationName, string language = "en",
|
||
DateOnly? weekStartOverride = null)
|
||
{
|
||
DateOnly curMon, curSun, prevMon, prevSun;
|
||
|
||
if (weekStartOverride.HasValue)
|
||
{
|
||
// Debug/backfill mode: use the provided Monday as the week start
|
||
curMon = weekStartOverride.Value;
|
||
curSun = curMon.AddDays(6);
|
||
prevMon = curMon.AddDays(-7);
|
||
prevSun = curMon.AddDays(-1);
|
||
}
|
||
else
|
||
{
|
||
(curMon, curSun) = LastCalendarWeek();
|
||
(prevMon, prevSun) = PreviousCalendarWeek();
|
||
}
|
||
|
||
// Skip file cache when a specific week is requested (avoid stale or wrong-week hits)
|
||
var cachePath = weekStartOverride.HasValue
|
||
? null
|
||
: TmpReportDir + $"{installationId}_{language}_{curMon:yyyy-MM-dd}.cache.json";
|
||
|
||
// Use cache if it exists and is less than 6 hours old (skipped in override mode)
|
||
if (cachePath != null && File.Exists(cachePath))
|
||
{
|
||
var cacheAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(cachePath);
|
||
if (cacheAge.TotalHours < 6)
|
||
{
|
||
try
|
||
{
|
||
var cached = JsonConvert.DeserializeObject<WeeklyReportResponse>(
|
||
await File.ReadAllTextAsync(cachePath));
|
||
if (cached != null)
|
||
{
|
||
Console.WriteLine($"[WeeklyReportService] Returning cached report for installation {installationId} ({language}), week {curMon:yyyy-MM-dd}.");
|
||
return cached;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// Cache corrupt — regenerate
|
||
}
|
||
}
|
||
}
|
||
|
||
// 1. Try to load daily records from SQLite for the calendar weeks
|
||
var currentWeekDays = Db.GetDailyRecords(installationId, curMon, curSun)
|
||
.Select(r => ToDailyEnergyData(r)).ToList();
|
||
var previousWeekDays = Db.GetDailyRecords(installationId, prevMon, prevSun)
|
||
.Select(r => ToDailyEnergyData(r)).ToList();
|
||
|
||
// 2. Fallback: if DB empty for current week, parse all xlsx files on the fly
|
||
var xlsxFiles = Directory.Exists(TmpReportDir)
|
||
? Directory.GetFiles(TmpReportDir, $"{installationId}*.xlsx").OrderBy(f => f).ToList()
|
||
: new List<String>();
|
||
|
||
if (currentWeekDays.Count == 0 && xlsxFiles.Count > 0)
|
||
{
|
||
Console.WriteLine($"[WeeklyReportService] DB empty for week {curMon:yyyy-MM-dd}, falling back to xlsx.");
|
||
var allDaysParsed = xlsxFiles.SelectMany(p => ExcelDataParser.Parse(p)).ToList();
|
||
currentWeekDays = allDaysParsed
|
||
.Where(d => { var date = DateOnly.Parse(d.Date); return date >= curMon && date <= curSun; })
|
||
.ToList();
|
||
previousWeekDays = allDaysParsed
|
||
.Where(d => { var date = DateOnly.Parse(d.Date); return date >= prevMon && date <= prevSun; })
|
||
.ToList();
|
||
}
|
||
|
||
if (currentWeekDays.Count == 0)
|
||
throw new InvalidOperationException(
|
||
$"No energy data available for week {curMon:yyyy-MM-dd}–{curSun:yyyy-MM-dd}. " +
|
||
"Upload an xlsx file or wait for daily ingestion.");
|
||
|
||
// 3. Load hourly data from ALL xlsx files for behavioral analysis (current week only).
|
||
// Combine all files so any week can find its hourly data regardless of file split.
|
||
// Future: replace with S3 hourly fetch.
|
||
var allHourly = xlsxFiles
|
||
.SelectMany(p => { try { return ExcelDataParser.ParseHourly(p); } catch { return Enumerable.Empty<HourlyEnergyData>(); } })
|
||
.ToList();
|
||
var curMonDt = curMon.ToDateTime(TimeOnly.MinValue);
|
||
var curSunDt = curSun.ToDateTime(TimeOnly.MaxValue);
|
||
var currentHourlyData = allHourly
|
||
.Where(h => h.DateTime >= curMonDt && h.DateTime <= curSunDt)
|
||
.ToList();
|
||
|
||
var report = await GenerateReportFromDataAsync(
|
||
currentWeekDays, previousWeekDays, currentHourlyData, installationName, language,
|
||
curMon, curSun);
|
||
|
||
// Write cache (skipped in override mode)
|
||
if (cachePath != null)
|
||
{
|
||
try
|
||
{
|
||
await File.WriteAllTextAsync(cachePath, JsonConvert.SerializeObject(report));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.Error.WriteLine($"[WeeklyReportService] Could not write cache: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
return report;
|
||
}
|
||
|
||
// ── Conversion helpers ─────────────────────────────────────────────
|
||
|
||
private static DailyEnergyData ToDailyEnergyData(DailyEnergyRecord r) => new()
|
||
{
|
||
Date = r.Date,
|
||
PvProduction = r.PvProduction,
|
||
LoadConsumption = r.LoadConsumption,
|
||
GridImport = r.GridImport,
|
||
GridExport = r.GridExport,
|
||
BatteryCharged = r.BatteryCharged,
|
||
BatteryDischarged = r.BatteryDischarged,
|
||
};
|
||
|
||
/// <summary>
|
||
/// Core report generation. Accepts pre-split current/previous week data and hourly intervals.
|
||
/// weekStart/weekEnd are used to set PeriodStart/PeriodEnd on the response.
|
||
/// </summary>
|
||
public static async Task<WeeklyReportResponse> GenerateReportFromDataAsync(
|
||
List<DailyEnergyData> currentWeekDays,
|
||
List<DailyEnergyData> previousWeekDays,
|
||
List<HourlyEnergyData> currentHourlyData,
|
||
string installationName,
|
||
string language = "en",
|
||
DateOnly? weekStart = null,
|
||
DateOnly? weekEnd = null)
|
||
{
|
||
currentWeekDays = currentWeekDays.OrderBy(d => d.Date).ToList();
|
||
previousWeekDays = previousWeekDays.OrderBy(d => d.Date).ToList();
|
||
|
||
var currentSummary = Summarize(currentWeekDays);
|
||
var previousSummary = previousWeekDays.Count > 0 ? Summarize(previousWeekDays) : null;
|
||
|
||
// Key ratios for current week
|
||
var selfSufficiency = currentSummary.TotalConsumption > 0
|
||
? Math.Round((currentSummary.TotalConsumption - currentSummary.TotalGridImport) / currentSummary.TotalConsumption * 100, 1)
|
||
: 0;
|
||
|
||
var selfConsumption = currentSummary.TotalPvProduction > 0
|
||
? Math.Round((currentSummary.TotalPvProduction - currentSummary.TotalGridExport) / currentSummary.TotalPvProduction * 100, 1)
|
||
: 0;
|
||
|
||
var batteryEfficiency = currentSummary.TotalBatteryCharged > 0
|
||
? Math.Round(currentSummary.TotalBatteryDischarged / currentSummary.TotalBatteryCharged * 100, 1)
|
||
: 0;
|
||
|
||
var gridDependency = currentSummary.TotalConsumption > 0
|
||
? Math.Round(currentSummary.TotalGridImport / currentSummary.TotalConsumption * 100, 1)
|
||
: 0;
|
||
|
||
// Week-over-week changes
|
||
var pvChange = PercentChange(previousSummary?.TotalPvProduction, currentSummary.TotalPvProduction);
|
||
var consumptionChange = PercentChange(previousSummary?.TotalConsumption, currentSummary.TotalConsumption);
|
||
var gridImportChange = PercentChange(previousSummary?.TotalGridImport, currentSummary.TotalGridImport);
|
||
|
||
// Behavioral pattern from hourly data (pure C# — no AI)
|
||
var behavior = BehaviorAnalyzer.Analyze(currentHourlyData);
|
||
|
||
// Pre-computed savings — single source of truth for UI and AI
|
||
const double ElectricityPriceCHF = 0.39;
|
||
var totalEnergySaved = Math.Round(currentSummary.TotalConsumption - currentSummary.TotalGridImport, 1);
|
||
var totalSavingsCHF = Math.Round(totalEnergySaved * ElectricityPriceCHF, 0);
|
||
var avgDailyConsumption = currentWeekDays.Count > 0 ? currentSummary.TotalConsumption / currentWeekDays.Count : 0;
|
||
var daysEquivalent = avgDailyConsumption > 0 ? Math.Round(totalEnergySaved / avgDailyConsumption, 1) : 0;
|
||
|
||
// AI insight combining daily facts + behavioral pattern
|
||
var aiInsight = await GetAiInsightAsync(
|
||
currentWeekDays, currentSummary, previousSummary,
|
||
selfSufficiency, totalEnergySaved, totalSavingsCHF,
|
||
behavior, installationName, language);
|
||
|
||
return new WeeklyReportResponse
|
||
{
|
||
InstallationName = installationName,
|
||
PeriodStart = currentWeekDays.First().Date,
|
||
PeriodEnd = currentWeekDays.Last().Date,
|
||
CurrentWeek = currentSummary,
|
||
PreviousWeek = previousSummary,
|
||
TotalEnergySaved = totalEnergySaved,
|
||
TotalSavingsCHF = totalSavingsCHF,
|
||
DaysEquivalent = daysEquivalent,
|
||
SelfSufficiencyPercent = selfSufficiency,
|
||
SelfConsumptionPercent = selfConsumption,
|
||
BatteryEfficiencyPercent = batteryEfficiency,
|
||
GridDependencyPercent = gridDependency,
|
||
PvChangePercent = pvChange,
|
||
ConsumptionChangePercent = consumptionChange,
|
||
GridImportChangePercent = gridImportChange,
|
||
DailyData = currentWeekDays,
|
||
Behavior = behavior,
|
||
AiInsight = aiInsight,
|
||
};
|
||
}
|
||
|
||
private static WeeklySummary Summarize(List<DailyEnergyData> days) => new()
|
||
{
|
||
TotalPvProduction = Math.Round(days.Sum(d => d.PvProduction), 1),
|
||
TotalConsumption = Math.Round(days.Sum(d => d.LoadConsumption), 1),
|
||
TotalGridImport = Math.Round(days.Sum(d => d.GridImport), 1),
|
||
TotalGridExport = Math.Round(days.Sum(d => d.GridExport), 1),
|
||
TotalBatteryCharged = Math.Round(days.Sum(d => d.BatteryCharged), 1),
|
||
TotalBatteryDischarged = Math.Round(days.Sum(d => d.BatteryDischarged), 1),
|
||
};
|
||
|
||
private static double PercentChange(double? previous, double current)
|
||
{
|
||
if (previous is null or 0) return 0;
|
||
return Math.Round((current - previous.Value) / previous.Value * 100, 1);
|
||
}
|
||
|
||
// ── Mistral AI Insight ──────────────────────────────────────────────
|
||
|
||
private static readonly string MistralUrl = "https://api.mistral.ai/v1/chat/completions";
|
||
|
||
private static string LanguageName(string code) => code switch
|
||
{
|
||
"de" => "German",
|
||
"fr" => "French",
|
||
"it" => "Italian",
|
||
_ => "English"
|
||
};
|
||
|
||
private static string FormatHour(int hour) => $"{hour:D2}:00";
|
||
private static string FormatHourSlot(int hour) => $"{hour:D2}:00–{hour + 1:D2}:00";
|
||
|
||
private static async Task<string> GetAiInsightAsync(
|
||
List<DailyEnergyData> currentWeek,
|
||
WeeklySummary current,
|
||
WeeklySummary? previous,
|
||
double selfSufficiency,
|
||
double totalEnergySaved,
|
||
double totalSavingsCHF,
|
||
BehavioralPattern behavior,
|
||
string installationName,
|
||
string language = "en")
|
||
{
|
||
var apiKey = Environment.GetEnvironmentVariable("MISTRAL_API_KEY");
|
||
if (string.IsNullOrWhiteSpace(apiKey))
|
||
{
|
||
Console.WriteLine("[WeeklyReportService] MISTRAL_API_KEY not set — skipping AI insight.");
|
||
return "AI insight unavailable (API key not configured).";
|
||
}
|
||
|
||
const double ElectricityPriceCHF = 0.39;
|
||
|
||
// Detect which components are present
|
||
var hasPv = currentWeek.Sum(d => d.PvProduction) > 0.5;
|
||
var hasBattery = currentWeek.Sum(d => d.BatteryCharged) > 0.5
|
||
|| currentWeek.Sum(d => d.BatteryDischarged) > 0.5;
|
||
var hasGrid = currentWeek.Sum(d => d.GridImport) > 0.5;
|
||
|
||
var bestDay = currentWeek.OrderByDescending(d => d.PvProduction).First();
|
||
var worstDay = currentWeek.OrderBy(d => d.PvProduction).First();
|
||
var bestDayName = DateTime.Parse(bestDay.Date).ToString("dddd");
|
||
var worstDayName = DateTime.Parse(worstDay.Date).ToString("dddd");
|
||
|
||
var topBattDay = currentWeek.OrderByDescending(d => d.BatteryCharged).First();
|
||
var topBattDayName = DateTime.Parse(topBattDay.Date).ToString("dddd");
|
||
|
||
// Behavioral facts as compact lines
|
||
var peakSolarWindow = FormatHour(behavior.PeakSolarHour) + "–" + FormatHour(behavior.PeakSolarEndHour);
|
||
var avoidableSavingsCHF = Math.Round(behavior.AvoidableGridKwh * ElectricityPriceCHF, 0);
|
||
|
||
var battDepleteLine = hasBattery
|
||
? (behavior.AvgBatteryDepletedHour >= 0
|
||
? $"Battery typically depletes below 20% during {FormatHourSlot(behavior.AvgBatteryDepletedHour)}."
|
||
: "Battery stayed above 20% SoC every night this week.")
|
||
: "";
|
||
|
||
var weekdayWeekendLine = behavior.WeekendAvgDailyLoad > 0
|
||
? $"Weekday avg load: {behavior.WeekdayAvgDailyLoad} kWh/day. Weekend avg: {behavior.WeekendAvgDailyLoad} kWh/day."
|
||
: $"Weekday avg load: {behavior.WeekdayAvgDailyLoad} kWh/day.";
|
||
|
||
// Build conditional fact lines
|
||
var pvDailyFact = hasPv
|
||
? $"- PV: total {current.TotalPvProduction:F1} kWh this week. Best day: {bestDayName} ({bestDay.PvProduction:F1} kWh), worst: {worstDayName} ({worstDay.PvProduction:F1} kWh). Solar covered {selfSufficiency}% of consumption."
|
||
: "";
|
||
var battDailyFact = hasBattery
|
||
? $"- Battery: {current.TotalBatteryCharged:F1} kWh charged, {current.TotalBatteryDischarged:F1} kWh discharged. Most active day: {topBattDayName} ({topBattDay.BatteryCharged:F1} kWh charged)."
|
||
: "";
|
||
var gridDailyFact = hasGrid
|
||
? $"- Grid import: {current.TotalGridImport:F1} kWh total this week."
|
||
: "";
|
||
|
||
var pvBehaviorLines = hasPv ? $@"
|
||
- Solar active window: {peakSolarWindow}; peak hour: {FormatHourSlot(behavior.PeakSolarHour)}, avg {behavior.AvgPeakSolarKwh} kWh during that hour
|
||
- Grid imported while solar was active: {behavior.AvoidableGridKwh} kWh = {avoidableSavingsCHF} CHF that could have been avoided" : "";
|
||
|
||
var gridBehaviorLine = hasGrid
|
||
? $"- Highest grid-import hour: {FormatHourSlot(behavior.HighestGridImportHour)}, avg {behavior.AvgGridImportAtPeakHour} kWh during that hour"
|
||
: "";
|
||
|
||
var battBehaviorLine = !string.IsNullOrEmpty(battDepleteLine) ? $"- {battDepleteLine}" : "";
|
||
|
||
// Build conditional instructions
|
||
var instruction1 = $"1. Energy savings: Write 1–2 sentences. Say that this week, thanks to sodistore home, the customer avoided buying {totalEnergySaved} kWh from the grid, saving {totalSavingsCHF} CHF (at {ElectricityPriceCHF} CHF/kWh). Use these exact numbers — do not recalculate or change them.";
|
||
|
||
var instruction2 = hasPv
|
||
? $"2. Solar performance: Comment on the best and worst solar day this week and the likely weather reason."
|
||
: hasGrid
|
||
? $"2. Grid usage: Comment on the {current.TotalGridImport:F1} kWh drawn from the grid this week and what time of day drives it most ({FormatHourSlot(behavior.HighestGridImportHour)})."
|
||
: "2. Consumption pattern: Comment on the weekday vs weekend load pattern.";
|
||
|
||
var instruction3 = hasBattery
|
||
? $"3. Battery performance: Use the daily facts. Keep it simple for a homeowner."
|
||
: "3. Consumption pattern: Comment on the peak load time and weekday vs weekend usage.";
|
||
|
||
var instruction4 = hasPv
|
||
? $"4. Smart action for next week: Write exactly 2 sentences. Sentence 1: point out the timing mismatch using exact numbers — peak household load is during {FormatHourSlot(behavior.PeakLoadHour)} ({behavior.AvgPeakLoadKwh} kWh) but solar peaks during {FormatHourSlot(behavior.PeakSolarHour)} ({behavior.AvgPeakSolarKwh} kWh), with solar active from {peakSolarWindow}. Sentence 2: suggest shifting energy-intensive appliances (such as washing machine, dishwasher, heat pump, or EV charger if applicable) to run during the solar window {peakSolarWindow} — do not assume which specific device the customer has."
|
||
: hasGrid
|
||
? $"4. Smart action for next week: Write exactly 2 sentences. Sentence 1: state that the peak grid-import hour is {FormatHourSlot(behavior.HighestGridImportHour)} ({behavior.AvgGridImportAtPeakHour} kWh avg). Sentence 2: suggest one action to reduce grid use during that hour — shifting energy-intensive appliances (washing machine, dishwasher, heat pump, EV charger) away from that time."
|
||
: "4. Smart action for next week: Give one practical tip to reduce energy consumption based on the peak load time and weekday/weekend pattern.";
|
||
|
||
var prompt = $@"You are an energy advisor for a sodistore home installation: ""{installationName}"".
|
||
|
||
Write 4 bullet points (each on its own line starting with ""- ""). No bold markers, no asterisks, no markdown — plain text only.
|
||
|
||
IMPORTANT FORMAT RULE: Each bullet MUST start with a short title followed by a colon, then the description. Example: ""- Title label: Description text here."" Translate the title label into {LanguageName(language)} but always keep the ""Title: description"" structure.
|
||
|
||
CRITICAL: All numbers below are pre-calculated. Use these values as-is — do not recalculate, round differently, or change any number.
|
||
|
||
SYSTEM COMPONENTS: PV={hasPv}, Battery={hasBattery}, Grid={hasGrid}
|
||
|
||
DAILY FACTS:
|
||
- Total consumption: {current.TotalConsumption:F1} kWh this week. Self-sufficiency: {selfSufficiency}%.
|
||
{pvDailyFact}
|
||
{battDailyFact}
|
||
{gridDailyFact}
|
||
|
||
BEHAVIORAL PATTERN (from hourly data this week):
|
||
- Peak household load: {FormatHourSlot(behavior.PeakLoadHour)}, avg {behavior.AvgPeakLoadKwh} kWh during that hour
|
||
- {weekdayWeekendLine}{pvBehaviorLines}
|
||
{gridBehaviorLine}
|
||
{battBehaviorLine}
|
||
|
||
INSTRUCTIONS:
|
||
{instruction1}
|
||
{instruction2}
|
||
{instruction3}
|
||
{instruction4}
|
||
|
||
Rules: Write for a homeowner, not an engineer. Do NOT use asterisks or any formatting marks. Only describe components that exist (PV={hasPv}, Battery={hasBattery}, Grid={hasGrid}). Do NOT add any closing remark, summary sentence, or motivational phrase after the 4 bullet points (e.g. no 'Das ist ein guter Fortschritt', 'Keep it up', 'Good progress', etc.). Write exactly 4 bullet points — nothing before, nothing after.
|
||
IMPORTANT: Write your entire response in {LanguageName(language)}.";
|
||
|
||
try
|
||
{
|
||
var requestBody = new
|
||
{
|
||
model = "mistral-small-latest",
|
||
messages = new[] { new { role = "user", content = prompt } },
|
||
max_tokens = 400,
|
||
temperature = 0.3
|
||
};
|
||
|
||
var responseText = await MistralUrl
|
||
.WithHeader("Authorization", $"Bearer {apiKey}")
|
||
.PostJsonAsync(requestBody)
|
||
.ReceiveString();
|
||
|
||
var envelope = JsonConvert.DeserializeObject<dynamic>(responseText);
|
||
var content = (string?)envelope?.choices?[0]?.message?.content;
|
||
|
||
if (!string.IsNullOrWhiteSpace(content))
|
||
{
|
||
var insight = content.Trim();
|
||
Console.WriteLine($"[WeeklyReportService] AI insight generated ({insight.Length} chars).");
|
||
return insight;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.Error.WriteLine($"[WeeklyReportService] Mistral error: {ex.Message}");
|
||
}
|
||
|
||
return "AI insight could not be generated at this time.";
|
||
}
|
||
}
|