using System;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using Microsoft.Extensions.Primitives;
using System.Globalization;
using NpgsqlTypes;

namespace NpgsqlRest;

internal static class ParameterParser
{
    internal static bool TryParseParameter(
        ref StringValues values, 
        ref TypeDescriptor descriptor,
        ref NpgsqlRestParameter parameter,
        QueryStringNullHandling queryStringNullHandling)
    {
        if (descriptor.IsArray == false)
        {
            if (values.Count == 0)
            {
                parameter.Value = DBNull.Value;
                return true;
            }
            if (values.Count == 1)
            {
                var value = values[0];
                if (TryGetValue(ref descriptor, ref value, out var resultValue))
                {
                    parameter.Value = resultValue;
                    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(ref descriptor, ref value, out var resultValue))
                {
                    parameter.Value = resultValue;
                    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(ref descriptor, ref value, out var resultValue))
            {
                list.Add(resultValue);
            }
            else
            {
                return false;
            }
        }
        parameter.Value = list;
        return true;

        bool TryGetValue(
            ref TypeDescriptor descriptor, 
            ref string? value, 
            out object? resultValue)
        {
            if (queryStringNullHandling == QueryStringNullHandling.NullLiteral)
            {
                if (string.Equals(value, "null", StringComparison.OrdinalIgnoreCase))
                {
                    resultValue = DBNull.Value;
                    return true;
                }
            } 
            else if (queryStringNullHandling == QueryStringNullHandling.EmptyString)
            {
                if (string.IsNullOrEmpty(value))
                {
                    resultValue = DBNull.Value;
                    return true;
                }
            }

            if (!descriptor.IsText && string.IsNullOrEmpty(value))
            {
                resultValue = DBNull.Value;
                return true;
            }

            if (descriptor.BaseDbType == NpgsqlDbType.Smallint)
            {
                if (short.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var shortValue))
                {
                    resultValue = shortValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Integer)
            {
                if (int.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var intValue))
                {
                    resultValue = intValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Bigint)
            {
                if (long.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var bigValue))
                {
                    resultValue = bigValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Double)
            {
                if (double.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var doubleValue))
                {
                    resultValue = doubleValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Real)
            {
                if (float.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var floatValue))
                {
                    resultValue = floatValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Numeric || descriptor.BaseDbType == NpgsqlDbType.Money)
            {
                if (decimal.TryParse(value, CultureInfo.InvariantCulture.NumberFormat, out var decimalValue))
                {
                    resultValue = decimalValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Boolean)
            {
                if (bool.TryParse(value, out var boolValue))
                {
                    resultValue = boolValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Timestamp || descriptor.BaseDbType == NpgsqlDbType.TimestampTz)
            {
                if (DateTime.TryParse(value, out var dateTimeValue))
                {
                    resultValue = descriptor.BaseDbType == NpgsqlDbType.TimestampTz ? DateTime.SpecifyKind(dateTimeValue, DateTimeKind.Utc) : dateTimeValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Date)
            {
                if (DateOnly.TryParse(value, out var dateTimeValue))
                {
                    resultValue = dateTimeValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }

            if (descriptor.BaseDbType == NpgsqlDbType.Time || descriptor.BaseDbType == NpgsqlDbType.TimeTz)
            {
                if (DateTime.TryParse(value, out var dateTimeValue))
                {
                    if (descriptor.BaseDbType == NpgsqlDbType.TimeTz)
                    {
                        resultValue = new DateTimeOffset(DateTime.SpecifyKind(dateTimeValue, DateTimeKind.Utc));
                    }
                    else
                    {
                        resultValue = TimeOnly.FromDateTime(dateTimeValue);
                    }
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.BaseDbType == NpgsqlDbType.Uuid)
            {
                if (Guid.TryParse(value, out var guidValue))
                {
                    resultValue = guidValue;
                    return true;
                }
                resultValue = null!;
                return false;
            }
            if (descriptor.IsText)
            {
                resultValue = value;
                return true;
            }

            // for all other cases, use raw string
            resultValue = value;
            return true;
        }
    }

    internal static bool TryParseParameter(
        ref JsonNode? value, 
        ref TypeDescriptor descriptor,
        ref NpgsqlRestParameter parameter)
    {
        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(ref descriptor, ref value, ref kind, out var nonStringValue))
        {
            parameter.Value = nonStringValue;
            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(ref descriptor, ref arrayItem, ref arrayItemKind, out object arrayValue))
                {
                    list.Add(arrayValue);
                    continue;
                }

                var arrayItemContent = arrayItem.ToString();
                if (TryGetNonStringValueFromString(ref descriptor, ref arrayItemContent, out arrayValue))
                {
                    list.Add(arrayValue);
                    continue;
                }
                list.Add(arrayItemContent);
            }
            parameter.Value = list;
            return true;
        }

        var content = value.ToString();
        if (TryGetNonStringValueFromString(ref descriptor, ref content, out nonStringValue))
        {
            parameter.Value = nonStringValue;
            return true;
        }

        parameter.Value = content;
        return true;

        bool TryGetNonStringValue(
            ref TypeDescriptor descriptor, 
            ref JsonNode value, 
            ref JsonValueKind valueKind, 
            out object result)
        {
            try
            {
                if (valueKind == JsonValueKind.Number)
                {
                    if (descriptor.BaseDbType == NpgsqlDbType.Smallint)
                    {
                        result = value.GetValue<short>();
                        return true;
                    }

                    if (descriptor.BaseDbType == NpgsqlDbType.Integer)
                    {
                        result = value.GetValue<int>();
                        return true;
                    }

                    if (descriptor.BaseDbType == NpgsqlDbType.Bigint)
                    {
                        result = value.GetValue<long>();
                        return true;
                    }

                    if (descriptor.BaseDbType == NpgsqlDbType.Double)
                    {
                        result = value.GetValue<double>();
                        return true;
                    }

                    if (descriptor.BaseDbType == NpgsqlDbType.Real)
                    {
                        result = value.GetValue<float>();
                        return true;
                    }

                    if (descriptor.BaseDbType is NpgsqlDbType.Numeric or NpgsqlDbType.Money)
                    {
                        result = value.GetValue<decimal>();
                        return true;
                    }
                }
                if (valueKind is JsonValueKind.True or JsonValueKind.False && descriptor.BaseDbType == NpgsqlDbType.Boolean)
                {
                    result = value.GetValue<bool>();
                    return true;
                }
            }
            catch (Exception ex) when (ex is FormatException or InvalidOperationException)
            {
            }
            result = null!;
            return false;
        }

        bool TryGetNonStringValueFromString(
            ref TypeDescriptor descriptor, 
            ref string nonStrContent, 
            out object result)
        {
            if (descriptor.BaseDbType is NpgsqlDbType.Timestamp or NpgsqlDbType.TimestampTz)
            {
                if (DateTime.TryParse(nonStrContent, out var dateTimeValue))
                {
                    if (descriptor.BaseDbType == NpgsqlDbType.TimestampTz)
                    {
                        result = DateTime.SpecifyKind(dateTimeValue, DateTimeKind.Utc);
                    }
                    else
                    {
                        result = dateTimeValue;
                    }
                    return true;
                }
            }
            else if (descriptor.BaseDbType == NpgsqlDbType.Date)
            {
                if (DateOnly.TryParse(nonStrContent, out var dateTimeValue))
                {
                    result = dateTimeValue;
                    return true;
                }
            }
            else if (descriptor.BaseDbType is NpgsqlDbType.Time or NpgsqlDbType.TimeTz)
            {
                if (DateTime.TryParse(nonStrContent, out var dateTimeValue))
                {
                    if (descriptor.BaseDbType == NpgsqlDbType.TimeTz)
                    {
                        result = new DateTimeOffset(DateTime.SpecifyKind(dateTimeValue, DateTimeKind.Utc));
                    }
                    else
                    {
                        result = TimeOnly.FromDateTime(dateTimeValue);
                    };
                    return true;
                }
            }
            else if (descriptor.BaseDbType == NpgsqlDbType.Uuid)
            {
                if (Guid.TryParse(nonStrContent, out var guidValue))
                {
                    result = guidValue;
                    return true;
                }
            }
            result = null!;
            return false;
        }
    }

    internal static string FormatParam(ref object value, ref TypeDescriptor descriptor)
    {
        if (value == DBNull.Value)
        {
            return "null";
        }
        if (descriptor.IsArray && value is IList<object> list)
        {
            var d = descriptor;
            if (descriptor is { IsNumeric: false, IsBoolean: false })
            {
                return string.Concat("{", string.Join(",", list.Select(x => string.Concat("'", Format(ref x, ref d), "'"))), "}");
            }
            return string.Concat("{", string.Join(",", list.Select(x => Format(ref x, ref d))), "}");
        }
        if (descriptor is { IsNumeric: false, IsBoolean: false })
        {
            return string.Concat("'", Format(ref value, ref descriptor), "'");
        }

        return Format(ref value, ref descriptor);

        string Format(ref object v, ref 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;
        }
    }
}