using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace axXez.TS3.Protocol
{
    /// <summary>Parsed TeamSpeak text-protocol message — includes the command name and all key-value entries.</summary>
    public class TsMessage
    {
        /// <summary>The command or notification name (e.g. <c>"clientlist"</c>, <c>"notifyclientmoved"</c>).</summary>
        public string Name { get; set; }

        /// <summary>All parsed key-value entry sets. Multiple entries are separated by <c>|</c> in the raw data.</summary>
        public List<TsDataEntry> Entries { get; set; }

        /// <summary>The raw message string, before parsing.</summary>
        public string RawData { get; private set; }

        /// <summary>Whether the message contains at least one data entry.</summary>
        public bool HasData => Entries?.Count > 0;
        /// <summary>Number of entries in the message.</summary>
        public int Count => Entries?.Count ?? 0;

        /// <summary>Shorthand for the first entry. <c>null</c> if <see cref="HasData"/> is <c>false</c>.</summary>
        public TsDataEntry Params => HasData ? Entries[0] : null;

        /// <summary>Returns the entry at the given index.</summary>
        public TsDataEntry this[int index] => Entries[index];
        /// <summary>Returns the value of the given key from the first entry, or <c>null</c> if there is no data.</summary>
        public string this[string key] => HasData ? Entries[0][key] : null;

        internal TsMessage() { }

        internal TsMessage(string name, string data)
        {
            Name = name;
            RawData = data;
            ParseEntries(data);
        }

        /// <summary>Parses a raw TeamSpeak text-protocol string into a <see cref="TsMessage"/>.</summary>
        public static TsMessage Parse(string raw)
        {
            var parts = raw.Split('|');
            var first = parts[0].Trim();
            int nameEnd = first.IndexOf(' ');
            var name = nameEnd >= 0 ? first[..nameEnd] : first;

            var entries = new List<TsDataEntry>();
            foreach (var part in parts)
                entries.Add(TsDataEntry.Parse(part));

            return new TsMessage { Name = name, RawData = raw, Entries = entries };
        }

        private void ParseEntries(string data)
        {
            if (string.IsNullOrWhiteSpace(data))
            {
                Entries = null;
                return;
            }

            Entries = new();
            foreach (var part in data.Split('|'))
                Entries.Add(TsDataEntry.Parse(part));
        }

        /// <summary>Returns the value of the first matching key from the first entry, or an empty string if not found.</summary>
        public string Get(params string[] keys)
            => HasData ? Entries[0].GetValue(keys) : "";

        /// <summary>Returns the numeric value of the first matching key from the first entry, or the type's default if not found.</summary>
        public T Get<T>(params string[] keys) where T : INumber<T>
            => HasData ? Entries[0].GetValue<T>(keys) : default;

        /// <summary>Deserializes the first entry into a <see cref="TsEntity"/> of type <typeparamref name="T"/>.</summary>
        public T Get<T>() where T : TsEntity
            => HasData ? Entries[0].GetEntity<T>() : default;

        /// <summary>Returns the Unix-timestamp field from the first entry as a <see cref="DateTime"/>.</summary>
        public DateTime GetDateTime(params string[] keys)
            => HasData ? Entries[0].GetDateTime(keys) : default;

        /// <summary>Returns the value of the first matching key from every entry.</summary>
        public List<string> GetAll(params string[] keys)
            => HasData ? Entries.Select(x => x.GetValue(keys)).ToList() : [];

        /// <summary>Returns the numeric value of the first matching key from every entry.</summary>
        public List<T> GetAll<T>(params string[] keys) where T : INumber<T>
            => HasData ? Entries.Select(x => x.GetValue<T>(keys)).ToList() : [];

        /// <summary>Deserializes every entry into a <see cref="TsEntity"/> of type <typeparamref name="T"/>.</summary>
        public List<T> GetAll<T>() where T : TsEntity
            => HasData ? Entries.Select(x => x.GetEntity<T>()).ToList() : [];

        internal Dictionary<string, string> ToDictionary()
            => HasData ? Entries[0].ToDictionary() : new();

        internal List<Dictionary<string, string>> ToDictionaryList()
            => HasData ? Entries.Select(e => e.ToDictionary()).ToList() : new();
    }
}