using NpgsqlTypes;

namespace NpgsqlRest;

public class TypeDescriptor

{

public string OriginalType { get; }

public string Type { get; }

public bool IsArray { get; }

public NpgsqlDbType DbType { get; }

public NpgsqlDbType BaseDbType { get; }

public NpgsqlDbType ActualDbType { get; }

public bool HasDefault { get; private set; }

public bool IsPk { get; }

public bool IsIdentity { get; }

public string? CustomType { get; }

public short? CustomTypePosition { get; }

public string? OriginalParameterName { get; }

public string? CustomTypeName { get; }

internal bool ShouldRenderAsUnknownType => IsBinary is false;

/// <summary>

/// Pre-computed type category flags for optimized type dispatch.

/// Use bitwise operations for fast type checking in hot paths.

/// </summary>

public TypeCategory Category { get; }

// Computed properties from Category for backward compatibility

public bool IsNumeric => (Category & TypeCategory.Numeric) != 0;

public bool IsJson => (Category & TypeCategory.Json) != 0;

public bool IsDate => (Category & TypeCategory.Date) != 0;

public bool IsDateTime => (Category & TypeCategory.DateTime) != 0;

public bool IsBoolean => (Category & TypeCategory.Boolean) != 0;

public bool IsText => (Category & TypeCategory.Text) != 0;

public bool NeedsEscape { get; }

public bool IsBinary => (Category & TypeCategory.Binary) != 0;

// Properties for nested composite type support

/// <summary>

/// For fields that are composite types, the converted field names of the nested type.

/// Null if this is not a composite type field.

/// </summary>

public string[]? CompositeFieldNames { get; internal set; }

/// <summary>

/// For fields that are composite types, the type descriptors for each nested field.

/// Null if this is not a composite type field.

/// </summary>

public TypeDescriptor[]? CompositeFieldDescriptors { get; internal set; }

/// <summary>

/// For fields that are arrays of composite types, the converted field names of the element type.

/// Null if this is not an array of composite type field.

/// </summary>

public string[]? ArrayCompositeFieldNames { get; internal set; }

/// <summary>

/// For fields that are arrays of composite types, the type descriptors for each element field.

/// Null if this is not an array of composite type field.

/// </summary>

public TypeDescriptor[]? ArrayCompositeFieldDescriptors { get; internal set; }

/// <summary>

/// True if this field is a composite type with resolved nested field metadata.

/// </summary>

public bool IsCompositeType => CompositeFieldNames != null;

/// <summary>

/// True if this field is an array of composite types with resolved nested field metadata.

/// </summary>

public bool IsArrayOfCompositeType => ArrayCompositeFieldNames != null;

public TypeDescriptor(

string type,

bool hasDefault = false,

bool isPk = false,

bool isIdentity = false,

string? customType = null,

short? customTypePosition = null,

string? originalParameterName = null,

string? customTypeName = null)

{

OriginalType = type;

HasDefault = hasDefault;

IsPk = isPk;

IsIdentity = isIdentity;

IsArray = type.EndsWith("[]");

Type = (IsArray ? type[..^2] : type).Trim(Consts.DoubleQuote);

DbType = GetDbType();

BaseDbType = DbType;

// Use pre-computed lookup table for type category

Category = TypeCategoryLookup.GetCategory(BaseDbType);

ActualDbType = (Category & TypeCategory.CastToText) != 0 ? NpgsqlDbType.Text : BaseDbType;

if (IsArray)

{

DbType |= NpgsqlDbType.Array;

ActualDbType |= NpgsqlDbType.Array;

}

NeedsEscape = (Category & TypeCategory.NeedsEscape) != 0;

CustomType = customType;

CustomTypePosition = customTypePosition;

OriginalParameterName = originalParameterName;

CustomTypeName = customTypeName;

}

internal void SetHasDefault()

{

HasDefault = true;

}

public bool IsCastToText() => (Category & TypeCategory.CastToText) != 0;

private NpgsqlDbType GetDbType()

{

// Strip type modifiers (length, precision, scale) before matching

// e.g., "character(1)" -> "character", "numeric(10,2)" -> "numeric"

var normalizedType = Type;

var parenIndex = Type.IndexOf('(');

if (parenIndex > 0)

{

normalizedType = Type.Substring(0, parenIndex);

}

var result = normalizedType switch

{

"smallint" => NpgsqlDbType.Smallint,

"int" => NpgsqlDbType.Integer,

"integer" => NpgsqlDbType.Integer,

"bigint" => NpgsqlDbType.Bigint,

"decimal" => NpgsqlDbType.Numeric,

"numeric" => NpgsqlDbType.Numeric,

"real" => NpgsqlDbType.Real,

"double precision" => NpgsqlDbType.Double,

"float" => NpgsqlDbType.Double,

"int2" => NpgsqlDbType.Smallint,

"int4" => NpgsqlDbType.Integer,

"int8" => NpgsqlDbType.Bigint,

"float4" => NpgsqlDbType.Real,

"float8" => NpgsqlDbType.Double,

"money" => NpgsqlDbType.Money,

"smallserial" => NpgsqlDbType.Smallint,

"serial" => NpgsqlDbType.Integer,

"serial2" => NpgsqlDbType.Smallint,

"serial4" => NpgsqlDbType.Integer,

"bigserial" => NpgsqlDbType.Bigint,

"serial8" => NpgsqlDbType.Bigint,

"text" => NpgsqlDbType.Text,

"xml" => NpgsqlDbType.Xml,

"varchar" => NpgsqlDbType.Varchar,

"character varying" => NpgsqlDbType.Varchar,

"bpchar" => NpgsqlDbType.Char,

"character" => NpgsqlDbType.Char,

"char" => NpgsqlDbType.Char,

"name" => NpgsqlDbType.Name,

"refcursor" => NpgsqlDbType.Refcursor,

"jsonb" => NpgsqlDbType.Jsonb,

"json" => NpgsqlDbType.Json,

"jsonpath" => NpgsqlDbType.JsonPath,

"timestamp" => NpgsqlDbType.Timestamp,

"timestamptz" => NpgsqlDbType.TimestampTz,

"timestamp without time zone" => NpgsqlDbType.Timestamp,

"timestamp with time zone" => NpgsqlDbType.TimestampTz,

"date" => NpgsqlDbType.Date,

"time" => NpgsqlDbType.Time,

"timetz" => NpgsqlDbType.TimeTz,

"time without time zone" => NpgsqlDbType.Time,

"time with time zone" => NpgsqlDbType.TimeTz,

"interval" => NpgsqlDbType.Interval,

"bool" => NpgsqlDbType.Boolean,

"boolean" => NpgsqlDbType.Boolean,

"bytea" => NpgsqlDbType.Bytea,

"uuid" => NpgsqlDbType.Uuid,

"bit varying" => NpgsqlDbType.Varbit,

"varbit" => NpgsqlDbType.Varbit,

"bit" => NpgsqlDbType.Bit,

"cidr" => NpgsqlDbType.Cidr,

"inet" => NpgsqlDbType.Inet,

"macaddr" => NpgsqlDbType.MacAddr,

"macaddr8" => NpgsqlDbType.MacAddr8,

"tsquery" => NpgsqlDbType.TsQuery,

"tsvector" => NpgsqlDbType.TsVector,

"box" => NpgsqlDbType.Box,

"circle" => NpgsqlDbType.Circle,

"line" => NpgsqlDbType.Line,

"lseg" => NpgsqlDbType.LSeg,

"path" => NpgsqlDbType.Path,

"point" => NpgsqlDbType.Point,

"polygon" => NpgsqlDbType.Polygon,

"oid" => NpgsqlDbType.Oid,

"xid" => NpgsqlDbType.Xid,

"xid8" => NpgsqlDbType.Xid8,

"cid" => NpgsqlDbType.Cid,

"regtype" => NpgsqlDbType.Regtype,

"regconfig" => NpgsqlDbType.Regconfig,

"int4range" => NpgsqlDbType.IntegerRange,

"int8range" => NpgsqlDbType.BigIntRange,

"numrange" => NpgsqlDbType.NumericRange,

"tsrange" => NpgsqlDbType.TimestampRange,

"tstzrange" => NpgsqlDbType.TimestampTzRange,

"daterange" => NpgsqlDbType.DateRange,

"int4multirange" => NpgsqlDbType.IntegerMultirange,

"int8multirange" => NpgsqlDbType.BigIntMultirange,

"nummultirange" => NpgsqlDbType.NumericMultirange,

"tsmultirange" => NpgsqlDbType.TimestampMultirange,

"tstzmultirange" => NpgsqlDbType.TimestampTzMultirange,

"datemultirange" => NpgsqlDbType.DateMultirange,

"int2vector" => NpgsqlDbType.Int2Vector,

"oidvector" => NpgsqlDbType.Oidvector,

"pg_lsn" => NpgsqlDbType.PgLsn,

"tid" => NpgsqlDbType.Tid,

"citext" => NpgsqlDbType.Citext,

"lquery" => NpgsqlDbType.LQuery,

"ltree" => NpgsqlDbType.LTree,

"ltxtquery" => NpgsqlDbType.LTxtQuery,

"hstore" => NpgsqlDbType.Hstore,

"geometry" => NpgsqlDbType.Geometry,

"geography" => NpgsqlDbType.Geography,

_ => NpgsqlDbType.Unknown

};

return result;

}

}