using System;
using Csla.Properties;

namespace Csla
{

  /// <summary>
  /// Provides a date data type that understands the concept
  /// of an empty date value.
  /// </summary>
  /// <remarks>
  /// See Chapter 5 for a full discussion of the need for this
  /// data type and the design choices behind it.
  /// </remarks>
  [Serializable()]
  public struct SmartDate : IComparable
  {
    private DateTime _date;
    private bool _initialized;
    private EmptyValue _emptyValue;
    private string _format;
    private static string _defaultFormat;

    #region EmptyValue enum

    /// <summary>
    /// Indicates the empty value of a
    /// SmartDate.
    /// </summary>
    public enum EmptyValue
    {
      /// <summary>
      /// Indicates that an empty SmartDate
      /// is the smallest date.
      /// </summary>
      MinDate,
      /// <summary>
      /// Indicates that an empty SmartDate
      /// is the largest date.
      /// </summary>
      MaxDate
    }

    #endregion

    #region Constructors

    static SmartDate()
    {
      _defaultFormat = "d";
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      // provide a dummy value to allow real initialization
      _date = DateTime.MinValue;
      SetEmptyDate(_emptyValue);
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="emptyValue">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      // provide a dummy value to allow real initialization
      _date = DateTime.MinValue;
      SetEmptyDate(_emptyValue);
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <remarks>
    /// The SmartDate created will use the min possible
    /// date to represent an empty date.
    /// </remarks>
    /// <param name="value">The initial value of the object.</param>
    public SmartDate(DateTime value)
    {
      _emptyValue = Csla.SmartDate.EmptyValue.MinDate;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="value">The initial value of the object.</param>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(DateTime value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="value">The initial value of the object.</param>
    /// <param name="emptyValue">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(DateTime value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <remarks>
    /// The SmartDate created will use the min possible
    /// date to represent an empty date.
    /// </remarks>
    /// <param name="value">The initial value of the object (as text).</param>
    public SmartDate(string value)
    {
      _emptyValue = EmptyValue.MinDate;
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="value">The initial value of the object (as text).</param>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(string value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }

    /// <summary>
    /// Creates a new SmartDate object.
    /// </summary>
    /// <param name="value">The initial value of the object (as text).</param>
    /// <param name="emptyValue">Indicates whether an empty date is the min or max date value.</param>
    public SmartDate(string value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }

    private static EmptyValue GetEmptyValue(bool emptyIsMin)
    {
      if (emptyIsMin)
        return EmptyValue.MinDate;
      else
        return EmptyValue.MaxDate;
    }

    private void SetEmptyDate(EmptyValue emptyValue)
    {
      if (emptyValue == SmartDate.EmptyValue.MinDate)
        this.Date = DateTime.MinValue;
      else
        this.Date = DateTime.MaxValue;
    }

    #endregion

    #region Text Support

    /// <summary>
    /// Sets the global default format string used by all new
    /// SmartDate values going forward.
    /// </summary>
    /// <remarks>
    /// The default global format string is "d" unless this
    /// method is called to change that value. Existing SmartDate
    /// values are unaffected by this method, only SmartDate
    /// values created after calling this method are affected.
    /// </remarks>
    /// <param name="formatString">
    /// The format string should follow the requirements for the
    /// .NET System.String.Format statement.
    /// </param>
    public static void SetDefaultFormatString(string formatString)
    {
      _defaultFormat = formatString;
    }

    /// <summary>
    /// Gets or sets the format string used to format a date
    /// value when it is returned as text.
    /// </summary>
    /// <remarks>
    /// The format string should follow the requirements for the
    /// .NET System.String.Format statement.
    /// </remarks>
    /// <value>A format string.</value>
    public string FormatString
    {
      get
      {
        if (_format == null)
          _format = _defaultFormat;
        return _format;
      }
      set
      {
        _format = value;
      }
    }

    /// <summary>
    /// Gets or sets the date value.
    /// </summary>
    /// <remarks>
    /// <para>
    /// This property can be used to set the date value by passing a
    /// text representation of the date. Any text date representation
    /// that can be parsed by the .NET runtime is valid.
    /// </para><para>
    /// When the date value is retrieved via this property, the text
    /// is formatted by using the format specified by the 
    /// <see cref="FormatString" /> property. The default is the
    /// short date format (d).
    /// </para>
    /// </remarks>
    public string Text
    {
      get { return DateToString(this.Date, FormatString, _emptyValue); }
      set { this.Date = StringToDate(value, _emptyValue); }
    }

    #endregion

    #region Date Support

    /// <summary>
    /// Gets or sets the date value.
    /// </summary>
    public DateTime Date
    {
      get
      {
        if (!_initialized)
        {
          _date = DateTime.MinValue;
          _initialized = true;
        }
        return _date;
      }
      set
      {
        _date = value;
        _initialized = true;
      }
    }

    #endregion

    #region System.Object overrides

    /// <summary>
    /// Returns a text representation of the date value.
    /// </summary>
    public override string ToString()
    {
      return this.Text;
    }

    /// <summary>
    /// Returns a text representation of the date value.
    /// </summary>
    /// <param name="format">
    /// A standard .NET format string.
    /// </param>
    public string ToString(string format)
    {
      return DateToString(this.Date, format, _emptyValue);
    }

    /// <summary>
    /// Compares this object to another <see cref="SmartDate"/>
    /// for equality.
    /// </summary>
    /// <param name="obj">Object to compare for equality.</param>
    public override bool Equals(object obj)
    {
      if (obj is SmartDate)
      {
        SmartDate tmp = (SmartDate)obj;
        if (this.IsEmpty && tmp.IsEmpty)
          return true;
        else
          return this.Date.Equals(tmp.Date);
      }
      else if (obj is DateTime)
        return this.Date.Equals((DateTime)obj);
      else if (obj is string)
        return (this.CompareTo(obj.ToString()) == 0);
      else
        return false;
    }

    /// <summary>
    /// Returns a hash code for this object.
    /// </summary>
    public override int GetHashCode()
    {
      return this.Date.GetHashCode();
    }

    #endregion

    #region DBValue

    /// <summary>
    /// Gets a database-friendly version of the date value.
    /// </summary>
    /// <remarks>
    /// <para>
    /// If the SmartDate contains an empty date, this returns <see cref="DBNull"/>.
    /// Otherwise the actual date value is returned as type Date.
    /// </para><para>
    /// This property is very useful when setting parameter values for
    /// a Command object, since it automatically stores null values into
    /// the database for empty date values.
    /// </para><para>
    /// When you also use the SafeDataReader and its GetSmartDate method,
    /// you can easily read a null value from the database back into a
    /// SmartDate object so it remains considered as an empty date value.
    /// </para>
    /// </remarks>
    public object DBValue
    {
      get
      {
        if (this.IsEmpty)
          return DBNull.Value;
        else
          return this.Date;
      }
    }

    #endregion

    #region Empty Dates

    /// <summary>
    /// Gets a value indicating whether this object contains an empty date.
    /// </summary>
    public bool IsEmpty
    {
      get
      {
        if (_emptyValue == EmptyValue.MinDate)
          return this.Date.Equals(DateTime.MinValue);
        else
          return this.Date.Equals(DateTime.MaxValue);
      }
    }

    /// <summary>
    /// Gets a value indicating whether an empty date is the 
    /// min or max possible date value.
    /// </summary>
    /// <remarks>
    /// Whether an empty date is considered to be the smallest or largest possible
    /// date is only important for comparison operations. This allows you to
    /// compare an empty date with a real date and get a meaningful result.
    /// </remarks>
    public bool EmptyIsMin
    {
      get { return (_emptyValue == EmptyValue.MinDate); }
    }

    #endregion

    #region Conversion Functions

    /// <summary>
    /// Converts a string value into a SmartDate.
    /// </summary>
    /// <param name="value">String containing the date value.</param>
    /// <returns>A new SmartDate containing the date value.</returns>
    /// <remarks>
    /// EmptyIsMin will default to <see langword="true"/>.
    /// </remarks>
    public static SmartDate Parse(string value)
    {
      return new SmartDate(value);
    }

    /// <summary>
    /// Converts a string value into a SmartDate.
    /// </summary>
    /// <param name="value">String containing the date value.</param>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    /// <returns>A new SmartDate containing the date value.</returns>
    public static SmartDate Parse(string value, bool emptyIsMin)
    {
      return new SmartDate(value, emptyIsMin);
    }

    /// <summary>
    /// Converts a text date representation into a Date value.
    /// </summary>
    /// <remarks>
    /// An empty string is assumed to represent an empty date. An empty date
    /// is returned as the MinValue of the Date datatype.
    /// </remarks>
    /// <param name="value">The text representation of the date.</param>
    /// <returns>A Date value.</returns>
    public static DateTime StringToDate(string value)
    {
      return StringToDate(value, true);
    }

        /// <summary>
    /// Converts a text date representation into a Date value.
    /// </summary>
    /// <remarks>
    /// An empty string is assumed to represent an empty date. An empty date
    /// is returned as the MinValue or MaxValue of the Date datatype depending
    /// on the EmptyIsMin parameter.
    /// </remarks>
    /// <param name="value">The text representation of the date.</param>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    /// <returns>A Date value.</returns>
    public static DateTime StringToDate(string value, bool emptyIsMin)
    {
      return StringToDate(value, GetEmptyValue(emptyIsMin));
    }

    /// <summary>
    /// Converts a text date representation into a Date value.
    /// </summary>
    /// <remarks>
    /// An empty string is assumed to represent an empty date. An empty date
    /// is returned as the MinValue or MaxValue of the Date datatype depending
    /// on the EmptyIsMin parameter.
    /// </remarks>
    /// <param name="value">The text representation of the date.</param>
    /// <param name="emptyValue">Indicates whether an empty date is the min or max date value.</param>
    /// <returns>A Date value.</returns>
    public static DateTime StringToDate(string value, EmptyValue emptyValue)
    {
      DateTime tmp;
      if (String.IsNullOrEmpty(value))
      {
        if (emptyValue == EmptyValue.MinDate)
          return DateTime.MinValue;
        else
          return DateTime.MaxValue;
      }
      else if (DateTime.TryParse(value, out tmp))
        return tmp; 
      else
      {
        string ldate = value.Trim().ToLower();
        if (ldate == Resources.SmartDateT ||
            ldate == Resources.SmartDateToday ||
            ldate == ".")
          return DateTime.Now;
        if (ldate == Resources.SmartDateY ||
            ldate == Resources.SmartDateYesterday ||
            ldate == "-")
          return DateTime.Now.AddDays(-1);
        if (ldate == Resources.SmartDateTom ||
            ldate == Resources.SmartDateTomorrow ||
            ldate == "+")
          return DateTime.Now.AddDays(1);
        throw new ArgumentException(Resources.StringToDateException);
      }
    }

    /// <summary>
    /// Converts a date value into a text representation.
    /// </summary>
    /// <remarks>
    /// The date is considered empty if it matches the min value for
    /// the Date datatype. If the date is empty, this
    /// method returns an empty string. Otherwise it returns the date
    /// value formatted based on the FormatString parameter.
    /// </remarks>
    /// <param name="value">The date value to convert.</param>
    /// <param name="formatString">The format string used to format the date into text.</param>
    /// <returns>Text representation of the date value.</returns>
    public static string DateToString(
      DateTime value, string formatString)
    {
      return DateToString(value, formatString, true);
    }

    /// <summary>
    /// Converts a date value into a text representation.
    /// </summary>
    /// <remarks>
    /// Whether the date value is considered empty is determined by
    /// the EmptyIsMin parameter value. If the date is empty, this
    /// method returns an empty string. Otherwise it returns the date
    /// value formatted based on the FormatString parameter.
    /// </remarks>
    /// <param name="value">The date value to convert.</param>
    /// <param name="formatString">The format string used to format the date into text.</param>
    /// <param name="emptyIsMin">Indicates whether an empty date is the min or max date value.</param>
    /// <returns>Text representation of the date value.</returns>
    public static string DateToString(
      DateTime value, string formatString, bool emptyIsMin)
    {
      return DateToString(value, formatString, GetEmptyValue(emptyIsMin));
    }

    /// <summary>
    /// Converts a date value into a text representation.
    /// </summary>
    /// <remarks>
    /// Whether the date value is considered empty is determined by
    /// the EmptyIsMin parameter value. If the date is empty, this
    /// method returns an empty string. Otherwise it returns the date
    /// value formatted based on the FormatString parameter.
    /// </remarks>
    /// <param name="value">The date value to convert.</param>
    /// <param name="formatString">The format string used to format the date into text.</param>
    /// <param name="emptyValue">Indicates whether an empty date is the min or max date value.</param>
    /// <returns>Text representation of the date value.</returns>
    public static string DateToString(
      DateTime value, string formatString, EmptyValue emptyValue)
    {
      if (emptyValue == EmptyValue.MinDate)
      {
        if (value == DateTime.MinValue)
          return string.Empty;
      }
      else
      {
        if (value == DateTime.MaxValue)
          return string.Empty;
      }
      return string.Format("{0:" + formatString + "}", value);
    }

    #endregion

    #region Manipulation Functions

    /// <summary>
    /// Compares one SmartDate to another.
    /// </summary>
    /// <remarks>
    /// This method works the same as the DateTime.CompareTo method
    /// on the Date datetype, with the exception that it
    /// understands the concept of empty date values.
    /// </remarks>
    /// <param name="value">The date to which we are being compared.</param>
    /// <returns>A value indicating if the comparison date is less than, equal to or greater than this date.</returns>
    public int CompareTo(SmartDate value)
    {
      if (this.IsEmpty && value.IsEmpty)
        return 0;
      else
        return _date.CompareTo(value.Date);
    }

    /// <summary>
    /// Compares one SmartDate to another.
    /// </summary>
    /// <remarks>
    /// This method works the same as the DateTime.CompareTo method
    /// on the Date datetype, with the exception that it
    /// understands the concept of empty date values.
    /// </remarks>
    /// <param name="value">The date to which we are being compared.</param>
    /// <returns>A value indicating if the comparison date is less than, equal to or greater than this date.</returns>
    int IComparable.CompareTo(object value)
    {
      if (value is SmartDate)
        return CompareTo((SmartDate)value);
      else
        throw new ArgumentException(Resources.ValueNotSmartDateException);
    }

    /// <summary>
    /// Compares a SmartDate to a text date value.
    /// </summary>
    /// <param name="value">The date to which we are being compared.</param>
    /// <returns>A value indicating if the comparison date is less than, equal to or greater than this date.</returns>
    public int CompareTo(string value)
    {
      return this.Date.CompareTo(StringToDate(value, _emptyValue));
    }

    /// <summary>
    /// Compares a SmartDate to a date value.
    /// </summary>
    /// <param name="value">The date to which we are being compared.</param>
    /// <returns>A value indicating if the comparison date is less than, equal to or greater than this date.</returns>
    public int CompareTo(DateTime value)
    {
      return this.Date.CompareTo(value);
    }

    /// <summary>
    /// Adds a TimeSpan onto the object.
    /// </summary>
    /// <param name="value">Span to add to the date.</param>
    public DateTime Add(TimeSpan value)
    {
      if (IsEmpty)
        return this.Date;
      else
        return this.Date.Add(value);
    }

    /// <summary>
    /// Subtracts a TimeSpan from the object.
    /// </summary>
    /// <param name="value">Span to subtract from the date.</param>
    public DateTime Subtract(TimeSpan value)
    {
      if (IsEmpty)
        return this.Date;
      else
        return this.Date.Subtract(value);
    }

    /// <summary>
    /// Subtracts a DateTime from the object.
    /// </summary>
    /// <param name="value">Date to subtract from the date.</param>
    public TimeSpan Subtract(DateTime value)
    {
      if (IsEmpty)
        return TimeSpan.Zero;
      else
        return this.Date.Subtract(value);
    }

    #endregion

    #region Operators

    /// <summary>
    /// Equality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator ==(SmartDate obj1, SmartDate obj2)
    {
      return obj1.Equals(obj2);
    }

    /// <summary>
    /// Inequality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator !=(SmartDate obj1, SmartDate obj2)
    {
      return !obj1.Equals(obj2);
    }

    /// <summary>
    /// Equality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator ==(SmartDate obj1, DateTime obj2)
    {
      return obj1.Equals(obj2);
    }

    /// <summary>
    /// Inequality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator !=(SmartDate obj1, DateTime obj2)
    {
      return !obj1.Equals(obj2);
    }

    /// <summary>
    /// Equality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator ==(SmartDate obj1, string obj2)
    {
      return obj1.Equals(obj2);
    }

    /// <summary>
    /// Inequality operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator !=(SmartDate obj1, string obj2)
    {
      return !obj1.Equals(obj2);
    }

    /// <summary>
    /// Addition operator
    /// </summary>
    /// <param name="start">Original date/time</param>
    /// <param name="span">Span to add</param>
    /// <returns></returns>
    public static SmartDate operator +(SmartDate start, TimeSpan span)
    {
      return new SmartDate(start.Add(span), start.EmptyIsMin);
    }

    /// <summary>
    /// Subtraction operator
    /// </summary>
    /// <param name="start">Original date/time</param>
    /// <param name="span">Span to subtract</param>
    /// <returns></returns>
    public static SmartDate operator -(SmartDate start, TimeSpan span)
    {
      return new SmartDate(start.Subtract(span), start.EmptyIsMin);
    }

    /// <summary>
    /// Subtraction operator
    /// </summary>
    /// <param name="start">Original date/time</param>
    /// <param name="finish">Second date/time</param>
    /// <returns></returns>
    public static TimeSpan operator -(SmartDate start, SmartDate finish)
    {
      return start.Subtract(finish.Date);
    }

    /// <summary>
    /// Greater than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }

    /// <summary>
    /// Less than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }

    /// <summary>
    /// Greater than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }

    /// <summary>
    /// Less than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }

    /// <summary>
    /// Greater than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }

    /// <summary>
    /// Less than operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }

    /// <summary>
    /// Greater than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >=(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }

    /// <summary>
    /// Less than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <=(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }

    /// <summary>
    /// Greater than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >=(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }

    /// <summary>
    /// Less than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <=(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }

    /// <summary>
    /// Greater than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator >=(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }

    /// <summary>
    /// Less than or equals operator
    /// </summary>
    /// <param name="obj1">First object</param>
    /// <param name="obj2">Second object</param>
    /// <returns></returns>
    public static bool operator <=(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }

    #endregion

  }
}