using Chernobyl.Mathematics.Movement;

namespace Chernobyl.Mathematics.Geometry
{
    /// <summary>
    /// A class whose <see cref="IShape"/> implementation is defined by another
    /// <see cref="IShape"/> instance. This class allows for easier creation of
    /// <see cref="IShape"/> types that need to use other <see cref="IShape"/>
    /// implementations or for classes that need to dynamically alter their
    /// implementation at runtime. This is an implementation of the decorator
    /// pattern (http://en.wikipedia.org/wiki/Decorator_pattern).
    /// </summary>
    public abstract class ShapeDecorator : TransformDecorator, IShape
    {
        /// <summary>
        /// The largest width of the object in the object's X axis. This should
        /// be the world width and not the local width.
        /// </summary>
        public float Width
        {
            get { return DecoratedShape.Width; }
        }

        /// <summary>
        /// The largest height of the object in the object's Y axis. This should
        /// be the world height and not the local height
        /// </summary>
        public float Height
        {
            get { return DecoratedShape.Height; }
        }

        /// <summary>
        /// The largest depth of the object in the object's Z axis. If the depth
        /// is zero, the object is 2D. This should be the world depth and not
        /// the local depth.
        /// </summary>
        public float Depth
        {
            get { return DecoratedShape.Depth; }
        }

        /// <summary>
        /// True if this <see cref="IShape"/> is convex, false if it is concave
        /// or has 0 <see cref="Dimensions"/> (such as a point). A
        /// <see cref="IShape"/> is convex if for every pair of points within
        /// the object, every point on the straight line segment that joins them
        /// is also within the object. A concave <see cref="IShape"/> is the
        /// opposite of this.
        /// </summary>
        public bool IsConvex
        {
            get { return DecoratedShape.IsConvex; }
        }

        /// <summary>
        /// The amount of space taken up by an object on a flat plane in
        /// square metres (m^2).
        /// </summary>
        public float Area
        {
            get { return DecoratedShape.Area; }
        }

        /// <summary>
        /// The amount of 3D space this object consumes in cubic metres (m^3).
        /// If this object is 2D, then the value of this property is zero.
        /// </summary>
        public float Volume
        {
            get { return DecoratedShape.Volume; }
        }

        /// <summary>
        /// The length of the path that surrounds a shape specified in metres (m).
        /// In the case of a closed curve such as a circle, this value represents
        /// the circumference of the object.
        /// </summary>
        public float Perimeter
        {
            get { return DecoratedShape.Perimeter; }
        }

        /// <summary>
        /// The minimum number of coordinates needed to specify each point
        /// within this object. For example: a point has 0 dimensions, a
        /// line has 1 dimension, a circle or rectangle has 2 dimensions, a
        /// cube or sphere has 3 dimensions, and a moving cube or sphere has 4.
        /// </summary>
        public uint Dimensions
        {
            get { return DecoratedShape.Dimensions; }
        }

        /// <summary>
        /// The <see cref="IShape"/> instance that implements the
        /// <see cref="IShape"/> functionality.
        /// </summary>
        protected abstract IShape DecoratedShape { get; }
    }
}