//-----------------------------------------------------------------------------
// <copyright>
//   Copyright (c) 2009 Nesterovsky Bros. All rights reserved.
// </copyright>
// <description>
//   Sample scheduler.
// </description>
//-----------------------------------------------------------------------------

namespace NesterovskyBros.Collections
{
  using System;

  /// <summary>
  /// A schedule bookmark.
  /// </summary>
  public class ScheduleBookmark: ScheduleNode<ScheduleBookmark>
  {
    /// <summary>
    /// Creates a container bookmark.
    /// </summary>
    public ScheduleBookmark(): 
      base(DateTime.MinValue, null)
    { 
    }

    /// <summary>
    /// Creates a schedule bookmark.
    /// </summary>
    /// <param name="date">A bookmark date.</param>
    /// <param name="description">A bookmark description.</param>
    public ScheduleBookmark(DateTime date, string description): 
      base(date, description)
    {
    }
  }

  /// <summary>
  /// A schedule node.
  /// </summary>
  public class ScheduleNode<Node>: IndexedNode<Node>
    where Node: ScheduleNode<Node>
  {
    /// <summary>
    /// Creates a schedule node.
    /// </summary>
    /// <param name="date">A node date.</param>
    /// <param name="description">A node description.</param>
    public ScheduleNode(DateTime date, string description)
    {
      this.offset = date - DateTime.MinValue;
      this.description = description;
    }

    /// <summary>
    /// A bookmark date.
    /// </summary>
    public DateTime Date
    {
      get
      {
        TimeSpan result = TimeSpan.Zero;
        ScheduleNode<Node> bookmark = this;

        do
        {
          result += bookmark.offset;
          bookmark = bookmark.Parent;
        }
        while(bookmark != null);

        return DateTime.MinValue + result;
      }
    }

    /// <summary>
    /// Text row.
    /// </summary>
    public string Description
    {
      get { return description; }
    }

    /// <summary>
    /// Inserts a schedule node into a tree.
    /// </summary>
    /// <param name="reference">a reference node.</param>
    /// <param name="value">a node to insert.</param>
    public static void Insert(Node reference, Node value)
    {
      DateTime date = value.Date;
      DateTime otherDate;

      Node other = Find(reference, date, out otherDate);

      if (otherDate > date)
      {
        InsertBefore(other, value);
      }
      else
      {
        InsertAfter(other, value);
      }
    }

    /// <summary>
    /// Finds node near or coinciding with a date.
    /// </summary>
    /// <param name="reference">a reference node.</param>
    /// <param name="date">a date to look for.</param>
    /// <param name="nodeDate">a date of found node.</param>
    /// <returns>a node near or coinciding with a date.</returns>
    public static Node Find(
      Node reference,
      DateTime date, 
      out DateTime nodeDate)
    {
      nodeDate = reference.Date;

      Node node = reference;

      while(true)
      {
        Node parent = node;

        if (date > nodeDate)
        {
          node = node.Right;
        }
        else if (date < nodeDate)
        {
          node = node.Left;
        }
        else
        {
          return node;
        }

        if (node == null)
        {
          return parent;
        }

        nodeDate += node.offset;
      }
    }

    /// <summary>
    /// Adjusts schedule upon indreasing or decreasing interval 
    /// before or after this node.
    /// </summary>
    /// <param name="reference">a reference node.</param>
    /// <param name="offset">change offset.</param>
    /// <param name="before">
    /// true when interval increased or decreased before this node, and
    /// false when after it.
    /// </param>
    public static void OnScheduleChanged(
      Node reference,
      TimeSpan offset,
      bool before)
    {
      Node node = reference;
      bool left;

      if (before)
      {
        left = node.Left == null;

        if (!left)
        {
          node = Predecessor(node);
        }
      }
      else
      {
        left = node.Right != null;

        if (left)
        {
          node = Successor(node);
        }
      }

      while(!node.IsContainer)
      {
        Node parent = node.Parent;
        bool leftNode = parent.Right != node;

        if (left != leftNode)
        {
          if (leftNode)
          {
            node.offset -= offset;
          }
          else
          {
            node.offset += offset;
          }
        }

        node = parent;
        left = leftNode;
      }
    }

    /// <summary>
    /// Informational string representation of the schedule node.
    /// </summary>
    /// <returns>string value.</returns>
    public override string ToString()
    {
      return "Index: " + Index + 
        ", Date: " + Date + 
        ", description: " + Description;
    }

    /// <summary>
    /// Rebinds node's parent.
    /// RebindParent is called before parent is changed.
    /// </summary>
    /// <param name="from">parent a new parent node.</param>
    protected override void RebindParent(Node parent)
    {
      base.RebindParent(parent);

      if (parent != null)
      {
        offset = Date - parent.Date;
      }
      else
      {
        offset = Date - DateTime.MinValue;
      }
    }

    /// <summary>
    /// Bookmark offset.
    /// </summary>
    private TimeSpan offset;

    /// <summary>
    /// Node description.
    /// </summary>
    private string description;
  }
}