using Admin.NET.Core;
using Evergreen.Health.Application.Health.Entities;
using Evergreen.Health.Application.Health.Integrations.Ib43;
using Evergreen.Health.Application.Health.Services;
using Evergreen.Health.Application.Health.Sleep;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using SqlSugar;
using System.Security.Claims;
using Xunit;

namespace Admin.NET.Test.Health;

public sealed class Ib43PersistenceTests : IDisposable
{
    private const string PreviewAction = "dehumidifier-humidity-preview";
    private readonly SqlSugarClient _db;
    private readonly string _databasePath = Path.Combine(Path.GetTempPath(), "ib43-test-" + Guid.NewGuid().ToString("N") + ".db");
    private readonly Ib43DataRepository _repository;
    private readonly Clock _clock = new();
    private readonly Ib43Binding _device = new() { ProductKey = "test", SerialNumber = "sim", Simulation = true };
    private readonly HttpContextAccessor _context = new() { HttpContext = new DefaultHttpContext() };
    private readonly HealthIb43Service _service;
    private readonly BedPresenceAutomation _automation;

    private sealed class Clock : TimeProvider
    {
        public DateTimeOffset Now = DateTimeOffset.FromUnixTimeMilliseconds(1000000);
        public override DateTimeOffset GetUtcNow() => Now;
    }

    public Ib43PersistenceTests()
    {
        _db = new SqlSugarClient(new ConnectionConfig { ConnectionString = "DataSource=" + _databasePath,
            DbType = DbType.Sqlite, IsAutoCloseConnection = false, InitKeyType = InitKeyType.Attribute,
            ConfigureExternalServices = new ConfigureExternalServices { EntityService = (property, column) =>
            {
                // SQLite 的 rowid 必须声明 INTEGER；MySQL 生产表保持 bigint identity。
                if (property.DeclaringType == typeof(HealthIb43Observation) && property.Name == "Id") column.DataType = "INTEGER";
                if (Nullable.GetUnderlyingType(property.PropertyType) != null) column.IsNullable = true;
            } } });
        _db.CodeFirst.InitTables<HealthIb43Binding, HealthIb43Observation, HealthUser>();
        _db.CodeFirst.InitTables<HealthIb43AutomationExecution>();
        _db.Ado.ExecuteCommand("CREATE TABLE SysUser (Id INTEGER PRIMARY KEY, AccountType INTEGER, Status INTEGER)");
        _db.Ado.ExecuteCommand("INSERT INTO SysUser VALUES (99,999,1)");
        foreach (var id in new[] { 1L, 2L, 3L })
            _db.Insertable(new HealthUser { Id = id, Phone = id.ToString(), DisplayName = "test", PasswordHash = "unused",
                CreateTime = DateTime.UtcNow, CreateUserName = "test", UpdateUserName = "test" }).ExecuteCommand();
        _repository = new(_db);
        _automation = CreateAutomation(_repository, PreviewAction);
        _service = CreateService(_repository, _automation);
    }

    private BedPresenceAutomation CreateAutomation(Ib43DataRepository repository, string secondaryAction) =>
        new(Options.Create(new BedPresenceAutomationOptions
        {
            Mode = BedAutomationMode.Managed, ProductKey = _device.ProductKey, SerialNumber = _device.SerialNumber,
            ActionKey = "curtain-close", TargetEntityId = "cover.test", TargetLabel = "测试窗帘",
            AdditionalRules = [new() { Mode = BedAutomationMode.Managed, ProductKey = _device.ProductKey,
                SerialNumber = _device.SerialNumber, ActionKey = secondaryAction, TargetEntityId = "humidifier.test" }]
        }), [new TestAction("curtain-close", "cover.test"), new TestAction(secondaryAction, "humidifier.test")],
            _clock, NullLogger<BedPresenceAutomation>.Instance, new TestExecutionLog(repository));

    private HealthIb43Service CreateService(Ib43DataRepository repository, BedPresenceAutomation automation)
    {
        var options = Options.Create(new Ib43Options { Enabled = true, Devices = [_device] });
        return new(repository, _context, options, new(options, new(), _clock), _clock, automation);
    }

    private void User(long id) => _context.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(
        [new Claim("health_user_id", id.ToString())], "test"));
    private void Admin() => _context.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(
        [new Claim(ClaimConst.UserId, "99"), new Claim(ClaimConst.AccountType, "999")], "test"));
    private async Task<Ib43BedOutput> Assign(string side, long user)
    {
        Admin();
        return await _service.Assign(new() { ProductKey = "test", SerialNumber = "sim", Side = side, UserId = user, BedName = "测试床" });
    }
    private Ib43Report Report(string fields) => new Ib43Parser().Parse(_device.PostTopic,
        "{\"method\":\"thing.property.post\",\"params\":{\"deviceName\":\"sim\"," + fields + "}}", _device, _clock.Now);

    [Fact]
    public async Task Stored_sides_are_isolated_and_survive_new_store_instance()
    {
        var left = await Assign("left", 1); var right = await Assign("right", 2);
        await _repository.Save("a", _device, Report("\"HR\":[72,16,0,80,18,1]"));
        User(1);
        var current = await _service.Current(left.Id);
        Assert.Equal(72d, current.Readings["heartRate"].Value);
        Assert.Equal("unknown", current.Readings["presence"].Freshness);
        Assert.Single(await _service.Bindings());
        await ExpectRejection(() => _service.Current(right.Id));
        await ExpectRejection(() => _service.History(right.Id, 0, 2000000));
        _db.Ado.Close();
        using var reopened = new SqlSugarClient(new ConnectionConfig { ConnectionString = "DataSource=" + _databasePath,
            DbType = DbType.Sqlite, IsAutoCloseConnection = true, InitKeyType = InitKeyType.Attribute });
        var freshRepository = new Ib43DataRepository(reopened);
        Assert.Equal(80d, (await freshRepository.Latest(2, right.Id))["heartRate"].Value);
        var rows = await _db.Queryable<HealthIb43Observation>().Where(o => o.UserId == 1).ToListAsync();
        Assert.DoesNotContain("right", rows[0].ReadingsJson);
        Assert.DoesNotContain("80", rows[0].ReadingsJson);
    }

    [Fact]
    public async Task Partial_updates_and_zero_are_distinct_and_each_field_has_own_age()
    {
        var bed = await Assign("left", 1);
        await _repository.Save("a", _device, Report("\"SleepReportNew\":{\"ibNew\":[1,0,0,16,74,0,0,0,0,0,0,0]}"));
        _clock.Now += TimeSpan.FromSeconds(151);
        await _repository.Save("b", _device, Report("\"HR\":[0,0,0,80,18,0]"));
        User(1);
        var current = await _service.Current(bed.Id);
        Assert.Null(current.Readings["heartRate"].Value);
        Assert.Equal("recent", current.Readings["heartRate"].Freshness);
        Assert.Equal(1d, current.Readings["presence"].Value);
        Assert.Equal("stale", current.Readings["presence"].Freshness);
        Assert.Equal(2, (await _service.History(bed.Id, 0, 2000000)).Items.Count);
    }

    [Fact]
    public async Task Reassignment_does_not_transfer_previous_users_data_or_delayed_reports()
    {
        var oldBed = await Assign("left", 1);
        var pending = Report("\"HR\":[72,16,0,80,18,0]");
        _clock.Now += TimeSpan.FromSeconds(1);
        Admin(); await _service.Release(oldBed.Id);
        var newBed = await Assign("left", 3);
        await _repository.Save("delayed", _device, pending);
        User(3);
        Assert.Equal("unknown", (await _service.Current(newBed.Id)).Readings["heartRate"].Freshness);
        Assert.Empty((await _service.History(newBed.Id, 0, 2000000)).Items);
        await ExpectRejection(() => _service.Current(oldBed.Id));
        await _repository.Save("new", _device, Report("\"HR\":[90,20,0,0,0,0]"));
        Assert.Equal(90d, (await _service.Current(newBed.Id)).Readings["heartRate"].Value);
        User(1);
        Assert.Equal(72d, (await _service.Current(oldBed.Id)).Readings["heartRate"].Value);
        Assert.False((await _service.Current(oldBed.Id)).Active);
    }

    [Fact]
    public async Task Retries_are_idempotent_and_history_cursor_does_not_skip_same_timestamp()
    {
        var bed = await Assign("left", 1);
        var report = Report("\"HR\":[72,16,0,80,18,0]");
        await _repository.Save("a", _device, report);
        await _repository.Save("a", _device, report);
        await _repository.Save("b", _device, report);
        User(1);
        var page = await _service.History(bed.Id, 0, 2000000, take: 1);
        Assert.NotNull(page.NextBeforeId);
        var next = await _service.History(bed.Id, 0, 2000000, page.NextBeforeId, 1);
        Assert.Single(next.Items); Assert.Null(next.NextBeforeId);
        Assert.NotEqual(page.Items[0].Id, next.Items[0].Id);
        await ExpectRejection(() => _service.History(bed.Id, 0, 8L * 86400000));
        await ExpectRejection(() => _service.History(bed.Id, 0, 2000000, take: 201));
    }

    [Fact]
    public async Task Anonymous_disabled_and_health_users_cannot_provision_or_read_others()
    {
        await ExpectRejection(() => _service.Bindings());
        var bed = await Assign("left", 1);
        User(1);
        await ExpectRejection(() => _service.Assign(new() { ProductKey = "test", SerialNumber = "sim", Side = "right", UserId = 1, BedName = "test" }));
        await ExpectRejection(() => _service.Release(bed.Id));
        await _db.Updateable<HealthUser>().SetColumns(u => u.Status == HealthUserStatus.Disabled).Where(u => u.Id == 1).ExecuteCommandAsync();
        await ExpectRejection(() => _service.Bindings());
        await ExpectRejection(() => _service.Current(bed.Id));
    }

    [Fact]
    public async Task Duplicate_active_slot_is_rejected_and_unbound_invalid_reports_are_not_saved()
    {
        await _repository.Save("unbound", _device, Report("\"HR\":[72,16,0,80,18,0]"));
        Assert.Equal(0, await _db.Queryable<HealthIb43Observation>().CountAsync());
        await Assign("left", 1);
        await ExpectRejection(() => Assign("left", 2));
        await _repository.Save("bad", _device, Report("\"HR\":[72]"));
        Assert.Equal(0, await _db.Queryable<HealthIb43Observation>().CountAsync());
        await Assign("right", 2);
    }

    private static async Task ExpectRejection(Func<Task> action)
    {
        var error = await Assert.ThrowsAnyAsync<Exception>(action);
        Assert.Equal("Furion.FriendlyException.AppFriendlyException", error.GetType().FullName);
    }

    [Fact]
    public async Task Owner_controls_only_the_configured_bed_and_can_read_the_durable_execution_result()
    {
        var left = await Assign("left", 1);
        var right = await Assign("right", 2);
        await _automation.StartAsync(default);
        try
        {
            User(1);
            var state = await _service.AutomationStatus(left.Id);
            Assert.True(state.Available);
            Assert.False(state.Enabled);
            Assert.Equal(new[] { "curtain-close", PreviewAction }, state.Rules.Select(rule => rule.ActionKey));
            await _service.StartAutomation(left.Id);
            Assert.True((await _service.AutomationStatus(left.Id)).Enabled);
            await _service.StartAutomation(left.Id, PreviewAction);
            Assert.All((await _service.AutomationStatus(left.Id)).Rules, rule => Assert.True(rule.Enabled));
            await ExpectRejection(() => _service.StartAutomation(left.Id, "unknown"));
            await ExpectRejection(() => _service.StopAutomation(left.Id, "unknown"));

            var id = await _repository.BeginAutomation(left.Id, 1, "curtain-close", "测试窗帘", _clock.Now.ToUnixTimeMilliseconds(), default);
            Assert.NotNull(id);
            await _repository.CompleteAutomation(id!, "readback-confirmed", _clock.Now.ToUnixTimeMilliseconds());
            Assert.Equal("readback-confirmed", Assert.Single((await _service.AutomationStatus(left.Id)).Records).Result);

            User(2);
            await ExpectRejection(() => _service.AutomationStatus(left.Id));
            await ExpectRejection(() => _service.StartAutomation(left.Id));
            await ExpectRejection(() => _service.StopAutomation(left.Id));
            await ExpectRejection(() => _service.StartAutomation(left.Id, PreviewAction));
            await ExpectRejection(() => _service.StopAutomation(left.Id, PreviewAction));
            Assert.False((await _service.AutomationStatus(right.Id)).Available);
            await ExpectRejection(() => _service.StartAutomation(right.Id));
            Assert.True(_automation.IsEnabled(left.Id, 1));

            User(1);
            await _service.StopAutomation(left.Id);
            Assert.False((await _service.AutomationStatus(left.Id)).Enabled);
            Assert.True(_automation.IsEnabled(left.Id, 1, PreviewAction));
            await _service.StartAutomation(left.Id);
            Admin(); await _service.Release(left.Id);
            Assert.False(_automation.IsEnabled(left.Id, 1));
            Assert.False(_automation.IsEnabled(left.Id, 1, PreviewAction));
            Assert.Null(await _repository.BeginAutomation(left.Id, 1, "curtain-close", "测试窗帘", _clock.Now.ToUnixTimeMilliseconds(), default));
            User(1);
            state = await _service.AutomationStatus(left.Id);
            Assert.False(state.Available);
            Assert.Single(state.Records);
        }
        finally { await _automation.StopAsync(default); }
    }

    [Fact]
    public async Task Restarted_backend_services_leave_rules_stopped_and_return_the_same_saved_execution_history()
    {
        const string dehumidifier = "dehumidifier-humidity-start";
        var left = await Assign("left", 1);
        User(1);
        Ib43AutomationOutput before;
        using (var automation = CreateAutomation(_repository, dehumidifier))
        {
            await automation.StartAsync(default);
            try
            {
                var service = CreateService(_repository, automation);
                await service.StartAutomation(left.Id);
                await service.StartAutomation(left.Id, dehumidifier);
                foreach (var (action, target) in new[] { ("curtain-close", "测试窗帘"), (dehumidifier, "测试除湿机") })
                {
                    var now = _clock.GetUtcNow().ToUnixTimeMilliseconds();
                    var id = await _repository.BeginAutomation(left.Id, 1, action, target, now, default);
                    Assert.NotNull(id);
                    await _repository.CompleteAutomation(id!, "readback-confirmed", now);
                    _clock.Now = _clock.Now.AddSeconds(1);
                }
                before = await service.AutomationStatus(left.Id);
                Assert.Equal(2, before.Rules.Count);
                Assert.All(before.Rules, rule => Assert.True(rule.Enabled));
                Assert.Equal(2, before.Records.Count);
            }
            finally { await automation.StopAsync(default); }
        }

        _db.Ado.Close();
        using var reopened = new SqlSugarClient(new ConnectionConfig { ConnectionString = "DataSource=" + _databasePath,
            DbType = DbType.Sqlite, IsAutoCloseConnection = true, InitKeyType = InitKeyType.Attribute });
        var repository = new Ib43DataRepository(reopened);
        using var restarted = CreateAutomation(repository, dehumidifier);
        await restarted.StartAsync(default);
        try
        {
            var after = await CreateService(repository, restarted).AutomationStatus(left.Id);
            Assert.False(after.Enabled);
            Assert.Equal(before.Rules.Select(rule => rule with { Enabled = false }), after.Rules);
            Assert.Equal(before.Records.ToArray(), after.Records.ToArray());
        }
        finally { await restarted.StopAsync(default); }
    }

    private sealed class TestAction(string key, string target) : IBedPresenceAction
    {
        public string Key => key;
        public string Description => "测试";
        public bool SupportsTarget(string entityId) => entityId == target;
        public Task<string> ExecuteAsync(string entityId, CancellationToken token) => throw new InvalidOperationException("No real action in this test");
    }

    private sealed class TestExecutionLog(Ib43DataRepository repository) : IBedPresenceExecutionLog
    {
        public Task<string?> BeginAsync(string bindingId, long userId, string action, string target, DateTimeOffset triggeredAt, CancellationToken token)
            => repository.BeginAutomation(bindingId, userId, action, target, triggeredAt.ToUnixTimeMilliseconds(), token);
        public Task CompleteAsync(string id, string result, DateTimeOffset completedAt)
            => repository.CompleteAutomation(id, result, completedAt.ToUnixTimeMilliseconds());
    }

    [Fact]
    public async Task Local_maintenance_previews_then_binds_with_audit_and_is_idempotent()
    {
        _db.CodeFirst.InitTables<HealthIb43MaintenanceAudit>();
        var options = new Ib43Options { Devices = [new() { ProductKey = "evergreen-test", SerialNumber = "IB43SIM001", Simulation = true }] };
        var tool = new Ib43LocalBinding(_db, _clock);
        await tool.Run("1", options, "test-machine/test-operator", false);
        Assert.Equal(0, await _db.Queryable<HealthIb43Binding>().CountAsync());
        var first = await tool.Run("1", options, "test-machine/test-operator", true);
        var repeat = await tool.Run("1", options, "test-machine/test-operator", true);
        Assert.Equal(first.Id, repeat.Id);
        Assert.Equal(0, first.AssignedBy);
        Assert.Equal("left", first.Side);
        var audit = await _db.Queryable<HealthIb43MaintenanceAudit>().SingleAsync();
        Assert.Equal(first.Id, audit.BindingId);
        Assert.Equal("test-machine/test-operator", audit.Actor);
        await Assert.ThrowsAsync<InvalidOperationException>(() => tool.Run("2", options, "test", true));
        Assert.Single(await _db.Queryable<HealthIb43Binding>().ToListAsync());
        options.Devices[0].Simulation = false;
        await Assert.ThrowsAsync<InvalidOperationException>(() => tool.Run("1", options, "test", true));
    }

    [Fact]
    public async Task Local_maintenance_refuses_unknown_user_and_rolls_back_when_audit_fails()
    {
        var options = new Ib43Options { Devices = [new() { ProductKey = "evergreen-test", SerialNumber = "IB43SIM001", Simulation = true }] };
        var tool = new Ib43LocalBinding(_db, _clock);
        await Assert.ThrowsAsync<InvalidOperationException>(() => tool.Run("missing", options, "test", true));
        // 故意不建审计表，验证绑定不会单独提交。
        await Assert.ThrowsAsync<InvalidOperationException>(() => tool.Run("1", options, "test", true));
        Assert.Equal(0, await _db.Queryable<HealthIb43Binding>().CountAsync());
    }

    public void Dispose()
    {
        _automation.Dispose();
        _db.Dispose();
        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
        File.Delete(_databasePath);
    }
}