#region CPL License
/*
Nuclex Framework
Copyright (C) 2002-2010 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#endregion

using System;
using System.Collections.Generic;

using Microsoft.Xna.Framework;

namespace Nuclex.UserInterface {

  /// <summary>Stores a two-dimensional position or size</summary>
  public struct UniVector {

    /// <summary>A vector that has been initialized to zero</summary>
    public static readonly UniVector Zero = new UniVector();

    /// <summary>Initializes a new vector from the provided components</summary>
    /// <param name="x">Absolute and relative X coordinate of the vector</param>
    /// <param name="y">Absolute and relative Y coordinate of the vector</param>
    public UniVector(UniScalar x, UniScalar y) {
      this.X = x;
      this.Y = y;
    }

    /// <summary>Converts the vector into pure offset coordinates</summary>
    /// <param name="containerSize">
    ///   Dimensions of the container the relative part of the vector counts for
    /// </param>
    /// <returns>An XNA vector with the pure offset coordinates of the vector</returns>
    public Vector2 ToOffset(Vector2 containerSize) {
      return ToOffset(containerSize.X, containerSize.Y);
    }

    /// <summary>Converts the vector into pure offset coordinates</summary>
    /// <param name="containerWidth">
    ///   Width of the container the fractional part of the vector counts for
    /// </param>
    /// <param name="containerHeight">
    ///   Height of the container the fractional part of the vector counts for
    /// </param>
    /// <returns>An XNA vector with the pure offset coordinates of the vector</returns>
    public Vector2 ToOffset(float containerWidth, float containerHeight) {
      return new Vector2(
        this.X.Fraction * containerWidth + this.X.Offset,
        this.Y.Fraction * containerHeight + this.Y.Offset
      );
    }

    /// <summary>Adds one vector to another</summary>
    /// <param name="vector">Base vector to add to</param>
    /// <param name="summand">Vector to add to the base</param>
    /// <returns>The result of the addition</returns>
    public static UniVector operator +(UniVector vector, UniVector summand) {
      return new UniVector(vector.X + summand.X, vector.Y + summand.Y);
    }

    /// <summary>Subtracts one vector from another</summary>
    /// <param name="vector">Base vector to subtract from</param>
    /// <param name="subtrahend">Vector to subtract from the base</param>
    /// <returns>The result of the subtraction</returns>
    public static UniVector operator -(UniVector vector, UniVector subtrahend) {
      return new UniVector(vector.X - subtrahend.X, vector.Y - subtrahend.Y);
    }

    /// <summary>Divides one vector by another</summary>
    /// <param name="vector">Base vector to be divided</param>
    /// <param name="divisor">Divisor to divide by</param>
    /// <returns>The result of the division</returns>
    public static UniVector operator /(UniVector vector, UniVector divisor) {
      return new UniVector(vector.X / divisor.X, vector.Y / divisor.Y);
    }

    /// <summary>Multiplies one vector with another</summary>
    /// <param name="vector">Base vector to be multiplied</param>
    /// <param name="factor">Factor to multiply by</param>
    /// <returns>The result of the multiplication</returns>
    public static UniVector operator *(UniVector vector, UniVector factor) {
      return new UniVector(vector.X * factor.X, vector.Y * factor.Y);
    }

    /// <summary>Scales a vector by a scalar factor</summary>
    /// <param name="factor">Factor by which to scale the vector</param>
    /// <param name="vector">Vector to be Scaled</param>
    /// <returns>The result of the multiplication</returns>
    public static UniVector operator *(UniScalar factor, UniVector vector) {
      return new UniVector(factor * vector.X, factor * vector.Y);
    }

    /// <summary>Scales a vector by a scalar factor</summary>
    /// <param name="vector">Vector to be Scaled</param>
    /// <param name="factor">Factor by which to scale the vector</param>
    /// <returns>The result of the multiplication</returns>
    public static UniVector operator *(UniVector vector, UniScalar factor) {
      return new UniVector(vector.X * factor, vector.Y * factor);
    }

    /// <summary>Checks two vectors for inequality</summary>
    /// <param name="first">First vector to be compared</param>
    /// <param name="second">Second vector to be compared</param>
    /// <returns>True if the instances differ or exactly one reference is set to null</returns>
    public static bool operator !=(UniVector first, UniVector second) {
      return !(first == second);
    }

    /// <summary>Checks two vectors for equality</summary>
    /// <param name="first">First vector to be compared</param>
    /// <param name="second">Second vector to be compared</param>
    /// <returns>True if both instances are equal or both references are null</returns>
    public static bool operator ==(UniVector first, UniVector second) {
      // For a struct, neither 'first' nor 'second' can be null
      return first.Equals(second);
    }

    /// <summary>Checks whether another instance is equal to this instance</summary>
    /// <param name="other">Other instance to compare to this instance</param>
    /// <returns>True if the other instance is equal to this instance</returns>
    public override bool Equals(object other) {
      if (!(other is UniVector))
        return false;

      return Equals((UniVector)other);
    }

    /// <summary>Checks whether another instance is equal to this instance</summary>
    /// <param name="other">Other instance to compare to this instance</param>
    /// <returns>True if the other instance is equal to this instance</returns>
    public bool Equals(UniVector other) {
      // For a struct, 'other' cannot be null
      return (this.X == other.X) && (this.Y == other.Y);
    }

    /// <summary>Obtains a hash code of this instance</summary>
    /// <returns>The hash code of the instance</returns>
    public override int GetHashCode() {
      return this.X.GetHashCode() ^ this.Y.GetHashCode();
    }

    /// <summary>
    ///   Returns a human-readable string representation for the unified vector
    /// </summary>
    /// <returns>The human-readable string representation of the unified vector</returns>
    public override string ToString() {
      return string.Format(
        "{{X:{0}, Y:{1}}}",
        this.X.ToString(),
        this.Y.ToString()
      );
    }

    /// <summary>The vector's X coordinate</summary>
    public UniScalar X;
    /// <summary>The vector's Y coordinate</summary>
    public UniScalar Y;

  }

} // namespace Nuclex.UserInterface