Tau.Acuvim/console/src/Tau.Acuvim.Console/Services/AlertService.cs

using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using Tau.Acuvim.Console.Data;
using Tau.Acuvim.Console.Models;

namespace Tau.Acuvim.Console.Services;

public class AlertService
{
    private readonly AppDbContext _db;
    private readonly ILogger<AlertService> _logger;

    public AlertService(AppDbContext db, ILogger<AlertService> logger)
    {
        _db = db;
        _logger = logger;
    }

    public async Task ProcessAlertAsync(string deviceId, string payload)
    {
        try
        {
            using var doc = JsonDocument.Parse(payload);
            var root = doc.RootElement;

            var alert = new Alert
            {
                DeviceId = deviceId,
                AlertType = root.GetProperty("alert").GetString() ?? "unknown",
                Severity = root.GetProperty("severity").GetString() ?? "info",
                Message = root.GetProperty("message").GetString() ?? "",
                Value = root.TryGetProperty("value", out var v) ? v.GetDouble() : null,
                Threshold = root.TryGetProperty("threshold", out var t) ? t.GetDouble() : null,
                Metadata = JsonDocument.Parse(payload)
            };

            _db.Alerts.Add(alert);
            await _db.SaveChangesAsync();

            _logger.LogWarning("Alert {Type} from {DeviceId}: {Message}",
                alert.AlertType, deviceId, alert.Message);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process alert from {DeviceId}", deviceId);
        }
    }

    public async Task<List<Alert>> GetAllAsync(string? deviceId, string? severity,
        bool? acknowledged, int page, int pageSize)
    {
        var query = _db.Alerts.AsQueryable();

        if (!string.IsNullOrEmpty(deviceId))
            query = query.Where(a => a.DeviceId == deviceId);
        if (!string.IsNullOrEmpty(severity))
            query = query.Where(a => a.Severity == severity);
        if (acknowledged.HasValue)
            query = query.Where(a => a.Acknowledged == acknowledged.Value);

        return await query
            .OrderByDescending(a => a.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();
    }

    public async Task<List<Alert>> GetByDeviceAsync(string deviceId, int page, int pageSize)
    {
        return await _db.Alerts
            .Where(a => a.DeviceId == deviceId)
            .OrderByDescending(a => a.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();
    }

    public async Task<bool> AcknowledgeAsync(long id, string acknowledgedBy)
    {
        var alert = await _db.Alerts.FindAsync(id);
        if (alert == null) return false;

        alert.Acknowledged = true;
        alert.AcknowledgedBy = acknowledgedBy;
        alert.AcknowledgedAt = DateTime.UtcNow;
        await _db.SaveChangesAsync();
        return true;
    }

    public async Task<int> GetActiveCountAsync()
    {
        return await _db.Alerts
            .Where(a => !a.Acknowledged && a.ResolvedAt == null)
            .CountAsync();
    }
}