using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Text.RegularExpressions;

namespace axXez.TS3.Protocol
{
    /// <summary>A single key-value entry from a TeamSpeak text-protocol message, with typed accessors and deserialization helpers.</summary>
    public class TsDataEntry
    {
        private static readonly Regex _kvRegex = new(@"[ ]?(?<name>[^ =\n|]*)=(?<value>[^ \n|]*)", RegexOptions.Compiled);

        private readonly Dictionary<string, string> _data;

        /// <summary>Returns the value of the first matching key, or an empty string if none is found.</summary>
        public string this[params string[] keys]
            => GetValue(keys);

        internal TsDataEntry(Dictionary<string, string> data)
            => _data = data;

        internal static TsDataEntry Parse(string part)
        {
            var dict = new Dictionary<string, string>();
            foreach (Match match in _kvRegex.Matches(part))
            {
                string key = match.Groups["name"].Value;
                if (!dict.TryAdd(key, TsEncoding.Unescape(match.Groups["value"].Value)))
                    GlobalLogger.Log("TsEncoding", $"Duplicate key '{key}' in entry, ignoring.", LogType.Warning);
            }
            return new TsDataEntry(dict);
        }

        /// <summary>Returns <c>true</c> and sets <paramref name="key"/> to the first matching key found in this entry.</summary>
        public bool ContainsKey(out string key, params string[] keys)
        {
            key = keys.FirstOrDefault(_data.ContainsKey);
            return key != null;
        }

        /// <summary>Returns <c>true</c> and sets <paramref name="value"/> to the raw string value of the first matching key, or <c>null</c> if not found.</summary>
        public bool TryGetValue(out string value, params string[] keys)
        {
            string key = keys.FirstOrDefault(_data.ContainsKey);
            value = key != null ? _data[key] : null;
            return key != null;
        }

        /// <summary>Returns the raw string value of the first matching key, or an empty string if not found.</summary>
        public string GetValue(params string[] keys)
        {
            string key = keys.FirstOrDefault(_data.ContainsKey);
            return key != null ? _data[key] : "";
        }

        /// <summary>Returns the numeric value of the first matching key. Returns <c>-1</c> for signed types or <c>0</c> for unsigned types when the key is not found or the value is unparseable.</summary>
        public T GetValue<T>(params string[] keys) where T : INumber<T>
        {
            string value = GetValue(keys);
            if (!string.IsNullOrEmpty(value) && T.TryParse(value, null, out T result))
                return result;
            return T.TryParse("-1", null, out T fallback) ? fallback : T.Zero;
        }

        internal object GetEntity(Type targetType)
            => Activator.CreateInstance(targetType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, [this], null);

        /// <summary>Deserializes this entry into a <see cref="TsEntity"/> of type <typeparamref name="T"/>.</summary>
        public T GetEntity<T>() where T : TsEntity
            => (T)Activator.CreateInstance(typeof(T), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, [this], null);

        /// <summary>Returns the Unix-timestamp field of the first matching key as a local <see cref="DateTime"/>.</summary>
        public DateTime GetDateTime(params string[] keys)
            => new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)
                .AddSeconds(GetValue<long>(keys))
                .ToLocalTime();

        /// <summary>Parses a TeamSpeak boolean string (<c>"0"</c> or <c>"1"</c>) into a <see cref="bool"/>.</summary>
        public static bool TryParseBool(string input, out bool value)
        {
            if (!TryParseNumber<int>(input, out var b))
            {
                value = false;
                return false;
            }

            value = b == 1;
            return true;
        }

        /// <summary>Parses a numeric string into a value of type <typeparamref name="T"/>.</summary>
        public static bool TryParseNumber<T>(string input, out T value) where T : INumber<T>
        {
            if (!T.TryParse(input, null, out var n))
            {
                value = default;
                return false;
            }

            value = n;
            return true;
        }

        /// <summary>Parses a millisecond-count string into a <see cref="TimeSpan"/> boxed as <c>object</c>.</summary>
        public static bool TryParseTimespan(string input, out object value)
        {
            if (!TryParseNumber<long>(input, out var ms))
            {
                value = default;
                return false;
            }

            value = TimeSpan.FromMilliseconds(ms);
            return true;
        }

        /// <summary>Parses a Unix-timestamp string into a local <see cref="DateTime"/> boxed as <c>object</c>.</summary>
        public static bool TryParseDatetime(string input, out object value)
        {
            if (!TryParseNumber<long>(input, out var seconds))
            {
                value = default;
                return false;
            }

            value = DateTimeOffset.FromUnixTimeSeconds(seconds).LocalDateTime;
            return true;
        }

        internal Dictionary<string, string> ToDictionary()
            => _data;

        internal void Merge(TsDataEntry incoming)
        {
            foreach (var kvp in incoming._data)
                _data[kvp.Key] = kvp.Value;
        }

        internal bool Inject(string key, string value)
        {
            if (!_data.TryGetValue(key, out var current) || !value.Equals(current))
            {
                _data[key] = value;
                return true;
            }
            return false;
        }
    }
}