using UnityEngine;

[System.Serializable]
public class Vector3i
{
	public int x = 0, y = 0, z = 0;
	public static readonly Vector3i zero = new Vector3i(0, 0, 0);
	public static readonly Vector3i one = new Vector3i(1, 1, 1);
	public static readonly Vector3i forward = new Vector3i(0, 0, 1);
	public static readonly Vector3i back = new Vector3i(0, 0, -1);
	public static readonly Vector3i up = new Vector3i(0, 1, 0);
	public static readonly Vector3i down = new Vector3i(0, -1, 0);
	public static readonly Vector3i left = new Vector3i(-1, 0, 0);
	public static readonly Vector3i right = new Vector3i(1, 0, 0);


	public Vector3i()
	{
	}

	
	public Vector3i(int x, int y, int z)
	{
		this.x = x;
		this.y = y;
		this.z = z;
	}


	public Vector3i(int x, int y)
	{
		this.x = x;
		this.y = y;
	}


	public Vector3i(Vector3i a)
	{
		this.x = a.x;
		this.y = a.y;
		this.z = a.z;
	}


	public Vector3i(Vector3 a)
	{
		this.x = (int)a.x;
		this.y = (int)a.y;
		this.z = (int)a.z;
	}


	public int this[int key]
	{
		get
		{
			switch(key)
			{
				case 0:
				{
					return x;
				}
				case 1:
				{
					return y;
				}
				case 2:
				{
					return z;
				}
				default:
				{
					Debug.LogError("Invalid Vector3i index value of: " + key);
					return 0;
				}
			}
		}
		set
		{
			switch(key)
			{
				case 0:
				{
					x = value;
					return;
				}
				case 1:
				{
					y = value;
					return;
				}
				case 2:
				{
					z = value;
					return;
				}
				default:
				{
					Debug.LogError("Invalid Vector3i index value of: " + key);
					return;
				}
			}
		}
	}


	public static Vector3i Scale(Vector3i a, Vector3i b)
	{
		return new Vector3i(a.x * b.x, a.y * b.y, a.z * b.z);
	}


	public static int DistanceSquared(Vector3i a, Vector3i b)
	{
		int dx = b.x - a.x;
		int dy = b.y - a.y;
		int dz = b.z - a.z;
		return dx * dx + dy * dy + dz * dz;
	}

	
	public int DistanceSquared(Vector3i v)
	{
		return DistanceSquared(this, v);
	}

	
	public override int GetHashCode()
	{
		return x.GetHashCode() ^ y.GetHashCode() << 2 ^ z.GetHashCode() >> 2;
	}

	
	public override bool Equals(object other)
	{
		if(!(other is Vector3i))
		{
			return false;
		}
		Vector3i vector = (Vector3i)other;
		return x == vector.x && 
			   y == vector.y && 
			   z == vector.z;
	}

	
	public override string ToString()
	{
		return string.Format("Vector3i({0} {1} {2})", x, y, z);
	}

	
	public static bool operator ==(Vector3i a, Vector3i b)
	{
		return a.x == b.x &&
			   a.y == b.y && 
			   a.z == b.z;
	}

	
	public static bool operator !=(Vector3i a, Vector3i b)
	{
		return a.x != b.x || 
			   a.y != b.y ||
			   a.z != b.z;
	}

	
	public static Vector3i operator -(Vector3i a, Vector3i b)
	{
		return new Vector3i(a.x - b.x, a.y - b.y, a.z - b.z);
	}

	
	public static Vector3i operator +(Vector3i a, Vector3i b)
	{
		return new Vector3i(a.x + b.x, a.y + b.y, a.z + b.z);
	}


	public static Vector3i operator *(Vector3i a, int d)
	{
		return new Vector3i(a.x * d, a.y * d, a.z * d);
	}


	public static Vector3i operator *(int d, Vector3i a)
	{
		return new Vector3i(a.x * d, a.y * d, a.z * d);
	}

	
	public static explicit operator Vector3(Vector3i v)
	{
		return new Vector3(v.x, v.y, v.z);
	}

	public static explicit operator Vector3i(Vector3 v)
	{
		return new Vector3i(v);
	}


	public static Vector3i Min(Vector3i lhs, Vector3i rhs)
	{
		return new Vector3i(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z));
	}


	public static Vector3i Max(Vector3i lhs, Vector3i rhs)
	{
		return new Vector3i(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z));
	}


	public static Vector3i Clamp(Vector3i value, Vector3i min, Vector3i max)
	{
		return new Vector3i(Mathf.Clamp(value.x, min.x, max.x), Mathf.Clamp(value.y, min.y, max.y), Mathf.Clamp(value.z, min.z, max.z));
	}
}