using System.Linq;

namespace System.Collections.Generic;

public class HashSet<T> : IEnumerable<T>, IEnumerable where T : notnull
{
	private Dictionary<T, object?> hashTable;

	public int Count => hashTable.Count;

	public bool IsReadOnly => false;

	public HashSet(IEqualityComparer<T>? equalityComparer = null)
	{
		hashTable = new Dictionary<T, object>(equalityComparer);
	}

	public HashSet(IEnumerable<T>? items, IEqualityComparer<T>? equalityComparer = null)
		: this(equalityComparer)
	{
		if (items == null)
		{
			return;
		}
		foreach (T item in items)
		{
			Add(item);
		}
	}

	public bool Add(T item)
	{
		int count = hashTable.Count;
		hashTable[item] = null;
		return count != hashTable.Count;
	}

	public void Clear()
	{
		hashTable.Clear();
	}

	public bool Contains(T item)
	{
		return hashTable.ContainsKey(item);
	}

	public IEnumerable<T> Except(HashSet<T> otherSet)
	{
		return this.Where((T it) => !otherSet.Contains(it));
	}

	public bool IntersectsWith(IEnumerable<T> items)
	{
		foreach (T item in items)
		{
			if (Contains(item))
			{
				return true;
			}
		}
		return false;
	}

	public void CopyTo(T[] array, int arrayIndex)
	{
		hashTable.Keys.CopyTo(array, arrayIndex);
	}

	public bool Remove(T item)
	{
		return hashTable.Remove(item);
	}

	public IEnumerator<T> GetEnumerator()
	{
		return hashTable.Keys.GetEnumerator();
	}

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