using System.Text.Json;
using System.Text.Json.Serialization;
using ZB.MOM.WW.OtOpcUa.Core.Hosting;
using S7NetCpuType = global::S7.Net.CpuType;

namespace ZB.MOM.WW.OtOpcUa.Driver.S7;

/// <summary>
///     Static factory registration helper for <see cref="S7Driver"/>. Server's Program.cs
///     calls <see cref="Register"/> once at startup; the bootstrapper (task #248) then
///     materialises S7 DriverInstance rows from the central config DB into live driver
///     instances. Mirrors <c>GalaxyProxyDriverFactoryExtensions</c>.
/// </summary>
public static class S7DriverFactoryExtensions
{
    public const string DriverTypeName = "S7";

    public static void Register(DriverFactoryRegistry registry)
    {
        ArgumentNullException.ThrowIfNull(registry);
        registry.Register(DriverTypeName, CreateInstance);
    }

    internal static S7Driver CreateInstance(string driverInstanceId, string driverConfigJson)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(driverInstanceId);
        ArgumentException.ThrowIfNullOrWhiteSpace(driverConfigJson);

        var dto = JsonSerializer.Deserialize<S7DriverConfigDto>(driverConfigJson, JsonOptions)
            ?? throw new InvalidOperationException(
                $"S7 driver config for '{driverInstanceId}' deserialised to null");

        if (string.IsNullOrWhiteSpace(dto.Host))
            throw new InvalidOperationException(
                $"S7 driver config for '{driverInstanceId}' missing required Host");

        // PR-S7-C3 — translate ScanGroupIntervalsMs (string -> int ms) into the runtime
        // string -> TimeSpan map. Skip any entry with a non-positive value rather than
        // throwing, so a config typo (e.g. 0 ms) degrades to "fall back to default
        // publishing interval" instead of breaking the whole driver init.
        IReadOnlyDictionary<string, TimeSpan>? scanGroupMap = null;
        if (dto.ScanGroupIntervalsMs is { Count: > 0 })
        {
            var built = new Dictionary<string, TimeSpan>(StringComparer.OrdinalIgnoreCase);
            foreach (var kvp in dto.ScanGroupIntervalsMs)
            {
                if (string.IsNullOrWhiteSpace(kvp.Key) || kvp.Value <= 0) continue;
                built[kvp.Key] = TimeSpan.FromMilliseconds(kvp.Value);
            }
            if (built.Count > 0) scanGroupMap = built;
        }

        var options = new S7DriverOptions
        {
            Host = dto.Host!,
            Port = dto.Port ?? 102,
            CpuType = ParseEnum<S7NetCpuType>(dto.CpuType, driverInstanceId, "CpuType",
                fallback: S7NetCpuType.S71500),
            Rack = dto.Rack ?? 0,
            Slot = dto.Slot ?? 0,
            Timeout = TimeSpan.FromMilliseconds(dto.TimeoutMs ?? 5_000),
            Tags = dto.Tags is { Count: > 0 }
                ? [.. dto.Tags.Select(t => BuildTag(t, driverInstanceId))]
                : [],
            Probe = new S7ProbeOptions
            {
                Enabled = dto.Probe?.Enabled ?? true,
                Interval = TimeSpan.FromMilliseconds(dto.Probe?.IntervalMs ?? 5_000),
                Timeout = TimeSpan.FromMilliseconds(dto.Probe?.TimeoutMs ?? 2_000),
                ProbeAddress = dto.Probe?.ProbeAddress ?? "MW0",
            },
            TsapMode = ParseEnum<TsapMode>(dto.TsapMode, driverInstanceId, "TsapMode",
                fallback: TsapMode.Auto),
            LocalTsap = dto.LocalTsap,
            RemoteTsap = dto.RemoteTsap,
            ScanGroupIntervals = scanGroupMap,
        };

        return new S7Driver(options, driverInstanceId);
    }

    private static S7TagDefinition BuildTag(S7TagDto t, string driverInstanceId) =>
        new(
            Name: t.Name ?? throw new InvalidOperationException(
                $"S7 config for '{driverInstanceId}' has a tag missing Name"),
            Address: t.Address ?? throw new InvalidOperationException(
                $"S7 tag '{t.Name}' in '{driverInstanceId}' missing Address"),
            DataType: ParseEnum<S7DataType>(t.DataType, driverInstanceId, "DataType",
                tagName: t.Name),
            Writable: t.Writable ?? true,
            StringLength: t.StringLength ?? 254,
            WriteIdempotent: t.WriteIdempotent ?? false,
            ScanGroup: string.IsNullOrWhiteSpace(t.ScanGroup) ? null : t.ScanGroup);

    private static T ParseEnum<T>(string? raw, string driverInstanceId, string field,
        string? tagName = null, T? fallback = null) where T : struct, Enum
    {
        if (string.IsNullOrWhiteSpace(raw))
        {
            if (fallback.HasValue) return fallback.Value;
            throw new InvalidOperationException(
                $"S7 tag '{tagName ?? "<unnamed>"}' in '{driverInstanceId}' missing {field}");
        }
        return Enum.TryParse<T>(raw, ignoreCase: true, out var v)
            ? v
            : throw new InvalidOperationException(
                $"S7 {(tagName is null ? "config" : $"tag '{tagName}'")} has unknown {field} '{raw}'. " +
                $"Expected one of {string.Join(", ", Enum.GetNames<T>())}");
    }

    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNameCaseInsensitive = true,
        ReadCommentHandling = JsonCommentHandling.Skip,
        AllowTrailingCommas = true,
    };

    internal sealed class S7DriverConfigDto
    {
        public string? Host { get; init; }
        public int? Port { get; init; }
        public string? CpuType { get; init; }
        public short? Rack { get; init; }
        public short? Slot { get; init; }
        public int? TimeoutMs { get; init; }
        public List<S7TagDto>? Tags { get; init; }
        public S7ProbeDto? Probe { get; init; }

        /// <summary>
        ///     Optional connection-class selector — one of <c>Auto</c> (default),
        ///     <c>Pg</c>, <c>Op</c>, <c>S7Basic</c>, <c>Other</c>. When omitted the driver
        ///     keeps the existing <c>Auto</c> behaviour (S7netplus picks the TSAP pair
        ///     from <see cref="CpuType"/>). See <c>docs/v2/s7.md</c> "TSAP / Connection
        ///     Type" section.
        /// </summary>
        public string? TsapMode { get; init; }

        /// <summary>Optional 16-bit local TSAP override. Required (with <see cref="RemoteTsap"/>) when <c>TsapMode = Other</c>.</summary>
        public ushort? LocalTsap { get; init; }

        /// <summary>Optional 16-bit remote TSAP override. Required (with <see cref="LocalTsap"/>) when <c>TsapMode = Other</c>.</summary>
        public ushort? RemoteTsap { get; init; }

        /// <summary>
        ///     PR-S7-C3 — optional scan-group → publishing-interval (ms) map. Tags carrying
        ///     a matching <see cref="S7TagDto.ScanGroup"/> string poll at the configured
        ///     rate; tags with no group, or with a group not present here, fall back to
        ///     the subscription default. Group names are matched case-insensitively. See
        ///     <c>docs/v2/s7.md</c> "Per-tag scan groups" section.
        /// </summary>
        public Dictionary<string, int>? ScanGroupIntervalsMs { get; init; }
    }

    internal sealed class S7TagDto
    {
        public string? Name { get; init; }
        public string? Address { get; init; }
        public string? DataType { get; init; }
        public bool? Writable { get; init; }
        public int? StringLength { get; init; }
        public bool? WriteIdempotent { get; init; }

        /// <summary>
        ///     PR-S7-C3 — optional scan-group identifier. Resolved against
        ///     <see cref="S7DriverConfigDto.ScanGroupIntervalsMs"/> at subscribe time.
        ///     Null / empty = no group (legacy behaviour, falls back to subscription
        ///     default publishing interval).
        /// </summary>
        public string? ScanGroup { get; init; }
    }

    internal sealed class S7ProbeDto
    {
        public bool? Enabled { get; init; }
        public int? IntervalMs { get; init; }
        public int? TimeoutMs { get; init; }
        public string? ProbeAddress { get; init; }
    }
}