namespace ScreenConnect;

public static class Tuple
{
	public static Tuple<T, U> Create<T, U>(T item1, U item2)
	{
		return new Tuple<T, U>
		{
			Item1 = item1,
			Item2 = item2
		};
	}

	public static Tuple<T, U, V> Create<T, U, V>(T item1, U item2, V item3)
	{
		return new Tuple<T, U, V>
		{
			Item1 = item1,
			Item2 = item2,
			Item3 = item3
		};
	}

	public static Tuple<T, U, V, W> Create<T, U, V, W>(T item1, U item2, V item3, W item4)
	{
		return new Tuple<T, U, V, W>
		{
			Item1 = item1,
			Item2 = item2,
			Item3 = item3,
			Item4 = item4
		};
	}
}
public struct Tuple<T, U>
{
	public T Item1 { get; internal set; }

	public U Item2 { get; internal set; }

	public Tuple<T, U, V> With<V>(V withItem)
	{
		return Tuple.Create(Item1, Item2, withItem);
	}

	public Tuple<T, U, V, W> With<V, W>(V withItem1, W withItem2)
	{
		return Tuple.Create(Item1, Item2, withItem1, withItem2);
	}

	public Tuple<T, U, V, W> With<V, W>(Tuple<V, W> withItem)
	{
		return Tuple.Create(Item1, Item2, withItem.Item1, withItem.Item2);
	}

	public Tuple<T, NewU> Swap2<NewU>(NewU newItem)
	{
		return Tuple.Create(Item1, newItem);
	}

	public static bool operator ==(Tuple<T, U> left, Tuple<T, U> right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(Tuple<T, U> left, Tuple<T, U> right)
	{
		return !left.Equals(right);
	}

	public override int GetHashCode()
	{
		return HashCode.Seed.And(Item1).And(Item2);
	}

	public override bool Equals(object obj)
	{
		if (!(obj is Tuple<T, U> tuple))
		{
			return false;
		}
		if (object.Equals(Item1, tuple.Item1))
		{
			return object.Equals(Item2, tuple.Item2);
		}
		return false;
	}

	public override string ToString()
	{
		return $"Tuple[{Item1}, {Item2}]";
	}
}
public struct Tuple<T, U, V>
{
	public T Item1 { get; internal set; }

	public U Item2 { get; internal set; }

	public V Item3 { get; internal set; }

	public Tuple<T, U, V, W> With<W>(W withItem)
	{
		return Tuple.Create(Item1, Item2, Item3, withItem);
	}

	public static bool operator ==(Tuple<T, U, V> left, Tuple<T, U, V> right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(Tuple<T, U, V> left, Tuple<T, U, V> right)
	{
		return !left.Equals(right);
	}

	public override int GetHashCode()
	{
		return HashCode.Seed.And(Item1).And(Item2).And(Item3);
	}

	public override bool Equals(object obj)
	{
		if (!(obj is Tuple<T, U, V> tuple))
		{
			return false;
		}
		if (object.Equals(Item1, tuple.Item1) && object.Equals(Item2, tuple.Item2))
		{
			return object.Equals(Item3, tuple.Item3);
		}
		return false;
	}

	public override string ToString()
	{
		return $"Tuple[{Item1}, {Item2}, {Item3}]";
	}
}
public struct Tuple<T, U, V, W>
{
	public T Item1 { get; internal set; }

	public U Item2 { get; internal set; }

	public V Item3 { get; internal set; }

	public W Item4 { get; internal set; }

	public static bool operator ==(Tuple<T, U, V, W> left, Tuple<T, U, V, W> right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(Tuple<T, U, V, W> left, Tuple<T, U, V, W> right)
	{
		return !left.Equals(right);
	}

	public override int GetHashCode()
	{
		return HashCode.Seed.And(Item1).And(Item2).And(Item3)
			.And(Item4);
	}

	public override bool Equals(object obj)
	{
		if (!(obj is Tuple<T, U, V, W> tuple))
		{
			return false;
		}
		if (object.Equals(Item1, tuple.Item1) && object.Equals(Item2, tuple.Item2) && object.Equals(Item3, tuple.Item3))
		{
			return object.Equals(Item4, tuple.Item4);
		}
		return false;
	}

	public override string ToString()
	{
		return string.Format("Tuple[{0}, {1}, {2}, {3}]", new object[4] { Item1, Item2, Item3, Item4 });
	}
}