using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

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

/// <summary>
///     PCCC data types that map onto SLC / MicroLogix / PLC-5 files. Narrower than Logix — no
///     symbolic UDTs; every type is file-typed and fixed-width.
/// </summary>
public enum AbLegacyDataType
{
    /// <summary>B-file single bit (<c>B3:0/0</c>) or bit-within-N-file (<c>N7:0/3</c>).</summary>
    Bit,
    /// <summary>N-file integer (signed 16-bit).</summary>
    Int,
    /// <summary>L-file long integer — SLC 5/05+ only (signed 32-bit).</summary>
    Long,
    /// <summary>F-file float (32-bit IEEE-754).</summary>
    Float,
    /// <summary>A-file analog integer — some older hardware (signed 16-bit, semantically like N).</summary>
    AnalogInt,
    /// <summary>ST-file string (82-byte fixed-length + length word header).</summary>
    String,
    /// <summary>Timer sub-element — caller addresses <c>.ACC</c>, <c>.PRE</c>, <c>.EN</c>, <c>.DN</c>, <c>.TT</c>.</summary>
    TimerElement,
    /// <summary>Counter sub-element — caller addresses <c>.ACC</c>, <c>.PRE</c>, <c>.CU</c>, <c>.CD</c>, <c>.DN</c>.</summary>
    CounterElement,
    /// <summary>Control sub-element — caller addresses <c>.LEN</c>, <c>.POS</c>, <c>.EN</c>, <c>.DN</c>, <c>.ER</c>.</summary>
    ControlElement,
    /// <summary>
    ///     MicroLogix 1100/1400 function-file sub-element (RTC/HSC/DLS/MMI/PTO/PWM/STI/EII/IOS/BHI).
    ///     Sub-element catalogue lives in <see cref="AbLegacyFunctionFile.SubElementType"/>.
    /// </summary>
    MicroLogixFunctionFile,
}

/// <summary>
///     MicroLogix function-file sub-element catalogue. Covers the most-commonly-addressed members
///     per file — not exhaustive (Rockwell defines 30+ on RTC alone). Unknown sub-elements fall
///     back to <see cref="DriverDataType.Int32"/> at the <see cref="AbLegacyDataTypeExtensions"/>
///     boundary so the driver never refuses a tag the customer happens to know about.
/// </summary>
public static class AbLegacyFunctionFile
{
    /// <summary>
    ///     Driver-surface type for <paramref name="fileLetter"/>.<paramref name="subElement"/>.
    ///     Returns <see cref="DriverDataType.Int32"/> if the sub-element is unrecognised — keeps
    ///     the driver permissive without forcing every quirk into the catalogue.
    /// </summary>
    public static DriverDataType SubElementType(string fileLetter, string? subElement)
    {
        if (subElement is null) return DriverDataType.Int32;
        var key = (fileLetter.ToUpperInvariant(), subElement.ToUpperInvariant());
        return key switch
        {
            // Real-time clock — all stored as Int16 (year is 4-digit Int16).
            ("RTC", "HR") or ("RTC", "MIN") or ("RTC", "SEC") or
            ("RTC", "MON") or ("RTC", "DAY") or ("RTC", "YR") or ("RTC", "DOW") => DriverDataType.Int32,
            ("RTC", "DS") or ("RTC", "BL") or ("RTC", "EN") => DriverDataType.Boolean,

            // High-speed counter — accumulator/preset are Int32, status flags are bits.
            ("HSC", "ACC") or ("HSC", "PRE") or ("HSC", "OVF") or ("HSC", "UNF") => DriverDataType.Int32,
            ("HSC", "EN") or ("HSC", "UF") or ("HSC", "IF") or
            ("HSC", "IN") or ("HSC", "IH") or ("HSC", "IL") or
            ("HSC", "DN") or ("HSC", "CD") or ("HSC", "CU") => DriverDataType.Boolean,

            // Daylight saving + memory module info.
            ("DLS", "STR") or ("DLS", "STD") => DriverDataType.Int32,
            ("DLS", "EN") => DriverDataType.Boolean,
            ("MMI", "FT") or ("MMI", "LBN") => DriverDataType.Int32,
            ("MMI", "MP") or ("MMI", "MCP") => DriverDataType.Boolean,

            // Pulse-train / PWM output blocks.
            ("PTO", "ACC") or ("PTO", "OF") or ("PTO", "IDA") or ("PTO", "ODA") => DriverDataType.Int32,
            ("PTO", "EN") or ("PTO", "DN") or ("PTO", "EH") or ("PTO", "ED") or
            ("PTO", "RP") or ("PTO", "OUT") => DriverDataType.Boolean,
            ("PWM", "ACC") or ("PWM", "OF") or ("PWM", "PE") or ("PWM", "PD") => DriverDataType.Int32,
            ("PWM", "EN") or ("PWM", "DN") or ("PWM", "EH") or ("PWM", "ED") or
            ("PWM", "RP") or ("PWM", "OUT") => DriverDataType.Boolean,

            // Selectable timed interrupt + event input interrupt.
            ("STI", "SPM") or ("STI", "ER") or ("STI", "PFN") => DriverDataType.Int32,
            ("STI", "EN") or ("STI", "TIE") or ("STI", "DN") or
            ("STI", "PS") or ("STI", "ED") => DriverDataType.Boolean,
            ("EII", "PFN") or ("EII", "ER") => DriverDataType.Int32,
            ("EII", "EN") or ("EII", "TIE") or ("EII", "PE") or
            ("EII", "ES") or ("EII", "ED") => DriverDataType.Boolean,

            // I/O status + base hardware info — mostly status flags + a few counters.
            ("IOS", "ID") or ("IOS", "TYP") => DriverDataType.Int32,
            ("BHI", "OS") or ("BHI", "FRN") or ("BHI", "BSN") or ("BHI", "CC") => DriverDataType.Int32,

            _ => DriverDataType.Int32,
        };
    }
}

/// <summary>Map a PCCC data type to the driver-surface <see cref="DriverDataType"/>.</summary>
public static class AbLegacyDataTypeExtensions
{
    public static DriverDataType ToDriverDataType(this AbLegacyDataType t) => t switch
    {
        AbLegacyDataType.Bit => DriverDataType.Boolean,
        AbLegacyDataType.Int or AbLegacyDataType.AnalogInt => DriverDataType.Int32,
        AbLegacyDataType.Long => DriverDataType.Int32,       // matches Modbus/AbCip 64→32 gap
        AbLegacyDataType.Float => DriverDataType.Float32,
        AbLegacyDataType.String => DriverDataType.String,
        AbLegacyDataType.TimerElement or AbLegacyDataType.CounterElement
            or AbLegacyDataType.ControlElement => DriverDataType.Int32,
        AbLegacyDataType.MicroLogixFunctionFile => DriverDataType.Int32,
        _ => DriverDataType.Int32,
    };

    /// <summary>
    ///     Sub-element-aware driver type. Timer/Counter/Control elements expose Boolean status
    ///     bits (<c>.DN</c>, <c>.EN</c>, <c>.TT</c>, <c>.CU</c>, <c>.CD</c>, <c>.OV</c>,
    ///     <c>.UN</c>, <c>.ER</c>, etc.) and Int32 word members (<c>.PRE</c>, <c>.ACC</c>,
    ///     <c>.LEN</c>, <c>.POS</c>). Unknown sub-elements fall back to
    ///     <see cref="ToDriverDataType"/> so the driver remains permissive.
    /// </summary>
    public static DriverDataType EffectiveDriverDataType(AbLegacyDataType t, string? subElement)
    {
        if (subElement is null) return t.ToDriverDataType();
        var key = subElement.ToUpperInvariant();
        return t switch
        {
            AbLegacyDataType.TimerElement => key switch
            {
                "EN" or "TT" or "DN" => DriverDataType.Boolean,
                "PRE" or "ACC" => DriverDataType.Int32,
                _ => t.ToDriverDataType(),
            },
            AbLegacyDataType.CounterElement => key switch
            {
                "CU" or "CD" or "DN" or "OV" or "UN" => DriverDataType.Boolean,
                "PRE" or "ACC" => DriverDataType.Int32,
                _ => t.ToDriverDataType(),
            },
            AbLegacyDataType.ControlElement => key switch
            {
                "EN" or "EU" or "DN" or "EM" or "ER" or "UL" or "IN" or "FD" => DriverDataType.Boolean,
                "LEN" or "POS" => DriverDataType.Int32,
                _ => t.ToDriverDataType(),
            },
            _ => t.ToDriverDataType(),
        };
    }

    /// <summary>
    ///     Bit position within the parent control word for Timer/Counter/Control status bits.
    ///     Returns <c>null</c> if the sub-element is not a known bit member of the given element
    ///     type. Bit numbering follows Rockwell DTAM / PCCC documentation.
    /// </summary>
    public static int? StatusBitIndex(AbLegacyDataType t, string? subElement)
    {
        if (subElement is null) return null;
        var key = subElement.ToUpperInvariant();
        return t switch
        {
            // T4 element word 0: bit 13=DN, 14=TT, 15=EN.
            AbLegacyDataType.TimerElement => key switch
            {
                "DN" => 13,
                "TT" => 14,
                "EN" => 15,
                _ => null,
            },
            // C5 element word 0: bit 10=UN, 11=OV, 12=DN, 13=CD, 14=CU.
            AbLegacyDataType.CounterElement => key switch
            {
                "UN" => 10,
                "OV" => 11,
                "DN" => 12,
                "CD" => 13,
                "CU" => 14,
                _ => null,
            },
            // R6 element word 0: bit 8=FD, 9=IN, 10=UL, 11=ER, 12=EM, 13=DN, 14=EU, 15=EN.
            AbLegacyDataType.ControlElement => key switch
            {
                "FD" => 8,
                "IN" => 9,
                "UL" => 10,
                "ER" => 11,
                "EM" => 12,
                "DN" => 13,
                "EU" => 14,
                "EN" => 15,
                _ => null,
            },
            _ => null,
        };
    }

    /// <summary>
    ///     PLC-set status bits — read-only from the OPC UA side. Operator-controllable bits
    ///     (e.g. <c>.EN</c> on a timer/counter, <c>.CU</c>/<c>.CD</c> rung-driven inputs) are
    ///     omitted so they keep default writable behaviour.
    /// </summary>
    public static bool IsPlcSetStatusBit(AbLegacyDataType t, string? subElement)
    {
        if (subElement is null) return false;
        var key = subElement.ToUpperInvariant();
        return t switch
        {
            AbLegacyDataType.TimerElement => key is "DN" or "TT",
            AbLegacyDataType.CounterElement => key is "DN" or "OV" or "UN",
            AbLegacyDataType.ControlElement => key is "DN" or "EM" or "ER" or "FD" or "UL" or "IN",
            _ => false,
        };
    }
}