// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace System.Diagnostics
{
    internal sealed partial class DiagNode<T>
    {
        public DiagNode(T value) => Value = value;
        public T Value;
        public DiagNode<T>? Next;
    }

    // We are not using the public LinkedList<T> because we need to ensure thread safety operation on the list.
    internal sealed class DiagLinkedList<T> : IEnumerable<T>
    {
        private DiagNode<T>? _first;
        private DiagNode<T>? _last;

        public DiagLinkedList() { }

        public DiagLinkedList(T firstValue) => _last = _first = new DiagNode<T>(firstValue);

        public DiagLinkedList(IEnumerator<T> e)
        {
            Debug.Assert(e is not null);
            _last = _first = new DiagNode<T>(e.Current);

            while (e.MoveNext())
            {
                _last.Next = new DiagNode<T>(e.Current);
                _last = _last.Next;
            }
        }

        public DiagNode<T>? First => _first;

        public void Clear()
        {
            lock (this)
            {
                _first = _last = null;
            }
        }

        private void UnsafeAdd(DiagNode<T> newNode)
        {
            if (_first is null)
            {
                _first = _last = newNode;
                return;
            }

            Debug.Assert(_first is not null);
            Debug.Assert(_last is not null);

            _last!.Next = newNode;
            _last = newNode;
        }

        public void Add(T value)
        {
            DiagNode<T> newNode = new DiagNode<T>(value);

            lock (this)
            {
                UnsafeAdd(newNode);
            }
        }

        public bool AddIfNotExist(T value, Func<T, T, bool> compare)
        {
            lock (this)
            {
                DiagNode<T>? current = _first;
                while (current is not null)
                {
                    if (compare(value, current.Value))
                    {
                        return false;
                    }

                    current = current.Next;
                }

                DiagNode<T> newNode = new DiagNode<T>(value);
                UnsafeAdd(newNode);

                return true;
            }
        }

        public T? Remove(T value, Func<T, T, bool> compare)
        {
            lock (this)
            {
                DiagNode<T>? previous = _first;
                if (previous is null)
                {
                    return default;
                }

                if (compare(previous.Value, value))
                {
                    _first = previous.Next;
                    if (_first is null)
                    {
                        _last = null;
                    }
                    return previous.Value;
                }

                DiagNode<T>? current = previous.Next;

                while (current is not null)
                {
                    if (compare(current.Value, value))
                    {
                        previous.Next = current.Next;
                        if (object.ReferenceEquals(_last, current))
                        {
                            _last = previous;
                        }

                        return current.Value;
                    }

                    previous = current;
                    current = current.Next;
                }

                return default;
            }
        }

        public void AddFront(T value)
        {
            DiagNode<T> newNode = new DiagNode<T>(value);

            lock (this)
            {
                newNode.Next = _first;
                _first = newNode;
            }
        }

        public DiagEnumerator<T> GetEnumerator() => new DiagEnumerator<T>(_first);
        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        private static void ActivityLinkToString(ref ActivityLink al, ref ValueStringBuilder vsb)
        {
            ActivityContext ac = al.Context;

            vsb.Append("(");
            vsb.Append(ac.TraceId.ToHexString());
            vsb.Append(",\u200B");
            vsb.Append(ac.SpanId.ToHexString());
            vsb.Append(",\u200B");
            vsb.Append(ac.TraceFlags.ToString());
            vsb.Append(",\u200B");
            vsb.Append(ac.TraceState ?? "null");
            vsb.Append(",\u200B");
            vsb.Append(ac.IsRemote ? "true" : "false");

            if (al.Tags is not null)
            {
                vsb.Append(",\u200B[");
                string sep = "";
                foreach (KeyValuePair<string, object?> kvp in al.EnumerateTagObjects())
                {
                    vsb.Append(sep);
                    vsb.Append(kvp.Key);
                    vsb.Append(":\u200B");
                    vsb.Append(kvp.Value?.ToString() ?? "null");
                    sep = ",\u200B";
                }

                vsb.Append("]");
            }
            vsb.Append(")");
        }

        private static void ActivityEventToString(ref ActivityEvent ae, ref ValueStringBuilder vsb)
        {
            vsb.Append("(");
            vsb.Append(ae.Name);
            vsb.Append(",\u200B");
            vsb.Append(ae.Timestamp.ToString("o"));

            if (ae.Tags is not null)
            {
                vsb.Append(",\u200B[");
                string sep = "";
                foreach (KeyValuePair<string, object?> kvp in ae.EnumerateTagObjects())
                {
                    vsb.Append(sep);
                    vsb.Append(kvp.Key);
                    vsb.Append(":\u200B");
                    vsb.Append(kvp.Value?.ToString() ?? "null");
                    sep = ",\u200B";
                }

                vsb.Append("]");
            }
            vsb.Append(")");
        }

        public override string ToString()
        {
            lock (this)
            {
                DiagNode<T>? current = _first;
                if (current is null)
                {
                    return "[]";
                }

                var vsb = new ValueStringBuilder(stackalloc char[256]);
                vsb.Append("[");

                if (typeof(T) == typeof(ActivityLink))
                {
                    while (current is not null)
                    {
                        ActivityLink al = (ActivityLink)(object)current.Value!;
                        ActivityLinkToString(ref al, ref vsb);
                        current = current.Next;
                        if (current is not null)
                        {
                            vsb.Append(",\u200B");
                        }
                    }
                }
                else if (typeof(T) == typeof(ActivityEvent))
                {
                    while (current is not null)
                    {
                        ActivityEvent ae = (ActivityEvent)(object)current.Value!;
                        ActivityEventToString(ref ae, ref vsb);
                        current = current.Next;
                        if (current is not null)
                        {
                            vsb.Append(",\u200B");
                        }
                    }
                }
                else
                {
                    while (current is not null)
                    {
                        vsb.Append(current.Value?.ToString() ?? "null");
                        current = current.Next;
                        if (current is not null)
                        {
                            vsb.Append(",\u200B");
                        }
                    }
                }

                vsb.Append("]");
                return vsb.ToString();
            }
        }
    }

    internal struct DiagEnumerator<T> : IEnumerator<T>
    {
        private static readonly DiagNode<T> s_Empty = new DiagNode<T>(default!);

        private DiagNode<T>? _nextNode;
        private DiagNode<T> _currentNode;

        public DiagEnumerator(DiagNode<T>? head)
        {
            _nextNode = head;
            _currentNode = s_Empty;
        }

        public T Current => _currentNode.Value;

        object? IEnumerator.Current => Current;

        public bool MoveNext()
        {
            if (_nextNode == null)
            {
                _currentNode = s_Empty;
                return false;
            }

            _currentNode = _nextNode;
            _nextNode = _nextNode.Next;
            return true;
        }

        public void Reset() => throw new NotSupportedException();

        public void Dispose()
        {
        }
    }
}