using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System.Threading.Channels;

namespace Evergreen.Health.Application.Health.Sleep;

public enum BedSide { Left, Right }
public enum BedAutomationMode { Disabled, Preview, Execute, Managed }

public sealed record BedPresenceSample(string BindingId, string ProductKey, string SerialNumber, BedSide Side,
    bool Simulation, BedPresence Presence, DateTimeOffset ReceivedAt, Guid ConnectionId);

public interface IBedPresenceSink
{
    void Observe(BedPresenceSample sample, CancellationToken connectionToken);
}

public interface IBedPresenceAction
{
    string Key { get; }
    string Description { get; }
    bool PreviewOnly => false;
    string? ConditionLabel => null;
    TimeSpan ExecutionTimeout => TimeSpan.FromSeconds(25);
    bool SupportsTarget(string entityId);
    Task<string> ExecuteAsync(string entityId, CancellationToken token);
}

public sealed class BedPresenceAutomationOptions : BedPresenceRuleOptions
{
    public List<BedPresenceRuleOptions> AdditionalRules { get; set; } = [];
}

public class BedPresenceRuleOptions
{
    public BedAutomationMode Mode { get; set; }
    public string BindingId { get; set; } = "";
    public string ProductKey { get; set; } = "evergreen-test";
    public string SerialNumber { get; set; } = "IB43SIM001";
    public BedSide Side { get; set; } = BedSide.Left;
    public string ActionKey { get; set; } = "";
    public string TargetEntityId { get; set; } = "";
    public string TargetLabel { get; set; } = "";

    public bool IsValid()
    {
        if (Mode == BedAutomationMode.Disabled) return true;
        var bindingValid = Mode switch
        {
            BedAutomationMode.Managed => string.IsNullOrEmpty(BindingId) || Guid.TryParseExact(BindingId, "N", out _),
            BedAutomationMode.Preview => Guid.TryParseExact(BindingId, "N", out _),
            _ => false
        };
        return bindingValid && !string.IsNullOrWhiteSpace(ProductKey) && !string.IsNullOrWhiteSpace(SerialNumber) &&
            Enum.IsDefined(Side) && !string.IsNullOrWhiteSpace(ActionKey) && ActionKey.Length <= 64 &&
            !string.IsNullOrWhiteSpace(TargetEntityId) && TargetEntityId.Length <= 128 && (TargetLabel?.Length ?? 0) <= 128;
    }

    public bool Matches(BedPresenceSample sample) => MatchesSource(sample.BindingId, sample.ProductKey, sample.SerialNumber, sample.Side, sample.Simulation);

    public bool Matches(BedAutomationBinding binding) => MatchesSource(binding.Id, binding.ProductKey, binding.SerialNumber, binding.Side, binding.Simulation);

    private bool MatchesSource(string id, string productKey, string serialNumber, BedSide side, bool simulation) =>
        simulation && (id == BindingId || Mode == BedAutomationMode.Managed && string.IsNullOrEmpty(BindingId)) &&
        productKey == ProductKey && serialNumber == SerialNumber && side == Side;
}

/// <summary>按连接识别连续的离床到在床，首条、重复和超时事件只建立基线。</summary>
public sealed class BedPresenceEdge
{
    public static readonly TimeSpan MaxAge = TimeSpan.FromSeconds(60);
    private BedPresenceSample? _previous;

    public bool Observe(BedPresenceSample sample, DateTimeOffset now)
    {
        if (sample.Presence is not (BedPresence.Empty or BedPresence.Occupied) ||
            sample.ReceivedAt > now || now - sample.ReceivedAt > MaxAge) return false;
        var previous = _previous;
        var sameBedConnection = previous != null && previous.ConnectionId == sample.ConnectionId &&
            previous.BindingId == sample.BindingId && previous.Side == sample.Side;
        if (sameBedConnection && sample.ReceivedAt < previous!.ReceivedAt) return false;
        _previous = sample;
        return sameBedConnection && previous!.Presence == BedPresence.Empty &&
            sample.Presence == BedPresence.Occupied && sample.ReceivedAt - previous.ReceivedAt <= MaxAge;
    }

    public void Reset() => _previous = null;
}

public sealed class BedPresenceAutomation(IOptions<BedPresenceAutomationOptions> options, IEnumerable<IBedPresenceAction> actions,
    TimeProvider clock, ILogger<BedPresenceAutomation> logger, IBedPresenceExecutionLog? executionLog = null) : BackgroundService, IBedPresenceSink
{
    private readonly BedPresenceRule[] _rules = CreateRules(options.Value, actions, clock, logger, executionLog);

    public BedPresenceRuleStatus? PrimaryRuleStatus(BedAutomationBinding binding) => _rules[0].Status(binding);

    public BedPresenceRuleStatus[] RuleStatuses(BedAutomationBinding binding) =>
        _rules.Select(rule => rule.Status(binding)).OfType<BedPresenceRuleStatus>().ToArray();

    public bool IsEnabled(string bindingId, long userId, string? actionKey = null) =>
        FindRule(actionKey)?.IsEnabled(bindingId, userId) == true;

    public bool TryEnable(BedAutomationBinding binding, string? actionKey = null) =>
        FindRule(actionKey)?.TryEnable(binding) == true;

    public bool Disable(string bindingId, long userId, string? actionKey = null)
    {
        var rule = FindRule(actionKey);
        if (rule is null) return false;
        rule.Disable(bindingId, userId);
        return true;
    }

    public void RevokeBinding(string bindingId)
    {
        foreach (var rule in _rules) rule.RevokeBinding(bindingId);
    }

    public void Observe(BedPresenceSample sample, CancellationToken connectionToken)
    {
        foreach (var rule in _rules) rule.Observe(sample, connectionToken);
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken) =>
        Task.WhenAll(_rules.Select(rule => rule.RunAsync(stoppingToken)));

    public override Task StopAsync(CancellationToken cancellationToken)
    {
        foreach (var rule in _rules) rule.Stop();
        return base.StopAsync(cancellationToken);
    }

    private BedPresenceRule? FindRule(string? actionKey) => actionKey is null
        ? _rules[0] : _rules.FirstOrDefault(rule => rule.ActionKey == actionKey);

    private static BedPresenceRule[] CreateRules(BedPresenceAutomationOptions configuration,
        IEnumerable<IBedPresenceAction> actions, TimeProvider clock, ILogger<BedPresenceAutomation> logger,
        IBedPresenceExecutionLog? executionLog)
    {
        var registeredActions = actions.ToArray();
        var rules = new List<BedPresenceRule> { new(configuration, registeredActions, clock, logger, executionLog) };
        if (configuration.Mode != BedAutomationMode.Managed) return rules.ToArray();

        var keys = new HashSet<string>(StringComparer.Ordinal) { configuration.ActionKey };
        foreach (var rule in configuration.AdditionalRules)
        {
            if (rule.Mode != BedAutomationMode.Managed) continue;
            if (!keys.Add(rule.ActionKey))
            {
                logger.LogWarning("Bed presence automation ignored duplicate action key {Action}", rule.ActionKey);
                continue;
            }
            rules.Add(new(rule, registeredActions, clock, logger, executionLog));
        }
        return rules.ToArray();
    }
}

public sealed record BedPresenceRuleStatus(string ActionKey, string ActionLabel, string TargetLabel, bool Enabled,
    bool PreviewOnly, string? ConditionLabel);

/// <summary>每条规则独立处理上床事件，慢速设备回读不会阻塞其他规则。</summary>
internal sealed class BedPresenceRule(BedPresenceRuleOptions configuration, IReadOnlyList<IBedPresenceAction> actions,
    TimeProvider clock, ILogger<BedPresenceAutomation> logger, IBedPresenceExecutionLog? executionLog)
{
    private sealed class Session(string bindingId, long userId, DateTimeOffset startedAt)
    {
        private readonly CancellationTokenSource _stop = new();
        public string BindingId { get; } = bindingId;
        public long UserId { get; } = userId;
        public DateTimeOffset StartedAt { get; } = startedAt;
        public CancellationToken Token => _stop.Token;
        public void Cancel() => _stop.Cancel();
    }

    private sealed record Item(long Sequence, BedPresenceSample Sample, CancellationToken ConnectionToken, Session? Session);
    private readonly Channel<Item> _queue = Channel.CreateBounded<Item>(new BoundedChannelOptions(32)
    { SingleReader = true, FullMode = BoundedChannelFullMode.Wait });
    private long _sequence;
    private volatile IBedPresenceAction? _activeAction;
    private readonly object _sessionGate = new();
    private volatile Session? _session;

    public string ActionKey => configuration.ActionKey;
    private string TargetLabel => string.IsNullOrWhiteSpace(configuration.TargetLabel) ? configuration.TargetEntityId : configuration.TargetLabel;

    public BedPresenceRuleStatus? Status(BedAutomationBinding binding) =>
        _activeAction is { } action && configuration.Mode == BedAutomationMode.Managed && configuration.Matches(binding)
            ? new(action.Key, action.Description, TargetLabel, IsEnabled(binding.Id, binding.UserId), action.PreviewOnly, action.ConditionLabel)
            : null;

    public bool IsEnabled(string bindingId, long userId) => _session is { } session && session.BindingId == bindingId && session.UserId == userId;

    public bool TryEnable(BedAutomationBinding binding)
    {
        Session? previous;
        lock (_sessionGate)
        {
            if (_activeAction is null || configuration.Mode != BedAutomationMode.Managed || !configuration.Matches(binding)) return false;
            if (IsEnabled(binding.Id, binding.UserId)) return true;
            previous = _session;
            _session = new(binding.Id, binding.UserId, clock.GetUtcNow());
        }
        previous?.Cancel();
        return true;
    }

    public void Disable(string bindingId, long userId)
    {
        Session? previous;
        lock (_sessionGate)
        {
            if (!IsEnabled(bindingId, userId)) return;
            previous = _session;
            _session = null;
        }
        previous?.Cancel();
    }

    public void RevokeBinding(string bindingId)
    {
        if (_session is { } session && session.BindingId == bindingId) Disable(bindingId, session.UserId);
    }

    public void Observe(BedPresenceSample sample, CancellationToken connectionToken)
    {
        if (_activeAction is null || !configuration.Matches(sample) || connectionToken.IsCancellationRequested) return;
        var session = _session;
        if (configuration.Mode == BedAutomationMode.Managed &&
            (session is null || session.BindingId != sample.BindingId || sample.ReceivedAt < session.StartedAt)) return;
        if (!_queue.Writer.TryWrite(new(Interlocked.Increment(ref _sequence), sample, connectionToken, session)))
            logger.LogWarning("Bed presence automation queue full; observation dropped for {Action}", ActionKey);
    }

    public async Task RunAsync(CancellationToken stoppingToken)
    {
        if (configuration.Mode == BedAutomationMode.Disabled) return;
        if (configuration.Mode == BedAutomationMode.Execute)
        {
            logger.LogWarning("Legacy Execute mode is disabled; use Managed and enable the rule in H5");
            return;
        }
        var candidates = actions.Where(action => string.Equals(action.Key, configuration.ActionKey, StringComparison.Ordinal)).Take(2).ToArray();
        if (!configuration.IsValid() || candidates.Length != 1 || !candidates[0].SupportsTarget(configuration.TargetEntityId) ||
            configuration.Mode == BedAutomationMode.Managed && executionLog is null)
        {
            logger.LogWarning("Bed presence automation inactive: invalid binding, action or target for {Action}", ActionKey);
            return;
        }
        var action = candidates[0];
        var target = configuration.TargetEntityId;
        _activeAction = action;
        logger.LogInformation("Bed presence automation ready: Mode={Mode}, Side={Side}, Action={Action}, Target={EntityId}",
            configuration.Mode, configuration.Side, action.Key, target);
        var edge = new BedPresenceEdge();
        Session? lastSession = null;
        long lastSequence = 0;
        await foreach (var item in _queue.Reader.ReadAllAsync(stoppingToken))
        {
            if (item.Sequence != lastSequence + 1 || item.ConnectionToken.IsCancellationRequested || item.Session != lastSession) edge.Reset();
            lastSequence = item.Sequence;
            lastSession = item.Session;
            if (configuration.Mode == BedAutomationMode.Managed && (item.Session is null || item.Session != _session)) continue;
            if (item.ConnectionToken.IsCancellationRequested || !edge.Observe(item.Sample, clock.GetUtcNow())) continue;
            if (configuration.Mode == BedAutomationMode.Preview)
            {
                logger.LogInformation("Bed presence preview: empty -> occupied, Action={Action}, Plan={Plan}, Target={EntityId}",
                    action.Key, action.Description, target);
                continue;
            }
            if (clock.GetUtcNow() - item.Sample.ReceivedAt > TimeSpan.FromSeconds(10))
            {
                logger.LogInformation("Bed presence action skipped: observation aged in queue");
                continue;
            }
            await ExecuteManagedAction(item, action, target, stoppingToken);
        }
    }

    private async Task ExecuteManagedAction(Item item, IBedPresenceAction action, string target, CancellationToken stoppingToken)
    {
        var session = item.Session!;
        using var timeout = new CancellationTokenSource(action.ExecutionTimeout, clock);
        using var operation = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken, item.ConnectionToken, session.Token, timeout.Token);
        string? id = null;
        var result = "failed-unconfirmed";
        try
        {
            operation.Token.ThrowIfCancellationRequested();
            id = await executionLog!.BeginAsync(session.BindingId, session.UserId, action.Key, TargetLabel, item.Sample.ReceivedAt, operation.Token);
            if (id is null) return;
            operation.Token.ThrowIfCancellationRequested();
            if (session != _session) throw new OperationCanceledException();
            if (clock.GetUtcNow() - item.Sample.ReceivedAt > TimeSpan.FromSeconds(10))
            {
                result = "expired";
                return;
            }
            result = await action.ExecuteAsync(target, operation.Token);
            logger.LogInformation("Bed presence action: Action={Action}, Target={EntityId}, Result={Result}", action.Key, target, result);
        }
        catch (OperationCanceledException)
        {
            result = "cancelled-unconfirmed";
            logger.LogWarning("Bed presence action not confirmed: cancelled or timed out for {EntityId}", target);
        }
        catch (Exception error)
        {
            logger.LogWarning("Bed presence action not confirmed: Target={EntityId}, Error={Type}", target, error.GetType().Name);
        }
        finally
        {
            if (id is not null)
            {
                try { await executionLog!.CompleteAsync(id, result, clock.GetUtcNow()); }
                catch (Exception error) { logger.LogWarning("Bed presence execution result could not be saved ({Type})", error.GetType().Name); }
            }
        }
    }

    public void Stop()
    {
        Session? previous;
        lock (_sessionGate)
        {
            _activeAction = null;
            previous = _session;
            _session = null;
        }
        previous?.Cancel();
    }
}