using Xunit;
using Moq;
using FluentAssertions;
using Microsoft.Extensions.Logging;
using Haoliang.Core.Services;
using Haoliang.Models.System;
using Haoliang.Data.Repositories;

namespace Haoliang.Tests;

public class AlarmServiceTests
{
    private readonly Mock<IAlarmRepository> _mockAlarmRepository;
    private readonly AlarmService _alarmService;

    public AlarmServiceTests()
    {
        _mockAlarmRepository = new Mock<IAlarmRepository>();
        _alarmService = new AlarmService(_mockAlarmRepository.Object);
    }

    [Fact]
    public async Task GetAllAlarmsAsync_ReturnsAlarmsFromRepository()
    {
        var alarms = new List<Alarm>
        {
            new Alarm { Id = 1, AlarmType = "DeviceOffline", AlarmContent = "Device 1 is offline" },
            new Alarm { Id = 2, AlarmType = "DeviceError", AlarmContent = "Device 2 has error" }
        };
        _mockAlarmRepository.Setup(r => r.GetAllAsync()).ReturnsAsync(alarms);

        var result = await _alarmService.GetAllAlarmsAsync();

        result.Should().HaveCount(2);
        result.Should().BeEquivalentTo(alarms);
    }

    [Fact]
    public async Task GetAlarmByIdAsync_ReturnsAlarm_WhenExists()
    {
        var alarm = new Alarm { Id = 1, AlarmType = "DeviceOffline", AlarmContent = "Device offline" };
        _mockAlarmRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(alarm);

        var result = await _alarmService.GetAlarmByIdAsync(1);

        result.Should().NotBeNull();
        result!.Id.Should().Be(1);
    }

    [Fact]
    public async Task GetAlarmByIdAsync_ReturnsNull_WhenNotExists()
    {
        _mockAlarmRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((Alarm?)null);

        var result = await _alarmService.GetAlarmByIdAsync(999);

        result.Should().BeNull();
    }

    [Fact]
    public async Task CreateAlarmAsync_SetsCreatedAtAndOccurrenceTime()
    {
        var alarm = new Alarm { AlarmType = "DeviceOffline", AlarmContent = "Test alarm" };
        _mockAlarmRepository.Setup(r => r.AddAsync(It.IsAny<Alarm>())).Returns(Task.CompletedTask);
        _mockAlarmRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var beforeCreate = DateTime.Now;
        var result = await _alarmService.CreateAlarmAsync(alarm);
        var afterCreate = DateTime.Now;

        result.CreatedAt.Should().BeOnOrAfter(beforeCreate);
        result.CreatedAt.Should().BeOnOrBefore(afterCreate);
        result.OccurrenceTime.Should().BeOnOrAfter(beforeCreate);
        result.OccurrenceTime.Should().BeOnOrBefore(afterCreate);
    }

    [Fact]
    public async Task DeleteAlarmAsync_ReturnsTrue_WhenAlarmExists()
    {
        var alarm = new Alarm { Id = 1 };
        _mockAlarmRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(alarm);
        _mockAlarmRepository.Setup(r => r.Remove(alarm)).Verifiable();
        _mockAlarmRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var result = await _alarmService.DeleteAlarmAsync(1);

        result.Should().BeTrue();
    }

    [Fact]
    public async Task DeleteAlarmAsync_ReturnsFalse_WhenAlarmNotExists()
    {
        _mockAlarmRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((Alarm?)null);

        var result = await _alarmService.DeleteAlarmAsync(999);

        result.Should().BeFalse();
    }

    [Fact]
    public async Task GetActiveAlarmsAsync_ReturnsUnresolvedAlarms()
    {
        var activeAlarms = new List<Alarm>
        {
            new Alarm { Id = 1, IsResolved = false, AlarmType = "DeviceOffline" },
            new Alarm { Id = 2, IsResolved = false, AlarmType = "DeviceError" }
        };
        _mockAlarmRepository.Setup(r => r.GetActiveAlarmsAsync()).ReturnsAsync(activeAlarms);

        var result = await _alarmService.GetActiveAlarmsAsync();

        result.Should().HaveCount(2);
    }

    [Fact]
    public async Task GetAlarmsByTypeAsync_ReturnsFilteredAlarms()
    {
        var typeAlarms = new List<Alarm>
        {
            new Alarm { Id = 1, AlarmType = "DeviceOffline" }
        };
        _mockAlarmRepository.Setup(r => r.GetAlarmsByTypeAsync("DeviceOffline")).ReturnsAsync(typeAlarms);

        var result = await _alarmService.GetAlarmsByTypeAsync(AlarmType.DeviceOffline);

        result.Should().HaveCount(1);
    }

    [Fact]
    public async Task GetCriticalAlarmsAsync_ReturnsCriticalAlarms()
    {
        var criticalAlarms = new List<Alarm>
        {
            new Alarm { Id = 1, AlarmLevel = "Critical" }
        };
        _mockAlarmRepository.Setup(r => r.GetAlarmsByLevelAsync("Critical")).ReturnsAsync(criticalAlarms);

        var result = await _alarmService.GetCriticalAlarmsAsync();

        result.Should().HaveCount(1);
    }
}

public class AlarmRuleServiceTests
{
    private readonly AlarmRuleService _alarmRuleService;

    public AlarmRuleServiceTests()
    {
        _alarmRuleService = new AlarmRuleService();
    }

    [Fact]
    public async Task GetAllAlarmRulesAsync_ReturnsCreatedRules()
    {
        await _alarmRuleService.CreateAlarmRuleAsync(new AlarmRule
        {
            RuleName = "Rule1",
            Condition = "Condition1",
            AlarmType = "DeviceError",
            AlarmLevel = "Low"
        });

        var result = await _alarmRuleService.GetAllAlarmRulesAsync();

        result.Should().NotBeEmpty();
        result.Should().HaveCount(1);
    }

    [Fact]
    public async Task CreateAlarmRuleAsync_AddsRule_WithIncrementedId()
    {
        var rule = new AlarmRule
        {
            RuleName = "High Temperature",
            Condition = "Temperature > 100",
            AlarmType = "DeviceError",
            AlarmLevel = "Critical",
            IsEnabled = true
        };

        var result = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        result.Id.Should().BeGreaterThan(0);
        result.CreatedAt.Should().BeCloseTo(DateTime.Now, TimeSpan.FromSeconds(1));
    }

    [Fact]
    public async Task GetAlarmRuleByIdAsync_ReturnsRule_WhenExists()
    {
        var rule = new AlarmRule
        {
            RuleName = "High Temperature",
            Condition = "Temperature > 100",
            AlarmType = "DeviceError",
            AlarmLevel = "Critical"
        };
        var created = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        var result = await _alarmRuleService.GetAlarmRuleByIdAsync(created.Id);

        result.Should().NotBeNull();
        result!.RuleName.Should().Be("High Temperature");
    }

    [Fact]
    public async Task GetAlarmRuleByIdAsync_ReturnsNull_WhenNotExists()
    {
        var result = await _alarmRuleService.GetAlarmRuleByIdAsync(999);

        result.Should().BeNull();
    }

    [Fact]
    public async Task UpdateAlarmRuleAsync_UpdatesRule_WhenExists()
    {
        var rule = new AlarmRule
        {
            RuleName = "Original Rule",
            Condition = "Original Condition",
            AlarmType = "DeviceError",
            AlarmLevel = "Low"
        };
        var created = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        var updated = await _alarmRuleService.UpdateAlarmRuleAsync(created.Id, new AlarmRule
        {
            RuleName = "Updated Rule",
            Condition = "Updated Condition",
            AlarmType = "DeviceError",
            AlarmLevel = "Critical"
        });

        updated.Should().NotBeNull();
        updated!.RuleName.Should().Be("Updated Rule");
        updated.AlarmLevel.Should().Be("Critical");
    }

    [Fact]
    public async Task UpdateAlarmRuleAsync_ReturnsNull_WhenNotExists()
    {
        var result = await _alarmRuleService.UpdateAlarmRuleAsync(999, new AlarmRule());

        result.Should().BeNull();
    }

    [Fact]
    public async Task DeleteAlarmRuleAsync_ReturnsTrue_WhenExists()
    {
        var rule = new AlarmRule { RuleName = "To Delete" };
        var created = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        var result = await _alarmRuleService.DeleteAlarmRuleAsync(created.Id);

        result.Should().BeTrue();
    }

    [Fact]
    public async Task DeleteAlarmRuleAsync_ReturnsFalse_WhenNotExists()
    {
        var result = await _alarmRuleService.DeleteAlarmRuleAsync(999);

        result.Should().BeFalse();
    }

    [Fact]
    public async Task SetAlarmRuleEnabledAsync_EnablesRule()
    {
        var rule = new AlarmRule { RuleName = "Test Rule", IsEnabled = false };
        var created = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        await _alarmRuleService.SetAlarmRuleEnabledAsync(created.Id, true);

        var updated = await _alarmRuleService.GetAlarmRuleByIdAsync(created.Id);
        updated!.IsEnabled.Should().BeTrue();
    }

    [Fact]
    public async Task TestAlarmRuleAsync_Completes()
    {
        var rule = new AlarmRule { RuleName = "Test Rule" };
        var created = await _alarmRuleService.CreateAlarmRuleAsync(rule);

        await _alarmRuleService.TestAlarmRuleAsync(created.Id);
    }
}