using System.Globalization;

using System.Runtime.CompilerServices;

using NpgsqlTypes;

namespace NpgsqlRest;

/// <summary>

/// Pre-computed delegate array for type-specific parameter parsing.

/// Replaces sequential if-chain with O(1) delegate lookup.

/// </summary>

public static class ParameterParsers

{

/// <summary>

/// Delegate signature for type-specific parsing.

/// </summary>

/// <param name="value">The string value to parse</param>

/// <param name="result">The parsed result if successful</param>

/// <returns>True if parsing succeeded, false otherwise</returns>

public delegate bool TryParseDelegate(string? value, out object? result);

private static readonly TryParseDelegate?[] _parsers;

static ParameterParsers()

{

_parsers = new TryParseDelegate?[128];

// Numeric types

_parsers[(int)NpgsqlDbType.Smallint] = TryParseSmallint;

_parsers[(int)NpgsqlDbType.Integer] = TryParseInteger;

_parsers[(int)NpgsqlDbType.Bigint] = TryParseBigint;

_parsers[(int)NpgsqlDbType.Double] = TryParseDouble;

_parsers[(int)NpgsqlDbType.Real] = TryParseReal;

_parsers[(int)NpgsqlDbType.Numeric] = TryParseDecimal;

_parsers[(int)NpgsqlDbType.Money] = TryParseDecimal;

// Boolean

_parsers[(int)NpgsqlDbType.Boolean] = TryParseBoolean;

// DateTime types

_parsers[(int)NpgsqlDbType.Timestamp] = TryParseTimestamp;

_parsers[(int)NpgsqlDbType.TimestampTz] = TryParseTimestampTz;

_parsers[(int)NpgsqlDbType.Date] = TryParseDate;

_parsers[(int)NpgsqlDbType.Time] = TryParseTime;

_parsers[(int)NpgsqlDbType.TimeTz] = TryParseTimeTz;

// UUID

_parsers[(int)NpgsqlDbType.Uuid] = TryParseUuid;

// Text types - handled separately (just return string as-is)

// Not added to lookup - will fall through to text handling

}

// NpgsqlDbType flags for Range and Multirange

private const int RangeFlag = 0x40000000; // NpgsqlDbType.Range

private const int MultirangeFlag = 0x20000000; // NpgsqlDbType.Multirange

/// <summary>

/// Gets the parser delegate for the specified NpgsqlDbType.

/// Returns null if the type should be handled as text.

/// </summary>

[MethodImpl(MethodImplOptions.AggressiveInlining)]

public static TryParseDelegate? GetParser(NpgsqlDbType dbType)

{

int rawValue = (int)dbType;

// Range and Multirange types are handled as text

if ((rawValue & (RangeFlag | MultirangeFlag)) != 0)

{

return null;

}

// Strip Array flag and look up in table

int index = rawValue & ~(int)NpgsqlDbType.Array;

return (uint)index < (uint)_parsers.Length ? _parsers[index] : null;

}

private static bool TryParseSmallint(string? value, out object? result)

{

if (short.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseInteger(string? value, out object? result)

{

if (int.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseBigint(string? value, out object? result)

{

if (long.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseDouble(string? value, out object? result)

{

if (double.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseReal(string? value, out object? result)

{

if (float.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseDecimal(string? value, out object? result)

{

if (decimal.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseBoolean(string? value, out object? result)

{

if (bool.TryParse(value, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

// AssumeUniversal: naive ISO strings (no offset, no Z) are treated as UTC -

// the canonical JSON-over-HTTP convention. AdjustToUniversal: Z- and offset-

// bearing values are converted to UTC. Together they yield Kind=Utc holding

// the true UTC instant regardless of the host's TZ. Without these styles,

// DateTime.TryParse silently shifts to host-local time and tags Kind=Local.

private const DateTimeStyles UtcStyles =

DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal;

/// <summary>

/// Process-wide toggle wired from <see cref="NpgsqlRestOptions.JsonTimestampsAreUtc"/>. When true (default), the

/// datetime parsers convert any input to UTC and assume naive strings are UTC. When false, the legacy pre-3.16.0

/// host-local-interpretation behavior is restored.

/// </summary>

public static bool JsonTimestampsAreUtc = true;

private static bool TryParseTimestamp(string? value, out object? result)

{

if (JsonTimestampsAreUtc)

{

if (DateTime.TryParse(value, CultureInfo.InvariantCulture, UtcStyles, out var v))

{

// Strip Kind so Npgsql sends the UTC clock-time verbatim as the

// naive wall-clock value for `timestamp without time zone`.

result = DateTime.SpecifyKind(v, DateTimeKind.Unspecified);

return true;

}

}

else if (DateTime.TryParse(value, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

private static bool TryParseTimestampTz(string? value, out object? result)

{

if (JsonTimestampsAreUtc)

{

if (DateTime.TryParse(value, CultureInfo.InvariantCulture, UtcStyles, out var v))

{

result = v;

return true;

}

}

else if (DateTime.TryParse(value, out var v))

{

result = DateTime.SpecifyKind(v, DateTimeKind.Utc);

return true;

}

result = null;

return false;

}

private static bool TryParseDate(string? value, out object? result)

{

// Fast path: bare date or naive date-time string. DateOnly.TryParse handles

// "2026-05-20" and "2026-05-20T06:00:00" but rejects any Z- or offset-bearing

// input outright.

if (DateOnly.TryParse(value, out var v))

{

result = v;

return true;

}

// Fallback for Z- and offset-bearing strings (e.g. "2026-05-20T03:00:00Z"). The

// legacy parser returned false here, forcing callers to strip the time portion

// client-side. The fallback parses as DateTime and extracts the date portion.

// The UTC-vs-host-local semantic mirrors JsonTimestampsAreUtc so that the

// chosen date is deterministic on UTC hosts (true) or matches the host's

// calendar day (false).

if (JsonTimestampsAreUtc)

{

if (DateTime.TryParse(value, CultureInfo.InvariantCulture, UtcStyles, out var dt))

{

result = DateOnly.FromDateTime(dt);

return true;

}

}

else if (DateTime.TryParse(value, out var dt))

{

result = DateOnly.FromDateTime(dt);

return true;

}

result = null;

return false;

}

private static bool TryParseTime(string? value, out object? result)

{

if (JsonTimestampsAreUtc)

{

if (DateTime.TryParse(value, CultureInfo.InvariantCulture, UtcStyles, out var v))

{

result = TimeOnly.FromDateTime(v);

return true;

}

}

else if (DateTime.TryParse(value, out var v))

{

result = TimeOnly.FromDateTime(v);

return true;

}

result = null;

return false;

}

private static bool TryParseTimeTz(string? value, out object? result)

{

if (JsonTimestampsAreUtc)

{

if (DateTime.TryParse(value, CultureInfo.InvariantCulture, UtcStyles, out var v))

{

result = new DateTimeOffset(v, TimeSpan.Zero);

return true;

}

}

else if (DateTime.TryParse(value, out var v))

{

result = new DateTimeOffset(DateTime.SpecifyKind(v, DateTimeKind.Utc));

return true;

}

result = null;

return false;

}

private static bool TryParseUuid(string? value, out object? result)

{

if (Guid.TryParse(value, out var v))

{

result = v;

return true;

}

result = null;

return false;

}

}