using System.Text;

using System.Text.Json;

using System.Text.Json.Nodes;

using Microsoft.Extensions.Primitives;

using NpgsqlTypes;

namespace NpgsqlRest;

internal static class ParameterParser

{

internal static bool TryParseParameter(

NpgsqlRestParameter parameter,

ref StringValues values,

QueryStringNullHandling queryStringNullHandling)

{

if (parameter.TypeDescriptor.IsArray == false)

{

if (values.Count == 0)

{

parameter.Value = DBNull.Value;

return true;

}

if (values.Count == 1)

{

var value = values[0];

if (TryGetValue(value, out var resultValue))

{

parameter.Value = resultValue;

parameter.OriginalStringValue = value;

return true;

}

return false;

}

else

{

StringBuilder sb = new();

for (var i = 0; i < values.Count; i++)

{

sb.Append(values[i]);

}

var value = sb.ToString();

if (TryGetValue(value, out var resultValue))

{

parameter.Value = resultValue;

parameter.OriginalStringValue = value;

return true;

}

return false;

}

}

if (values.Count == 0)

{

parameter.Value = DBNull.Value;

return true;

}

var list = new List<object?>(values.Count);

for (var i = 0; i < values.Count; i++)

{

var value = values[i];

if (TryGetValue(value, out var resultValue))

{

list.Add(resultValue);

}

else

{

return false;

}

}

parameter.Value = list;

// For arrays, store the original values as a joined string

parameter.OriginalStringValue = string.Join(",", values.ToArray());

return true;

bool TryGetValue(

string? value,

out object? resultValue)

{

if (queryStringNullHandling == QueryStringNullHandling.NullLiteral)

{

if (string.Equals(value, Consts.Null, StringComparison.OrdinalIgnoreCase))

{

resultValue = DBNull.Value;

return true;

}

}

else if (queryStringNullHandling == QueryStringNullHandling.EmptyString)

{

if (string.IsNullOrEmpty(value))

{

resultValue = DBNull.Value;

return true;

}

}

// Fast path for text types

if (parameter.TypeDescriptor.IsText)

{

resultValue = value;

return true;

}

// Empty check for non-text types

if (string.IsNullOrEmpty(value))

{

resultValue = DBNull.Value;

return true;

}

// Use delegate lookup for type-specific parsing

var parser = ParameterParsers.GetParser(parameter.TypeDescriptor.BaseDbType);

if (parser is not null)

{

return parser(value, out resultValue);

}

// Fallback for unknown types - use raw string

resultValue = value;

return true;

}

}

internal static bool TryParseParameter(

NpgsqlRestParameter parameter,

JsonNode? value)

{

if (value is null)

{

parameter.Value = DBNull.Value;

return true;

}

JsonValueKind kind = value.GetValueKind();

if (kind == JsonValueKind.Null)

{

parameter.Value = DBNull.Value;

return true;

}

if (TryGetNonStringValue(value, ref kind, out var nonStringValue))

{

parameter.Value = nonStringValue;

// Store the original JSON representation for cache key consistency

parameter.OriginalStringValue = value.ToJsonString();

return true;

}

if (kind == JsonValueKind.Array)

{

var list = new List<object?>();

JsonArray array = value.AsArray();

for (var i = 0; i < array.Count; i++)

{

var arrayItem = array[i];

if (arrayItem is null)

{

list.Add(null);

continue;

}

var arrayItemKind = arrayItem.GetValueKind();

if (arrayItemKind == JsonValueKind.Null)

{

list.Add(null);

continue;

}

if (TryGetNonStringValue(arrayItem, ref arrayItemKind, out object arrayValue))

{

list.Add(arrayValue);

continue;

}

var arrayItemContent = arrayItem.ToString();

if (TryGetNonStringValueFromString(arrayItemContent, out arrayValue))

{

list.Add(arrayValue);

continue;

}

list.Add(arrayItemContent);

}

parameter.Value = list;

// Store the original JSON array representation for cache key consistency

parameter.OriginalStringValue = value.ToJsonString();

return true;

}

var content = value.ToString();

if (TryGetNonStringValueFromString(content, out nonStringValue))

{

parameter.Value = nonStringValue;

parameter.OriginalStringValue = content;

return true;

}

parameter.Value = content;

parameter.OriginalStringValue = content;

return true;

bool TryGetNonStringValue(

JsonNode value,

ref JsonValueKind valueKind,

out object result)

{

try

{

if (valueKind == JsonValueKind.Number)

{

if (parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Smallint)

{

result = value.GetValue<short>();

return true;

}

if (parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Integer)

{

result = value.GetValue<int>();

return true;

}

if (parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Bigint)

{

result = value.GetValue<long>();

return true;

}

if (parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Double)

{

result = value.GetValue<double>();

return true;

}

if (parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Real)

{

result = value.GetValue<float>();

return true;

}

if (parameter.TypeDescriptor.BaseDbType is NpgsqlDbType.Numeric or NpgsqlDbType.Money)

{

result = value.GetValue<decimal>();

return true;

}

}

if (valueKind is JsonValueKind.True or JsonValueKind.False && parameter.TypeDescriptor.BaseDbType == NpgsqlDbType.Boolean)

{

result = value.GetValue<bool>();

return true;

}

}

catch (Exception ex) when (ex is FormatException or InvalidOperationException)

{

}

result = null!;

return false;

}

bool TryGetNonStringValueFromString(

string nonStrContent,

out object result)

{

// Use delegate lookup for type-specific parsing

var parser = ParameterParsers.GetParser(parameter.TypeDescriptor.BaseDbType);

if (parser is not null && parser(nonStrContent, out var parsed) && parsed is not null)

{

result = parsed;

return true;

}

result = null!;

return false;

}

}

internal static string FormatParameterForLog(NpgsqlRestParameter parameter)

{

var value = parameter.NpgsqlValue;

var descriptor = parameter.TypeDescriptor;

if (value is null || value == DBNull.Value)

{

return Consts.Null;

}

// Use OriginalStringValue if available and format it according to PostgreSQL standard

if (parameter.OriginalStringValue is not null)

{

if (descriptor.IsArray)

{

// Format as PostgreSQL array literal: '{value1,value2}'

return string.Concat("'", parameter.OriginalStringValue, "'");

}

if (descriptor is { IsNumeric: false, IsBoolean: false })

{

return string.Concat("'", parameter.OriginalStringValue, "'");

}

return parameter.OriginalStringValue;

}

// Fallback for internally-set values (user claims, IP address, etc.)

if (descriptor.IsArray)

{

if (value is IList<object> objectList)

{

var d = descriptor;

if (descriptor is { IsNumeric: false, IsBoolean: false })

{

return string.Concat("'{", string.Join(",", objectList.Select(x => Format(x, d))), "}'");

}

return string.Concat("'{", string.Join(",", objectList.Select(x => Format(x, d))), "}'");

}

if (value is IList<string> stringList)

{

var d = descriptor;

if (descriptor is { IsNumeric: false, IsBoolean: false })

{

return string.Concat("'{", string.Join(",", stringList.Select(x => Format(x, d))), "}'");

}

return string.Concat("'{", string.Join(",", stringList.Select(x => Format(x, d))), "}'");

}

}

if (descriptor is { IsNumeric: false, IsBoolean: false })

{

return string.Concat("'", Format(value, descriptor), "'");

}

return Format(value, descriptor);

static string Format(object v, TypeDescriptor descriptor)

{

if (v is DateTime dt)

{

if (descriptor.BaseDbType == NpgsqlDbType.TimestampTz)

{

return dt.ToString("O");

}

return dt.ToString("s");

}

if (v is DateOnly dateOnly)

{

return dateOnly.ToString("O");

}

if (v is DateTimeOffset dto)

{

return dto.DateTime.ToString("T");

}

if (descriptor.IsBoolean)

{

return v.ToString()?.ToLowerInvariant() ?? string.Empty;

}

return v.ToString() ?? string.Empty;

}

}

}