using Microsoft.Data.SqlClient;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.SqlServer;

/// <summary>Status codes owned by the updater (named consts so <c>StatusCodeParityTests</c> sees them).</summary>
internal static class SqlHistorianUpdateStatusCodes
{
    /// <summary>
    ///     A value that cannot be stored: a Double NaN / ±Infinity, an Empty (null) value with a non-Bad status, or a
    ///     tag name longer than <see cref="SqlServerTagCatalog.MaxNameLength"/>.
    /// </summary>
    public const uint BadInvalidArgument = 0x80AB0000u;
}

/// <summary>
///     OPC UA HistoryUpdate against the SQL Server sample table (spec §4 "Updates"). One transaction per call;
///     exactly one status per input item, in input order.
///     <para><b>Duplicate timestamps within one request</b> (compared at full 100 ns tick precision):
///     Insert — the first occurrence is applied, later ones are <c>BadEntryExists</c>; Replace/Update — last wins,
///     and every earlier occurrence of that timestamp reports the same code as the winning one.
///     DeleteAtTime — the first occurrence reports the real outcome, later ones <c>BadNoEntryExists</c>.</para>
///     <para><b>Invalid items.</b> A null or <see cref="DateTime.MinValue"/> timestamp is
///     <c>BadInvalidTimestamp</c>. A Double NaN/±Infinity cannot live in the SQL <c>float</c> column and is
///     rejected with <c>BadInvalidArgument</c> (not silently stored as Empty). An Empty (null) value is only
///     accepted with a Bad status (an operator-authored outage marker); with a Good or Uncertain status it is
///     <c>BadInvalidArgument</c>, because a stored sample is never served better than "no value". Other items
///     still proceed.</para>
///     <para><b>Tag names over <see cref="SqlServerTagCatalog.MaxNameLength"/> characters</b> are refused, never
///     truncated: every item of the call (and DeleteRaw's single result) reports <c>BadInvalidArgument</c> and nothing
///     is written.</para>
///     <para><b>Unknown tag.</b> Insert/Update create it via <see cref="SqlServerTagCatalog"/>; Replace and the
///     deletes report <c>BadNoEntryExists</c> (DeleteRaw: <c>BadNoData</c>) without creating anything.</para>
/// </summary>
internal sealed class SqlServerHistorianDataUpdater : IHistorianDataUpdater
{
    private readonly SqlHistorianConnection _conn;
    private readonly SqlServerTagCatalog _tags;

    /// <summary>Creates the updater.</summary>
    /// <param name="conn">Connection helper.</param>
    /// <param name="tags">Tag catalog (runs the schema bootstrap itself).</param>
    public SqlServerHistorianDataUpdater(SqlHistorianConnection conn, SqlServerTagCatalog tags)
    {
        _conn = conn;
        _tags = tags;
    }

    /// <inheritdoc/>
    public async Task<IReadOnlyList<uint>> UpdateDataAsync(string tag, HistoryUpdateMode mode,
        IReadOnlyList<HistorizationValue> values, CancellationToken ct)
    {
        ArgumentNullException.ThrowIfNull(tag);
        ArgumentNullException.ThrowIfNull(values);
        var results = new uint[values.Count];
        if (!SqlServerTagCatalog.IsValidName(tag))
        {
            Array.Fill(results, SqlHistorianUpdateStatusCodes.BadInvalidArgument);
            return results;
        }
        var winner = new Dictionary<long, int>(); // tick -> index of the item actually sent
        for (var i = 0; i < values.Count; i++)
        {
            var v = values[i];
            if (v.TimestampUtc is not { } ts || ts == DateTime.MinValue)
            {
                results[i] = SqlHistorianStatusCodes.BadInvalidTimestamp;
                continue;
            }
            if ((v.Value.Kind == HistorianValueKind.Double && !double.IsFinite(v.Value.Number))
                || (v.Value.Kind == HistorianValueKind.Empty && !StatusBits.IsBad(v.StatusCode)))
            {
                results[i] = SqlHistorianUpdateStatusCodes.BadInvalidArgument;
                continue;
            }
            if (!winner.TryGetValue(ts.Ticks, out _))
                winner[ts.Ticks] = i;
            else if (mode == HistoryUpdateMode.Insert)
                results[i] = SqlHistorianStatusCodes.BadEntryExists;   // first occurrence stays the winner
            else
                winner[ts.Ticks] = i;                                  // last wins
        }

        var send = winner.Values.OrderBy(i => i).ToList();
        if (send.Count == 0) return results;

        var tagId = mode == HistoryUpdateMode.Replace
            ? await _tags.TryGetTagIdAsync(tag, ct).ConfigureAwait(false)
            : await _tags.GetOrCreateTagIdAsync(tag, SqlHistorianDataTypes.FromKind(values[send[0]].Value.Kind), ct).ConfigureAwait(false);

        var outcome = tagId is null
            ? new Dictionary<long, uint>()
            : await MergeAsync(tagId.Value, mode, send.Select(i => new SqlSampleRow(
                values[i].TimestampUtc!.Value, values[i].Value, values[i].StatusCode)).ToList(), ct).ConfigureAwait(false);

        // No OUTPUT row means the MERGE's absent branch: Insert => matched (exists); Replace => not matched.
        var absent = mode == HistoryUpdateMode.Replace
            ? SqlHistorianStatusCodes.BadNoEntryExists
            : SqlHistorianStatusCodes.BadEntryExists;
        foreach (var i in send)
            results[i] = outcome.TryGetValue(values[i].TimestampUtc!.Value.Ticks, out var code) ? code : absent;

        // Superseded earlier duplicates (Replace/Update) share the winner's code.
        if (mode != HistoryUpdateMode.Insert)
            for (var i = 0; i < values.Count; i++)
                if (values[i].TimestampUtc is { } ts && results[i] == 0
                    && winner.TryGetValue(ts.Ticks, out var w) && w != i)
                    results[i] = results[w];
        return results;
    }

    /// <inheritdoc/>
    public async Task<uint> DeleteRawAsync(string tag, DateTime startUtc, DateTime endUtc, CancellationToken ct)
    {
        ArgumentNullException.ThrowIfNull(tag);
        if (!SqlServerTagCatalog.IsValidName(tag)) return SqlHistorianUpdateStatusCodes.BadInvalidArgument;
        var tagId = await _tags.TryGetTagIdAsync(tag, ct).ConfigureAwait(false);
        if (tagId is null) return SqlHistorianStatusCodes.BadNoData;
        await using var conn = await _conn.OpenAsync(ct).ConfigureAwait(false);
        await using var tx = (SqlTransaction)await conn.BeginTransactionAsync(ct).ConfigureAwait(false);
        int rows;
        await using (var cmd = _conn.CreateCommand(conn,
                         $"DELETE FROM {_conn.Q("Sample")} WHERE TagId = @tagId AND SourceTimeUtc >= @s AND SourceTimeUtc < @e", tx))
        {
            cmd.Parameters.Add(new SqlParameter("@tagId", System.Data.SqlDbType.Int) { Value = tagId.Value });
            SqlHistorianConnection.AddDateTime2(cmd, "@s", startUtc);
            SqlHistorianConnection.AddDateTime2(cmd, "@e", endUtc);
            rows = await cmd.ExecuteNonQueryAsync(ct).ConfigureAwait(false);
        }
        await tx.CommitAsync(ct).ConfigureAwait(false);
        return rows > 0 ? SqlHistorianStatusCodes.Good : SqlHistorianStatusCodes.BadNoData;
    }

    /// <inheritdoc/>
    public async Task<IReadOnlyList<uint>> DeleteAtTimeAsync(string tag, IReadOnlyList<DateTime> timesUtc, CancellationToken ct)
    {
        ArgumentNullException.ThrowIfNull(tag);
        ArgumentNullException.ThrowIfNull(timesUtc);
        var results = new uint[timesUtc.Count];
        if (!SqlServerTagCatalog.IsValidName(tag))
        {
            Array.Fill(results, SqlHistorianUpdateStatusCodes.BadInvalidArgument);
            return results;
        }
        var first = new Dictionary<long, int>();
        for (var i = 0; i < timesUtc.Count; i++)
        {
            results[i] = SqlHistorianStatusCodes.BadNoEntryExists;
            if (timesUtc[i] == DateTime.MinValue) results[i] = SqlHistorianStatusCodes.BadInvalidTimestamp;
            else first.TryAdd(timesUtc[i].Ticks, i);
        }
        if (first.Count == 0) return results;
        var tagId = await _tags.TryGetTagIdAsync(tag, ct).ConfigureAwait(false);
        if (tagId is null) return results;

        await using var conn = await _conn.OpenAsync(ct).ConfigureAwait(false);
        await using var tx = (SqlTransaction)await conn.BeginTransactionAsync(ct).ConfigureAwait(false);
        await using (var cmd = _conn.CreateCommand(conn,
                         $"DELETE s OUTPUT deleted.SourceTimeUtc FROM {_conn.Q("Sample")} AS s JOIN @times AS t ON s.SourceTimeUtc = t.T WHERE s.TagId = @tagId", tx))
        {
            cmd.Parameters.Add(new SqlParameter("@tagId", System.Data.SqlDbType.Int) { Value = tagId.Value });
            _conn.AddStructured(cmd, "@times", "TimeRow",
                SampleRowMapper.ToTimeRecords(first.Keys.Select(t => new DateTime(t, DateTimeKind.Utc))));
            await using var rd = await cmd.ExecuteReaderAsync(ct).ConfigureAwait(false);
            while (await rd.ReadAsync(ct).ConfigureAwait(false))
                if (first.TryGetValue(SqlHistorianConnection.GetUtc(rd, 0).Ticks, out var idx))
                    results[idx] = SqlHistorianStatusCodes.Good;
        }
        await tx.CommitAsync(ct).ConfigureAwait(false);
        return results;
    }

    private async Task<Dictionary<long, uint>> MergeAsync(int tagId, HistoryUpdateMode mode,
        List<SqlSampleRow> rows, CancellationToken ct)
    {
        var sql = $"MERGE {_conn.Q("Sample")} WITH (HOLDLOCK) AS t USING @rows AS r ON t.TagId = @tagId AND t.SourceTimeUtc = r.SourceTimeUtc ";
        if (mode != HistoryUpdateMode.Insert)
            sql += "WHEN MATCHED THEN UPDATE SET ValueKind = r.ValueKind, NumValue = r.NumValue, IntValue = r.IntValue, " +
                   "StrValue = r.StrValue, StatusCode = r.StatusCode, ServerTimeUtc = SYSUTCDATETIME() ";
        if (mode != HistoryUpdateMode.Replace)
            sql += "WHEN NOT MATCHED THEN INSERT (TagId, SourceTimeUtc, ValueKind, NumValue, IntValue, StrValue, StatusCode, ServerTimeUtc) " +
                   "VALUES (@tagId, r.SourceTimeUtc, r.ValueKind, r.NumValue, r.IntValue, r.StrValue, r.StatusCode, SYSUTCDATETIME()) ";
        sql += "OUTPUT $action, r.SourceTimeUtc;";

        var outcome = new Dictionary<long, uint>();
        await using var conn = await _conn.OpenAsync(ct).ConfigureAwait(false);
        await using var tx = (SqlTransaction)await conn.BeginTransactionAsync(ct).ConfigureAwait(false);
        await using (var cmd = _conn.CreateCommand(conn, sql, tx))
        {
            cmd.Parameters.Add(new SqlParameter("@tagId", System.Data.SqlDbType.Int) { Value = tagId });
            _conn.AddStructured(cmd, "@rows", "SampleRow", SampleRowMapper.ToSampleRecords(rows));
            await using var rd = await cmd.ExecuteReaderAsync(ct).ConfigureAwait(false);
            while (await rd.ReadAsync(ct).ConfigureAwait(false))
                outcome[SqlHistorianConnection.GetUtc(rd, 1).Ticks] = rd.GetString(0) == "INSERT"
                    ? SqlHistorianStatusCodes.GoodEntryInserted
                    : SqlHistorianStatusCodes.GoodEntryReplaced;
        }
        await tx.CommitAsync(ct).ConfigureAwait(false);
        return outcome;
    }
}