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

namespace UVC.Extention
{
    /// <summary>
    /// 키의 순서가 보장되는 스레드 안전한 제네릭 컬렉션을 나타냅니다.
    /// 항목이 추가된 순서대로 유지되며, 인덱스를 통해 접근할 수 있습니다.
    /// </summary>
    /// <typeparam name="TKey">사전의 키 형식입니다.</typeparam>
    /// <typeparam name="TValue">사전의 값 형식입니다.</typeparam>
    /// <example>
    /// 다음은 OrderedDictionary의 사용 예제입니다.
    /// <code>
    /// // OrderedDictionary 인스턴스 생성
    /// var cityPopulation = new OrderedDictionary<string, int>();
    ///
    /// // 데이터 추가 (순서대로 추가됨)
    /// cityPopulation.Add("서울", 9700000);
    /// cityPopulation.Add("부산", 3400000);
    /// cityPopulation.Add("인천", 3000000);
    ///
    /// // 키를 이용한 값 접근
    /// Console.WriteLine($"서울 인구: {cityPopulation["서울"]}"); // 출력: 서울 인구: 9700000
    ///
    /// // 인덱스를 이용한 값 접근 (순서 보장)
    /// Console.WriteLine($"첫 번째 추가된 도시의 인구: {cityPopulation.GetValueAt(0)}"); // 출력: 첫 번째 추가된 도시의 인구: 9700000
    ///
    /// // 특정 위치에 데이터 삽입
    /// cityPopulation.Insert(1, "대구", 2400000); // "부산" 앞에 "대구" 삽입
    ///
    /// // 추가된 순서대로 반복
    /// Console.WriteLine("\n현재 도시 목록 (순서 보장):");
    /// foreach(var city in cityPopulation)
    /// {
    ///     Console.WriteLine($"- {city.Key}: {city.Value}");
    /// }
    /// // 출력:
    /// // - 서울: 9700000
    /// // - 대구: 2400000
    /// // - 부산: 3400000
    /// // - 인천: 3000000
    ///
    /// // 항목 삭제
    /// cityPopulation.Remove("부산");
    ///
    /// Console.WriteLine("\n'부산' 삭제 후 도시 목록:");
    /// foreach(var city in cityPopulation)
    /// {
    ///     Console.WriteLine($"- {city.Key}: {city.Value}");
    /// }
    /// </code>
    /// </example>
    public partial class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private readonly object _lock = new object();
        private readonly Dictionary<TKey, TValue> _dict;
        private readonly List<TKey> _keys;

        #region Constructors

        /// <summary>
        /// 비어 있고 기본 초기 용량을 가지며 키 형식에 대한 기본 같음 비교자를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        public OrderedDictionary()
        {
            _dict = new Dictionary<TKey, TValue>();
            _keys = new List<TKey>();
        }

        /// <summary>
        /// 비어 있고 기본 초기 용량을 가지며 지정된 <see cref="IEqualityComparer{TKey}"/>를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        /// <param name="comparer">키를 비교할 때 사용할 <see cref="IEqualityComparer{TKey}"/> 구현 또는 키 형식에 대한 기본 <see cref="EqualityComparer{TKey}"/>를 사용하려면 null입니다.</param>
        public OrderedDictionary(IEqualityComparer<TKey> comparer)
        {
            _dict = new Dictionary<TKey, TValue>(comparer);
            _keys = new List<TKey>();
        }

        /// <summary>
        /// 비어 있고 지정된 초기 용량을 가지며 키 형식에 대한 기본 같음 비교자를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        /// <param name="capacity"><see cref="OrderedDictionary{TKey, TValue}"/>가 초기에 포함할 수 있는 요소의 수입니다.</param>
        public OrderedDictionary(int capacity)
        {
            _dict = new Dictionary<TKey, TValue>(capacity);
            _keys = new List<TKey>(capacity);
        }

        /// <summary>
        /// 비어 있고 지정된 초기 용량을 가지며 지정된 <see cref="IEqualityComparer{TKey}"/>를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        /// <param name="capacity"><see cref="OrderedDictionary{TKey, TValue}"/>가 초기에 포함할 수 있는 요소의 수입니다.</param>
        /// <param name="comparer">키를 비교할 때 사용할 <see cref="IEqualityComparer{TKey}"/> 구현 또는 키 형식에 대한 기본 <see cref="EqualityComparer{TKey}"/>를 사용하려면 null입니다.</param>
        public OrderedDictionary(int capacity, IEqualityComparer<TKey> comparer)
        {
            _dict = new Dictionary<TKey, TValue>(capacity, comparer);
            _keys = new List<TKey>(capacity);
        }

        /// <summary>
        /// 지정된 <see cref="IDictionary{TKey, TValue}"/>에서 복사한 요소를 포함하고 키 형식에 대한 기본 같음 비교자를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        /// <param name="dictionary">요소가 새 <see cref="OrderedDictionary{TKey, TValue}"/>에 복사되는 <see cref="IDictionary{TKey, TValue}"/>입니다.</param>
        public OrderedDictionary(IDictionary<TKey, TValue> dictionary)
        {
            _dict = new Dictionary<TKey, TValue>(dictionary);
            _keys = new List<TKey>(dictionary.Keys);
        }

        /// <summary>
        /// 지정된 <see cref="IDictionary{TKey, TValue}"/>에서 복사한 요소를 포함하고 지정된 <see cref="IEqualityComparer{TKey}"/>를 사용하는 <see cref="OrderedDictionary{TKey, TValue}"/> 클래스의 새 인스턴스를 초기화합니다.
        /// </summary>
        /// <param name="dictionary">요소가 새 <see cref="OrderedDictionary{TKey, TValue}"/>에 복사되는 <see cref="IDictionary{TKey, TValue}"/>입니다.</param>
        /// <param name="comparer">키를 비교할 때 사용할 <see cref="IEqualityComparer{TKey}"/> 구현 또는 키 형식에 대한 기본 <see cref="EqualityComparer{TKey}"/>를 사용하려면 null입니다.</param>
        public OrderedDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
        {
            _dict = new Dictionary<TKey, TValue>(dictionary, comparer);
            _keys = new List<TKey>(dictionary.Keys);
        }

        #endregion

        #region IDictionary<TKey, TValue> Members

        /// <summary>
        /// 사전에 지정된 키와 값을 추가합니다.
        /// </summary>
        /// <param name="key">추가할 요소의 키입니다.</param>
        /// <param name="value">추가할 요소의 값입니다.</param>
        public void Add(TKey key, TValue value)
        {
            lock (_lock)
            {
                if (_dict.ContainsKey(key))
                    throw new ArgumentException("이미 존재하는 키입니다.");
                _keys.Add(key);
                _dict.Add(key, value);
            }
        }

        /// <summary>
        /// 사전에 지정된 키가 포함되어 있는지 확인합니다.
        /// </summary>
        /// <param name="key">찾을 키입니다.</param>
        /// <returns>사전에 지정된 키를 가진 요소가 있으면 true이고, 그렇지 않으면 false입니다.</returns>
        public bool ContainsKey(TKey key)
        {
            lock (_lock)
            {
                return _dict.ContainsKey(key);
            }
        }

        /// <summary>
        /// 사전의 키를 순서대로 포함하는 컬렉션을 가져옵니다.
        /// </summary>
        public ICollection<TKey> Keys
        {
            get
            {
                lock (_lock)
                {
                    return _keys.AsReadOnly();
                }
            }
        }

        /// <summary>
        /// 사전에서 지정된 키를 가진 요소를 제거합니다.
        /// <para>참고: 이 작업은 내부 리스트에서 키를 찾아 제거하므로 O(n)의 시간 복잡도를 가질 수 있습니다.</para>
        /// </summary>
        /// <param name="key">제거할 요소의 키입니다.</param>
        /// <returns>요소를 성공적으로 찾아 제거했으면 true이고, 그렇지 않으면 false입니다.</returns>
        public bool Remove(TKey key)
        {
            lock (_lock)
            {
                if (_dict.Remove(key))
                {
                    _keys.Remove(key);
                    return true;
                }
                return false;
            }
        }

        /// <summary>
        /// 지정된 키와 연결된 값을 가져옵니다.
        /// </summary>
        /// <param name="key">가져올 값의 키입니다.</param>
        /// <param name="value">이 메서드가 반환될 때, 키가 있으면 해당 키와 연결된 값을 포함하고, 그렇지 않으면 value 매개 변수의 형식에 대한 기본값을 포함합니다.</param>
        /// <returns>사전에 지정된 키를 가진 요소가 있으면 true이고, 그렇지 않으면 false입니다.</returns>
        public bool TryGetValue(TKey key, out TValue value)
        {
            lock (_lock)
            {
                return _dict.TryGetValue(key, out value);
            }
        }

        /// <summary>
        /// 사전의 값을 순서대로 포함하는 컬렉션을 가져옵니다.
        /// </summary>
        public ICollection<TValue> Values
        {
            get
            {
                lock (_lock)
                {
                    // ToList()를 호출하여 즉시 평가된 읽기 전용 컬렉션을 반환합니다.
                    // 이는 스레드 안정성을 위해 중요합니다.
                    return _keys.Select(key => _dict[key]).ToList().AsReadOnly();
                }
            }
        }


        /// <summary>
        /// 지정된 키와 연결된 값을 가져오거나 설정합니다.
        /// </summary>
        /// <param name="key">가져오거나 설정할 요소의 키입니다.</param>
        /// <returns>지정된 키와 연결된 값입니다.</returns>
        public TValue this[TKey key]
        {
            get
            {
                lock (_lock)
                {
                    return _dict[key];
                }
            }
            set
            {
                lock (_lock)
                {
                    if (!_dict.ContainsKey(key))
                    {
                        _keys.Add(key);
                    }
                    _dict[key] = value;
                }
            }
        }

        #endregion

        #region ICollection<KeyValuePair<TKey, TValue>> Members

        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
        {
            Add(item.Key, item.Value);
        }

        /// <summary>
        /// 사전에서 모든 키와 값을 제거합니다.
        /// </summary>
        public void Clear()
        {
            lock (_lock)
            {
                _dict.Clear();
                _keys.Clear();
            }
        }

        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
        {
            lock (_lock)
            {
                return ((ICollection<KeyValuePair<TKey, TValue>>)_dict).Contains(item);
            }
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            lock (_lock)
            {
                if (array == null) throw new ArgumentNullException(nameof(array));
                if (arrayIndex < 0) throw new ArgumentOutOfRangeException(nameof(arrayIndex));
                if (array.Length - arrayIndex < Count) throw new ArgumentException("대상 배열이 충분히 크지 않습니다.");

                foreach (var key in _keys)
                {
                    array[arrayIndex++] = new KeyValuePair<TKey, TValue>(key, _dict[key]);
                }
            }
        }

        /// <summary>
        /// 사전에 포함된 키/값 쌍의 수를 가져옵니다.
        /// </summary>
        public int Count
        {
            get
            {
                lock (_lock)
                {
                    return _dict.Count;
                }
            }
        }


        /// <summary>
        /// 사전이 읽기 전용인지 여부를 나타내는 값을 가져옵니다.
        /// </summary>
        public bool IsReadOnly => false;

        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
        {
            lock (_lock)
            {
                if (((ICollection<KeyValuePair<TKey, TValue>>)_dict).Contains(item))
                {
                    return Remove(item.Key);
                }
                return false;
            }
        }

        #endregion

        #region IEnumerable<KeyValuePair<TKey, TValue>> Members

        /// <summary>
        /// 사전을 반복하는 열거자를 반환합니다.
        /// <para>주의: 열거가 진행되는 동안 컬렉션이 다른 스레드에서 수정되면 예외가 발생할 수 있습니다. 스레드 안전한 열거를 위해서는 컬렉션을 복사하거나 lock을 사용해야 합니다.</para>
        /// </summary>
        /// <returns>사전을 반복하는 데 사용할 수 있는 <see cref="IEnumerator{T}"/>입니다.</returns>
        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            // GetEnumerator는 스레드 안정성을 위해 컬렉션의 복사본을 만들어 순회하는 것이 일반적입니다.
            List<KeyValuePair<TKey, TValue>> listCopy;
            lock (_lock)
            {
                listCopy = new List<KeyValuePair<TKey, TValue>>(Count);
                foreach (var key in _keys)
                {
                    listCopy.Add(new KeyValuePair<TKey, TValue>(key, _dict[key]));
                }
            }
            return listCopy.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        #region OrderedDictionary Specific Members

        /// <summary>
        /// 사전의 지정된 인덱스에 키/값 쌍을 삽입합니다.
        /// <para>참고: 이 작업은 내부 리스트에 요소를 삽입하므로 O(n)의 시간 복잡도를 가질 수 있습니다.</para>
        /// </summary>
        /// <param name="index">키/값 쌍을 삽입할 인덱스(0부터 시작)입니다.</param>
        /// <param name="key">삽입할 요소의 키입니다.</param>
        /// <param name="value">삽입할 요소의 값입니다.</param>
        public void Insert(int index, TKey key, TValue value)
        {
            lock (_lock)
            {
                if (_dict.ContainsKey(key))
                    throw new ArgumentException("이미 존재하는 키입니다.");
                _keys.Insert(index, key);
                _dict.Add(key, value);
            }
        }

        /// <summary>
        /// 사전의 지정된 인덱스에 있는 요소를 제거합니다.
        /// <para>참고: 이 작업은 내부 리스트에서 요소를 제거하므로 O(n)의 시간 복잡도를 가질 수 있습니다.</para>
        /// </summary>
        /// <param name="index">제거할 요소의 인덱스(0부터 시작)입니다.</param>
        public void RemoveAt(int index)
        {
            lock (_lock)
            {
                if (index < 0 || index >= _keys.Count)
                    throw new ArgumentOutOfRangeException(nameof(index));

                TKey key = _keys[index];
                _keys.RemoveAt(index);
                _dict.Remove(key);
            }
        }

        /// <summary>
        /// 지정된 인덱스의 값을 가져옵니다.
        /// </summary>
        /// <param name="index">가져올 값의 인덱스</param>
        /// <returns>지정된 인덱스에 있는 항목의 값</returns>
        public TValue GetValueAt(int index)
        {
            lock (_lock)
            {
                return _dict[_keys[index]];
            }
        }

        #endregion
    }
}