using System.Collections.Concurrent;

using Npgsql;

namespace NpgsqlRest;

/// <summary>

/// Metadata for a composite type including field names, types, and nested composite info.

/// </summary>

public class CompositeTypeMetadata

{

/// <summary>

/// Fully qualified type name, e.g., "public.my_type"

/// </summary>

public required string TypeName { get; init; }

/// <summary>

/// Field names in order, e.g., ["id", "name", "nested_val"]

/// </summary>

public required string[] FieldNames { get; init; }

/// <summary>

/// Field type names in order, e.g., ["integer", "text", "public.inner_type"]

/// </summary>

public required string[] FieldTypeNames { get; init; }

/// <summary>

/// Converted field names using the name converter

/// </summary>

public string[]? ConvertedFieldNames { get; set; }

/// <summary>

/// Type descriptors for each field

/// </summary>

public TypeDescriptor[]? FieldDescriptors { get; set; }

/// <summary>

/// For each field, if it's a composite type, contains its metadata; null otherwise

/// </summary>

public CompositeTypeMetadata?[]? NestedFieldTypes { get; set; }

/// <summary>

/// For each field, true if the field is an array type

/// </summary>

public required bool[] IsArrayField { get; init; }

/// <summary>

/// For each field that is an array of composites, contains the element type metadata

/// </summary>

public CompositeTypeMetadata?[]? ArrayElementTypes { get; set; }

}

/// <summary>

/// Thread-safe cache for composite type metadata.

/// Used to resolve nested composite types for deep JSON serialization.

/// </summary>

public static class CompositeTypeCache

{

private static readonly ConcurrentDictionary<string, CompositeTypeMetadata> _cache = new(StringComparer.Ordinal);

private static readonly object _initLock = new();

private static volatile bool _initialized = false;

private static Func<string, string?>? _nameConverter;

/// <summary>

/// SQL query to fetch all composite types and their fields.

/// </summary>

private const string TypeQuery = """

select

(quote_ident(n.nspname) || '.' || quote_ident(t.typname))::regtype::text as type_name,

a.attnum as field_pos,

a.attname as field_name,

pg_catalog.format_type(a.atttypid, a.atttypmod) as field_type,

ft.typrelid <> 0 as is_field_composite,

a.atttypid = any(array(select oid from pg_type where typelem <> 0)) as is_array,

case

when ft.typelem <> 0 then

(select eft.typrelid <> 0

from pg_catalog.pg_type eft

where eft.oid = ft.typelem)

else false

end as is_array_of_composite

from pg_catalog.pg_type t

join pg_catalog.pg_namespace n on n.oid = t.typnamespace

join pg_catalog.pg_class c on t.typrelid = c.oid and c.relkind in ('r', 'c')

join pg_catalog.pg_attribute a on t.typrelid = a.attrelid

and a.attisdropped is false and a.attnum > 0

left join pg_catalog.pg_type ft on a.atttypid = ft.oid

where n.nspname not like 'pg_%'

and n.nspname <> 'information_schema'

and has_schema_privilege(current_user, n.nspname, 'USAGE')

order by type_name, field_pos

""";

/// <summary>

/// Initialize the composite type cache from the database.

/// Thread-safe and idempotent - only loads once.

/// </summary>

/// <param name="connection">Open database connection</param>

/// <param name="nameConverter">Name converter function for field names</param>

public static void Initialize(NpgsqlConnection connection, Func<string, string?>? nameConverter = null)

{

if (_initialized) return;

lock (_initLock)

{

if (_initialized) return;

_nameConverter = nameConverter;

LoadAllCompositeTypes(connection);

ResolveNestedTypes();

_initialized = true;

}

}

/// <summary>

/// Clear the cache. Useful for testing or when schema changes.

/// </summary>

public static void Clear()

{

lock (_initLock)

{

_cache.Clear();

_initialized = false;

_nameConverter = null;

}

}

/// <summary>

/// Check if the cache is initialized.

/// </summary>

public static bool IsInitialized => _initialized;

/// <summary>

/// Get metadata for a composite type by name.

/// </summary>

/// <param name="typeName">Type name (e.g., "public.my_type" or "my_type")</param>

/// <returns>Composite type metadata, or null if not a composite type</returns>

public static CompositeTypeMetadata? GetType(string? typeName)

{

if (string.IsNullOrEmpty(typeName)) return null;

return FindInCache(typeName);

}

/// <summary>

/// Get metadata for the element type of an array of composites.

/// </summary>

/// <param name="arrayTypeName">Array type name (e.g., "public.my_type[]")</param>

/// <returns>Element composite type metadata, or null if not an array of composites</returns>

public static CompositeTypeMetadata? GetArrayElementType(string? arrayTypeName)

{

if (string.IsNullOrEmpty(arrayTypeName)) return null;

// Strip array suffix(es) - handles both [] and [][] etc.

var elementTypeName = arrayTypeName;

while (elementTypeName.EndsWith("[]", StringComparison.Ordinal))

{

elementTypeName = elementTypeName[..^2];

}

return GetType(elementTypeName);

}

/// <summary>

/// Resolve composite type metadata for a TypeDescriptor.

/// Sets CompositeFieldNames/CompositeFieldDescriptors if the type is a composite,

/// or ArrayCompositeFieldNames/ArrayCompositeFieldDescriptors if it's an array of composites.

/// Can be called from plugins since TypeDescriptor setters are internal.

/// </summary>

/// <param name="descriptor">The TypeDescriptor to resolve</param>

/// <returns>True if the descriptor was resolved as a composite or array of composites</returns>

public static bool ResolveTypeDescriptor(TypeDescriptor descriptor)

{

var compositeMetadata = GetType(descriptor.OriginalType);

if (compositeMetadata != null)

{

descriptor.CompositeFieldNames = compositeMetadata.ConvertedFieldNames;

descriptor.CompositeFieldDescriptors = compositeMetadata.FieldDescriptors;

return true;

}

if (descriptor.IsArray)

{

var elementMetadata = GetArrayElementType(descriptor.OriginalType);

if (elementMetadata != null)

{

descriptor.ArrayCompositeFieldNames = elementMetadata.ConvertedFieldNames;

descriptor.ArrayCompositeFieldDescriptors = elementMetadata.FieldDescriptors;

return true;

}

}

return false;

}

/// <summary>

/// Normalize type name by removing quotes and handling schema prefixes.

/// </summary>

private static string NormalizeTypeName(string typeName)

{

// Remove surrounding quotes if present

var result = typeName.Trim();

if (result.StartsWith('"') && result.EndsWith('"'))

{

result = result[1..^1];

}

// Handle quoted identifiers within the name

result = result.Replace("\"", "");

return result;

}

/// <summary>

/// Try to find a type in the cache, also trying without schema prefix.

/// PostgreSQL regtype::text omits the public schema, but other sources may include it.

/// </summary>

private static CompositeTypeMetadata? FindInCache(string typeName)

{

var normalized = NormalizeTypeName(typeName);

if (_cache.TryGetValue(normalized, out var result))

{

return result;

}

// Try stripping schema prefix (e.g., "public.my_type" → "my_type")

int dotIndex = normalized.IndexOf('.');

if (dotIndex >= 0)

{

var withoutSchema = normalized[(dotIndex + 1)..];

if (_cache.TryGetValue(withoutSchema, out result))

{

return result;

}

}

return null;

}

/// <summary>

/// Load all composite types from the database into the cache.

/// </summary>

private static void LoadAllCompositeTypes(NpgsqlConnection connection)

{

using var command = connection.CreateCommand();

command.CommandText = TypeQuery;

command.LogCommand(nameof(CompositeTypeCache));

using var reader = command.ExecuteReader();

// Group rows by type name to build metadata

string? currentTypeName = null;

var fieldNames = new List<string>();

var fieldTypes = new List<string>();

var isArrayField = new List<bool>();

var isFieldComposite = new List<bool>();

var isArrayOfComposite = new List<bool>();

while (reader.Read())

{

var typeName = reader.GetString(0);

// If we've moved to a new type, save the previous one

if (currentTypeName != null && typeName != currentTypeName)

{

SaveTypeMetadata(currentTypeName, fieldNames, fieldTypes, isArrayField, isFieldComposite, isArrayOfComposite);

fieldNames.Clear();

fieldTypes.Clear();

isArrayField.Clear();

isFieldComposite.Clear();

isArrayOfComposite.Clear();

}

currentTypeName = typeName;

fieldNames.Add(reader.GetString(2));

fieldTypes.Add(reader.GetString(3));

isArrayField.Add(reader.GetBoolean(5));

isFieldComposite.Add(reader.GetBoolean(4));

isArrayOfComposite.Add(reader.GetBoolean(6));

}

// Don't forget the last type

if (currentTypeName != null)

{

SaveTypeMetadata(currentTypeName, fieldNames, fieldTypes, isArrayField, isFieldComposite, isArrayOfComposite);

}

}

/// <summary>

/// Save a single type's metadata to the cache.

/// </summary>

private static void SaveTypeMetadata(

string typeName,

List<string> fieldNames,

List<string> fieldTypes,

List<bool> isArrayField,

List<bool> isFieldComposite,

List<bool> isArrayOfComposite)

{

var fieldNamesArray = fieldNames.ToArray();

var fieldTypesArray = fieldTypes.ToArray();

var count = fieldNamesArray.Length;

// Apply name converter

var convertedNames = new string[count];

for (var i = 0; i < count; i++)

{

convertedNames[i] = _nameConverter?.Invoke(fieldNamesArray[i]) ?? fieldNamesArray[i];

}

// Create type descriptors for each field

var descriptors = new TypeDescriptor[count];

for (var i = 0; i < count; i++)

{

descriptors[i] = new TypeDescriptor(fieldTypesArray[i]);

}

var metadata = new CompositeTypeMetadata

{

TypeName = typeName,

FieldNames = fieldNamesArray,

FieldTypeNames = fieldTypesArray,

ConvertedFieldNames = convertedNames,

FieldDescriptors = descriptors,

IsArrayField = isArrayField.ToArray(),

// These will be populated in ResolveNestedTypes()

NestedFieldTypes = new CompositeTypeMetadata?[count],

ArrayElementTypes = new CompositeTypeMetadata?[count]

};

var normalizedName = NormalizeTypeName(typeName);

_cache[normalizedName] = metadata;

}

/// <summary>

/// After all types are loaded, resolve nested type references.

/// Uses cycle detection to handle self-referencing types.

/// </summary>

private static void ResolveNestedTypes()

{

foreach (var metadata in _cache.Values)

{

var visited = new HashSet<string>(StringComparer.Ordinal);

ResolveNestedTypesForType(metadata, visited);

}

}

/// <summary>

/// Recursively resolve nested types for a single type.

/// </summary>

private static void ResolveNestedTypesForType(CompositeTypeMetadata metadata, HashSet<string> visited)

{

// Cycle detection

var normalizedName = NormalizeTypeName(metadata.TypeName);

if (!visited.Add(normalizedName))

{

return; // Already processing this type - circular reference

}

try

{

for (var i = 0; i < metadata.FieldTypeNames.Length; i++)

{

var fieldType = metadata.FieldTypeNames[i];

// Check if this field is a composite type

var nestedType = GetType(fieldType);

if (nestedType != null)

{

metadata.NestedFieldTypes![i] = nestedType;

// Also set the nested info on the TypeDescriptor

if (metadata.FieldDescriptors != null)

{

metadata.FieldDescriptors[i].CompositeFieldNames = nestedType.ConvertedFieldNames;

metadata.FieldDescriptors[i].CompositeFieldDescriptors = nestedType.FieldDescriptors;

}

// Recursively resolve (with cycle detection)

ResolveNestedTypesForType(nestedType, visited);

}

// Check if this field is an array of composites

if (metadata.IsArrayField[i])

{

var elementType = GetArrayElementType(fieldType);

if (elementType != null)

{

metadata.ArrayElementTypes![i] = elementType;

// Also set the array composite info on the TypeDescriptor

if (metadata.FieldDescriptors != null)

{

metadata.FieldDescriptors[i].ArrayCompositeFieldNames = elementType.ConvertedFieldNames;

metadata.FieldDescriptors[i].ArrayCompositeFieldDescriptors = elementType.FieldDescriptors;

}

// Recursively resolve the element type

ResolveNestedTypesForType(elementType, visited);

}

}

}

}

finally

{

visited.Remove(normalizedName);

}

}

}