using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;
using System.Drawing.Drawing2D;

namespace HeuristicLab.Calendar
{
    public class DayView : Control
    {
        public DayView()
        {
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.Selectable, true);
			SetStyle(ControlStyles.AllPaintingInWmPaint, true);
			SetStyle(ControlStyles.UserPaint, true);

            scrollbar = new VScrollBar();
            scrollbar.SmallChange = appointmentSlotHeight;
            scrollbar.LargeChange = appointmentSlotHeight * 2;
            scrollbar.Dock = DockStyle.Right;
            scrollbar.Visible = allowScroll;
            scrollbar.Scroll += new ScrollEventHandler(scrollbar_Scroll);
            AdjustScrollbar();
            scrollbar.Value = (startHour * 2 * appointmentSlotHeight);

            this.Controls.Add(scrollbar);

            editbox = new TextBox();
            editbox.Multiline = true;
            editbox.Visible = false;
            editbox.BorderStyle = BorderStyle.None;
            editbox.KeyUp += new KeyEventHandler(editbox_KeyUp);
            editbox.Margin = Padding.Empty;

            this.Controls.Add(editbox);

            drawTool = new DrawTool();
            drawTool.DayView = this;

            selectionTool = new SelectionTool();
            selectionTool.DayView = this;
            selectionTool.Complete += new EventHandler(selectionTool_Complete);

            activeTool = drawTool;

            UpdateWorkingHours();

            this.Renderer = new Office12Renderer();
        }

		#region " Private Fields "
		private TextBox editbox;
		private VScrollBar scrollbar;
		private DrawTool drawTool;
		private SelectionTool selectionTool;
		private int allDayEventsHeaderHeight = 20;

		private DateTime workStart;
		private DateTime workEnd;

		private int hourLabelWidth = 50;
		private int hourLabelIndent = 2;
		private int dayHeadersHeight = 20;
		private int appointmentGripWidth = 5;
		private int dayGripWidth = 5;
		private int horizontalAppointmentHeight = 20;

		private AppHeightDrawMode appHeightMode = AppHeightDrawMode.TrueHeightAll;
		private int appointmentSlotHeight = 24;
		private AbstractRenderer renderer;
		private bool ampmdisplay = false;
		private bool drawAllAppBorder = false;
		private bool minHalfHourApp = false;
		private int daysToShow = 1;
		private SelectionType selection;
		private DateTime startDate;
		private int startHour = 8;
		private Appointment selectedAppointment;
		private DateTime selectionStart;
		private DateTime selectionEnd;
		private ITool activeTool;
		private int workingHourStart = 8;
		private int workingMinuteStart = 30;
		private int workingHourEnd = 18;
		private int workingMinuteEnd = 30;
		private bool selectedAppointmentIsNew;
		private bool allowScroll = true;
		private bool allowInplaceEditing = true;
		private bool allowNew = true;
		private bool enableShadows = true;
		private bool enableRoundCorners = false;
		private bool enableTimeIndicator = false;
		private bool enableDurationDisplay = false;
		private AppointmentSlotDuration appointmentSlotDuration = AppointmentSlotDuration.ThirtyMinutes;

		internal System.Collections.Hashtable cachedAppointments = new System.Collections.Hashtable();
		internal Dictionary<Appointment, AppointmentView> appointmentViews = new Dictionary<Appointment, AppointmentView>();
		internal Dictionary<Appointment, AppointmentView> longappointmentViews = new Dictionary<Appointment, AppointmentView>();
		#endregion

		#region Properties
		[Category("DailyView")]
		[System.ComponentModel.DefaultValue(5)]
		public int DayGripWidth
		{
			get
			{
				return dayGripWidth;
			}
			set
			{
				if (dayGripWidth == value)
					return;

				dayGripWidth = value;
				this.Invalidate();
			}
		}

		[Category("DailyView")]
		[System.ComponentModel.DefaultValue(20)]
		public int DayHeadersHeight
		{
			get
			{
				return dayHeadersHeight;
			}
			set
			{
				if (dayHeadersHeight == value)
					return;

				dayHeadersHeight = value;
				this.Invalidate();
			}
		}
		
		[Category("DailyView")]
		public bool AmPmDisplay
        {
            get
            {
                return ampmdisplay;
            }
            set
            {
				if (ampmdisplay == value)
					return;
                ampmdisplay = value;
                this.Invalidate();
            }
        }

		[Category("DailyView")]
		public bool MinHalfHourApp
        {
            get
            {
                return minHalfHourApp;
            }
            set
            {
				if (minHalfHourApp == value)
					return;

                minHalfHourApp = value;
                this.Invalidate();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(1)]
        public int DaysToShow
        {
            get
            {
                return daysToShow;
            }
            set
            {
				if (daysToShow == value)
					return;
                daysToShow = value;
				
				if (this.CurrentlyEditing)
					FinishEditing(true);

				this.Invalidate();
            }
        }

		[Category("DailyView")]
        public DateTime StartDate
        {
            get
            {
                return startDate;
            }
            set
            {
				if (startDate == value)
					return;
                startDate = value;

				startDate = startDate.Date;

				selectedAppointment = null;
				selectedAppointmentIsNew = false;
				selection = SelectionType.DateRange;

				this.Invalidate();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(8)]
        public int StartHour
        {
            get
            {
                return startHour;
            }
            set
            {
                startHour = value;
                OnStartHourChanged();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(8)]
        public int WorkingHourStart
        {
            get
            {
                return workingHourStart;
            }
            set
            {
                workingHourStart = value;
                UpdateWorkingHours();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(30)]
        public int WorkingMinuteStart
        {
            get
            {
                return workingMinuteStart;
            }
            set
            {
                workingMinuteStart = value;
                UpdateWorkingHours();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(18)]
        public int WorkingHourEnd
        {
            get
            {
                return workingHourEnd;
            }
            set
            {
                workingHourEnd = value;
                UpdateWorkingHours();
            }
        }

		[Category("DailyView")]
        [System.ComponentModel.DefaultValue(30)]
        public int WorkingMinuteEnd
        {
            get { return workingMinuteEnd; }
            set
            {
                workingMinuteEnd = value;
                UpdateWorkingHours();
            }
        }

		[Category("DailyView")]
        [DefaultValue(true)]
        public bool AllowScroll
        {
            get
            {
                return allowScroll;
            }
            set
            {
				if (allowScroll == value)
					return;

                allowScroll = value;

				this.scrollbar.Visible = this.AllowScroll;
				this.Invalidate();
            }
        }

		[Category("DailyView")]
        [DefaultValue(true)]
        public bool AllowInplaceEditing
        {
            get
            {
                return allowInplaceEditing;
            }
            set
            {
                allowInplaceEditing = value;
            }
        }

		[Category("DailyView.Appointment")]
		[System.ComponentModel.DefaultValue(24)]
		public int AppointmentSlotHeight
		{
			get
			{
				return appointmentSlotHeight;
			}
			set
			{
				if (appointmentSlotHeight == value)
					return;

				appointmentSlotHeight = value;
				AdjustScrollbar();
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		[System.ComponentModel.DefaultValue(5)]
		public int AppointmentGripWidth
		{
			get
			{
				return appointmentGripWidth;
			}
			set
			{
				if (appointmentGripWidth == value)
					return;

				appointmentGripWidth = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		public bool DrawAllAppBorder
		{
			get
			{
				return drawAllAppBorder;
			}
			set
			{
				if (drawAllAppBorder == value)
					return;
				drawAllAppBorder = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		[System.ComponentModel.DefaultValue(20)]
		public int HorizontalAppointmentHeight
		{
			get
			{
				return horizontalAppointmentHeight;
			}
			set
			{
				if (horizontalAppointmentHeight == value)
					return;

				horizontalAppointmentHeight = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		public AppHeightDrawMode AppointmentHeightMode
		{
			get { return appHeightMode; }
			set { appHeightMode = value; }
		}
		
		[Category("DailyView.Appointment")]
        [DefaultValue(true)]
        public bool AllowNew
        {
            get
            {
                return allowNew;
            }
            set
            {
                allowNew = value;
            }
        }

		[Category("DailyView.Appointment")]
		public bool EnableShadows
		{
			get
			{
				return enableShadows;
			}
			set
			{
				if (enableShadows == value)
					return;
				enableShadows = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		public bool EnableRoundedCorners
		{
			get
			{
				return enableRoundCorners;
			}
			set
			{
				if (enableRoundCorners == value)
					return;
				enableRoundCorners = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		public bool EnableTimeIndicator
		{
			get
			{
				return enableTimeIndicator;
			}
			set
			{
				if (value == enableTimeIndicator)
					return;
				enableTimeIndicator = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		public bool EnableDurationDisplay
		{
			get
			{
				return enableDurationDisplay;
			}
			set
			{
				if (value == enableDurationDisplay)
					return;
				enableDurationDisplay = value;
				this.Invalidate();
			}
		}

		[Category("DailyView.Appointment")]
		[System.ComponentModel.DefaultValue(AppointmentSlotDuration.ThirtyMinutes)]
		public AppointmentSlotDuration AppointmentDuration
		{
			get
			{
				return appointmentSlotDuration;
			}
			set
			{
				if (appointmentSlotDuration == value)
					return;
				appointmentSlotDuration = value;
				this.Invalidate();
			}
		}
		#endregion

		#region " Property Overrides "
		[System.ComponentModel.Browsable(false)]
		public override Color BackColor
		{
			get
			{
				return base.BackColor;
			}
			set
			{
				base.BackColor = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override string Text
		{
			get
			{
				return base.Text;
			}
			set
			{
				base.Text = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override Image BackgroundImage
		{
			get
			{
				return base.BackgroundImage;
			}
			set
			{
				base.BackgroundImage = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override ImageLayout BackgroundImageLayout
		{
			get
			{
				return base.BackgroundImageLayout;
			}
			set
			{
				base.BackgroundImageLayout = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override System.Drawing.Color ForeColor
		{
			get
			{
				return base.ForeColor;
			}
			set
			{
				base.ForeColor = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override Font Font
		{
			get
			{
				return base.Font;
			}
			set
			{
				base.Font = value;
			}
		}
		[System.ComponentModel.Browsable(false)]
		public override RightToLeft RightToLeft
		{
			get
			{
				return base.RightToLeft;
			}
			set
			{
				base.RightToLeft = value;
			}
		}
		#endregion

		#region " Private Properties "
		[System.ComponentModel.Browsable(false)]
		public DateTime SelectionStart
		{
			get { return selectionStart; }
			set { selectionStart = value; }
		}

		[System.ComponentModel.Browsable(false)]
		public DateTime SelectionEnd
		{
			get { return selectionEnd; }
			set { selectionEnd = value; }
		}
		
		[System.ComponentModel.Browsable(false)]
		public bool SelectedAppointmentIsNew
		{
			get
			{
				return selectedAppointmentIsNew;
			}
		}

		[System.ComponentModel.Browsable(false)]
		public int VScrollBarWith
		{
			get
			{
				if (scrollbar.Visible)
					return scrollbar.Width;
				else
					return 0;
			}
		}

		[System.ComponentModel.Browsable(false)]
		public ITool ActiveTool
		{
			get { return activeTool; }
			set { activeTool = value; }
		}

		[System.ComponentModel.Browsable(false)]
		public bool CurrentlyEditing
		{
			get
			{
				return editbox.Visible;
			}
		}

		[System.ComponentModel.Browsable(false)]
		public Appointment SelectedAppointment
		{
			get { return selectedAppointment; }
		}

		[System.ComponentModel.Browsable(false)]
		public SelectionType Selection
		{
			get
			{
				return selection;
			}
		}

		[System.ComponentModel.Browsable(false)]
		[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
		public AbstractRenderer Renderer
		{
			get
			{
				return renderer;
			}
			set
			{
				if (renderer == value)
					return;

				renderer = value;
				this.Font = renderer.BaseFont;
				this.Invalidate();
			}
		}
		
		[System.ComponentModel.Browsable(false)]
		private int HeaderHeight
		{
			get
			{
				return dayHeadersHeight + allDayEventsHeaderHeight;
			}
		}
		#endregion

		#region Event Handlers
		private void editbox_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Escape)
            {
                e.Handled = true;
                FinishEditing(true);
            }
            else if (e.KeyCode == Keys.Enter)
            {
                e.Handled = true;
                FinishEditing(false);
            }
        }

		private void selectionTool_Complete(object sender, EventArgs e)
        {
            if (selectedAppointment != null)
            {
                System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(EnterEditMode));
            }
        }

		private void scrollbar_Scroll(object sender, ScrollEventArgs e)
        {
            Invalidate();
			
			//scroll text box too
            if (editbox.Visible)
                editbox.Top += e.OldValue - e.NewValue;
        }

        protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
        {
            base.SetBoundsCore(x, y, width, height, specified);
            AdjustScrollbar();
        }

        protected override void OnPaintBackground(PaintEventArgs pevent)
        {
            // Flicker free
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            // Capture focus
            this.Focus();

            if (CurrentlyEditing)
            {
                FinishEditing(false);
            }

            if (selectedAppointmentIsNew)
            {
                RaiseNewAppointment();
            }

            ITool newTool = null;

            Appointment appointment = GetAppointmentAt(e.X, e.Y);

            if (e.Y < HeaderHeight && e.Y > dayHeadersHeight && appointment == null)
            {
                if (selectedAppointment != null)
                {
                    selectedAppointment = null;
                    Invalidate();
                }

                newTool = drawTool;
                selection = SelectionType.None;

                base.OnMouseDown(e);
                return;
            }

            if (appointment == null)
            {
                if (selectedAppointment != null)
                {
                    selectedAppointment = null;
                    Invalidate();
                }

                newTool = drawTool;
                selection = SelectionType.DateRange;
            }
            else
            {
                newTool = selectionTool;
                selectedAppointment = appointment;
                selection = SelectionType.Appointment;

                Invalidate();
            }

            if (activeTool != null)
            {
                activeTool.MouseDown(e);
            }

            if ((activeTool != newTool) && (newTool != null))
            {
                newTool.Reset();
                newTool.MouseDown(e);
            }

            activeTool = newTool;

            base.OnMouseDown(e);
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (activeTool != null)
                activeTool.MouseMove(e);

            base.OnMouseMove(e);
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (activeTool != null)
                activeTool.MouseUp(e);

            base.OnMouseUp(e);
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            base.OnMouseWheel(e);

            if (e.Delta < 0)
            {//mouse wheel scroll down
                ScrollMe(true);
            }
            else
            {//mouse wheel scroll up
                ScrollMe(false);
            }
        }

		protected override void OnKeyPress(KeyPressEventArgs e)
        {
            if ((allowNew) && char.IsLetterOrDigit(e.KeyChar))
            {
                if ((this.Selection == SelectionType.DateRange))
                {
                    if (!selectedAppointmentIsNew)
                        EnterNewAppointmentMode(e.KeyChar);
                }
            }
        }

		protected virtual void ResolveAppointments(ResolveAppointmentsEventArgs args)
		{
			//System.Diagnostics.Debug.WriteLine("Resolve app");

			if (OnResolveAppointments != null)
				OnResolveAppointments(this, args);

			this.allDayEventsHeaderHeight = 0;

			// cache resolved appointments in hashtable by days.
			cachedAppointments.Clear();

			if ((selectedAppointmentIsNew) && (selectedAppointment != null))
			{
				if ((selectedAppointment.StartDate > args.StartDate) && (selectedAppointment.StartDate < args.EndDate))
				{
					args.Appointments.Add(selectedAppointment);
				}
			}

			foreach (Appointment appointment in args.Appointments)
			{
				int key = -1;
				AppointmentList list;

				if (appointment.StartDate.Day == appointment.EndDate.Day && appointment.AllDayEvent == false)
				{
					key = appointment.StartDate.Day;
				}
				else
				{
					key = -1;
				}

				list = (AppointmentList)cachedAppointments[key];

				if (list == null)
				{
					list = new AppointmentList();
					cachedAppointments[key] = list;
				}

				list.Add(appointment);
			}
		}
		#endregion

        #region " Public Methods "

        public void ScrollMe(bool down)
        {
			if (this.AllowScroll == false)
				return;

			int newScrollValue;

            if (down)
            {//mouse wheel scroll down
                newScrollValue = this.scrollbar.Value + this.scrollbar.SmallChange;

                if (newScrollValue < this.scrollbar.Maximum)
                    this.scrollbar.Value = newScrollValue;
                else
                    this.scrollbar.Value = this.scrollbar.Maximum;
            }
            else
            {//mouse wheel scroll up
                newScrollValue = this.scrollbar.Value - this.scrollbar.SmallChange;

                if (newScrollValue > this.scrollbar.Minimum)
                    this.scrollbar.Value = newScrollValue;
                else
                    this.scrollbar.Value = this.scrollbar.Minimum;
            }

			this.Invalidate();
        }

        public Rectangle GetTrueRectangle()
        {
            Rectangle truerect;
            truerect = this.ClientRectangle;
            truerect.X += hourLabelWidth + hourLabelIndent;
			truerect.Width -= VScrollBarWith + hourLabelWidth + hourLabelIndent;
            truerect.Y += this.HeaderHeight;
            truerect.Height -= this.HeaderHeight;

            return truerect;
        }

        public Rectangle GetFullDayApptsRectangle()
        {
            Rectangle fulldayrect;
            fulldayrect = this.ClientRectangle;
            fulldayrect.Height = this.HeaderHeight - dayHeadersHeight;
            fulldayrect.Y += dayHeadersHeight;
			fulldayrect.Width -= (hourLabelWidth + hourLabelIndent + this.VScrollBarWith);
            fulldayrect.X += hourLabelWidth + hourLabelIndent;

            return fulldayrect;
        }
        
        public void StartEditing()
        {
            if (!selectedAppointment.Locked && appointmentViews.ContainsKey(selectedAppointment))
            {
                Rectangle editBounds = appointmentViews[selectedAppointment].Rectangle;

                editBounds.Inflate(-3, -3);
                editBounds.X += appointmentGripWidth - 2;
                editBounds.Width -= appointmentGripWidth - 5;

                editbox.Bounds = editBounds;
                editbox.Text = selectedAppointment.Subject;
                editbox.Visible = true;
                editbox.SelectionStart = editbox.Text.Length;
                editbox.SelectionLength = 0;

                editbox.Focus();
            }
        }

        public void FinishEditing(bool cancel)
        {
            editbox.Visible = false;

            if (!cancel)
            {
                if (selectedAppointment != null)
                    selectedAppointment.Subject = editbox.Text;
            }
            else
            {
                if (selectedAppointmentIsNew)
                {
                    selectedAppointment = null;
                    selectedAppointmentIsNew = false;
                }
            }

            Invalidate();
            this.Focus();
        }

        public DateTime GetTimeAt(int x, int y)
        {
			int dayWidth = (this.Width - (VScrollBarWith + hourLabelWidth + hourLabelIndent)) / daysToShow;

            int hour = (y - this.HeaderHeight + scrollbar.Value) / appointmentSlotHeight;
            x -= hourLabelWidth;

            DateTime date = startDate;

            date = date.Date;
            date = date.AddDays(x / dayWidth);

            if ((hour > 0) && (hour < 24 * 2))
                date = date.AddMinutes((hour * 30));

            return date;
        }

        public Appointment GetAppointmentAt(int x, int y)
        {
            foreach (AppointmentView view in appointmentViews.Values)
                if (view.Rectangle.Contains(x, y))
                    return view.Appointment;

            foreach (AppointmentView view in longappointmentViews.Values)
                if (view.Rectangle.Contains(x, y))
                    return view.Appointment;

            return null;
		}

		private Rectangle GetHourRangeRectangle(DateTime start, DateTime end, Rectangle baseRectangle)
		{
			Rectangle rect = baseRectangle;

			int startY;
			int endY;

			startY = (start.Hour * appointmentSlotHeight * 2) + ((start.Minute * appointmentSlotHeight) / 30);
			endY = (end.Hour * appointmentSlotHeight * 2) + ((end.Minute * appointmentSlotHeight) / 30);

			rect.Y = startY - scrollbar.Value + this.HeaderHeight;

			rect.Height = System.Math.Max(1, endY - startY);

			return rect;
		}
		#endregion
		
		#region " Private Methods "
		private void AdjustScrollbar()
		{
			scrollbar.Maximum = (2 * appointmentSlotHeight * 25) - this.Height + this.HeaderHeight;
			scrollbar.Minimum = 0;
		}
		protected virtual void OnStartHourChanged()
		{
			// Fix : http://www.codeproject.com/cs/miscctrl/Calendardayview.asp?forumid=232232&select=1901930&df=100#xx1901930xx

			if ((startHour * 2 * appointmentSlotHeight) > scrollbar.Maximum) //maximum is lower on larger forms
			{
				scrollbar.Value = scrollbar.Maximum;
			}
			else
			{
				scrollbar.Value = (startHour * 2 * appointmentSlotHeight);
			}

			Invalidate();
		}
		private void UpdateWorkingHours()
		{
			workStart = new DateTime(1, 1, 1, workingHourStart, workingMinuteStart, 0);
			workEnd = new DateTime(1, 1, 1, workingHourEnd, workingMinuteEnd, 0);

			Invalidate();
		}
		private void EnterNewAppointmentMode(char key)
		{
			Appointment appointment = new Appointment();
			appointment.StartDate = selectionStart;
			appointment.EndDate = selectionEnd;
			appointment.Subject = key.ToString();

			selectedAppointment = appointment;
			selectedAppointmentIsNew = true;

			activeTool = selectionTool;

			Invalidate();

			System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(EnterEditMode));
		}

		private delegate void StartEditModeDelegate(object state);
		private void EnterEditMode(object state)
		{
			if (!allowInplaceEditing)
				return;

			if (this.InvokeRequired)
			{
				Appointment selectedApp = selectedAppointment;

				System.Threading.Thread.Sleep(200);

				if (selectedApp == selectedAppointment)
					this.Invoke(new StartEditModeDelegate(EnterEditMode), state);
			}
			else
			{
				StartEditing();
			}
		}
		#endregion

		#region " Method Overrides "
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				editbox.Dispose();
				scrollbar.Dispose();
			}
			base.Dispose(disposing);
		}
		#endregion

		#region " Drawing Methods "
		protected override void OnPaint(PaintEventArgs e)
        {
			e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

			// resolve appointments on visible date range.
			ResolveAppointmentsEventArgs args = new ResolveAppointmentsEventArgs(this.StartDate, this.StartDate.AddDays(daysToShow));
			ResolveAppointments(args);

			using (SolidBrush backBrush = new SolidBrush(renderer.BackColor))
				e.Graphics.FillRectangle(backBrush, this.ClientRectangle);

			// Visible Rectangle
			Rectangle rectangle = new Rectangle(0, 0, this.Width - VScrollBarWith, this.Height);

			DrawDays(ref e, rectangle);

			DrawHourLabels(ref e, rectangle);

			DrawDayHeaders(ref e, rectangle);
        }

		private void DrawDays(ref PaintEventArgs e, Rectangle rectangle)
		{
			Rectangle rect = rectangle;
			rect.X += hourLabelWidth + hourLabelIndent;
			rect.Y += this.HeaderHeight;
			rect.Width -= (hourLabelWidth + hourLabelIndent);


			if (e.ClipRectangle.IntersectsWith(rect) == false)
				return;

			int dayWidth = rect.Width / daysToShow;

			#region " Multi Day Appointments "
			AppointmentList longAppointments = (AppointmentList)cachedAppointments[-1];

			AppointmentList drawnLongApps = new AppointmentList();

			AppointmentView view;

			int y = dayHeadersHeight;
			bool intersect = false;

			List<int> layers = new List<int>();
			if (longAppointments != null)
			{

				foreach (Appointment appointment in longAppointments)
				{
					appointment.Layer = 0;

					if (drawnLongApps.Count != 0)
					{
						foreach (Appointment app in drawnLongApps)
							if (!layers.Contains(app.Layer))
								layers.Add(app.Layer);

						foreach (int lay in layers)
						{
							foreach (Appointment app in drawnLongApps)
							{
								if (app.Layer == lay)
									if (appointment.StartDate.Date >= app.EndDate.Date || appointment.EndDate.Date <= app.StartDate.Date)
										intersect = false;
									else
									{
										intersect = true;
										break;
									}
								appointment.Layer = lay;
							}

							if (!intersect)
								break;
						}

						if (intersect)
							appointment.Layer = layers.Count;
					}

					drawnLongApps.Add(appointment); // changed by Gimlei
				}

				foreach (Appointment app in drawnLongApps)
					if (!layers.Contains(app.Layer))
						layers.Add(app.Layer);

				allDayEventsHeaderHeight = layers.Count * (horizontalAppointmentHeight + 5) + 5;

				Rectangle backRectangle = rect;
				backRectangle.Y = y;
				backRectangle.Height = allDayEventsHeaderHeight;

				renderer.DrawAllDayBackground(e.Graphics, backRectangle);

				foreach (Appointment appointment in longAppointments)
				{
					Rectangle appointmenRect = rect;
					int spanDays = appointment.EndDate.Subtract(appointment.StartDate).Days;

					if (appointment.EndDate.Day != appointment.StartDate.Day && appointment.EndDate.TimeOfDay < appointment.StartDate.TimeOfDay)
						spanDays += 1;

					appointmenRect.Width = dayWidth * spanDays - 5;
					appointmenRect.Height = horizontalAppointmentHeight;
					appointmenRect.X += (appointment.StartDate.Subtract(startDate).Days) * dayWidth; // changed by Gimlei
					appointmenRect.Y = y + appointment.Layer * (horizontalAppointmentHeight + 5) + 5; // changed by Gimlei

					view = new AppointmentView();
					view.Rectangle = appointmenRect;
					view.Appointment = appointment;

					longappointmentViews[appointment] = view;

					Rectangle gripRect = appointmenRect;
					gripRect.Width = appointmentGripWidth;

					renderer.DrawAppointment(e.Graphics, appointmenRect, appointment, appointment == selectedAppointment, gripRect, EnableShadows, EnableRoundedCorners);

				}
			}
			#endregion

			DateTime time = startDate;
			Rectangle rectangle2 = rect;
			rectangle2.Width = dayWidth;
			rectangle2.Y += allDayEventsHeaderHeight;
			rectangle2.Height -= allDayEventsHeaderHeight;

			appointmentViews.Clear();
			layers.Clear();

			for (int day = 0; day < daysToShow; day++)
			{
				DrawDay(ref e, rectangle2, time);

				rectangle2.X += dayWidth;

				time = time.AddDays(1);
			}
		}

		private void DrawHourLabels(ref PaintEventArgs e, Rectangle rectangle)
        {
			Rectangle rect = rectangle;
			rect.Y += this.HeaderHeight;

            e.Graphics.SetClip(rect);

			int hourlabelheight = (int)AppointmentDuration * AppointmentSlotHeight;

            for (int m_Hour = 0; m_Hour < 24; m_Hour++)
            {
                Rectangle hourRectangle = rect;

                hourRectangle.Y = rect.Y + (m_Hour * 2 * appointmentSlotHeight) - scrollbar.Value;
                hourRectangle.X += hourLabelIndent;
                hourRectangle.Width = hourLabelWidth;
				hourRectangle.Height = hourlabelheight;

                if (hourRectangle.Y > this.HeaderHeight / 2)
                    renderer.DrawHourLabel(e.Graphics, hourRectangle, m_Hour, this.AmPmDisplay, EnableTimeIndicator);
            }

            e.Graphics.ResetClip();
        }

		private void DrawDayHeaders(ref PaintEventArgs e, Rectangle rectangle)
        {
			Rectangle rect = rectangle;
			rect.X += hourLabelWidth + hourLabelIndent;
			rect.Width -= (hourLabelWidth + hourLabelIndent);
			rect.Height = dayHeadersHeight;

			if (e.ClipRectangle.IntersectsWith(rect) == false)
				return;

            int dayWidth = rect.Width / daysToShow;

            //one day header rectangle
            Rectangle dayHeaderRectangle = new Rectangle(rect.Left, rect.Top, dayWidth, rect.Height);
            DateTime headerDate = startDate;

            for (int day = 0; day < daysToShow; day++)
            {
                renderer.DrawDayHeader(e.Graphics, dayHeaderRectangle, headerDate);

                dayHeaderRectangle.X += dayWidth;
                headerDate = headerDate.AddDays(1);
            }
			Rectangle scrollrect = rectangle;
			if (this.AllowScroll == false)
			{
				scrollrect.X = rect.Width + hourLabelWidth + hourLabelIndent;
				scrollrect.Width = VScrollBarWith;
				using (SolidBrush backBrush = new SolidBrush(renderer.BackColor))
					e.Graphics.FillRectangle(backBrush, scrollrect);
			}
        }

        private void DrawDay(ref PaintEventArgs e, Rectangle rect, DateTime time)
        {
            Rectangle workingHoursRectangle = GetHourRangeRectangle(workStart, workEnd, rect);

            if (workingHoursRectangle.Y < this.HeaderHeight)
            {
                // Fix : http://www.codeproject.com/cs/miscctrl/Calendardayview.asp?forumid=232232&select=1904152&df=100#xx1904152xx
                
                workingHoursRectangle.Height -= this.HeaderHeight - workingHoursRectangle.Y;
                workingHoursRectangle.Y = this.HeaderHeight;
            }

            if (!((time.DayOfWeek == DayOfWeek.Saturday) || (time.DayOfWeek == DayOfWeek.Sunday))) //weekends off -> no working hours
                renderer.DrawHourRange(e.Graphics, workingHoursRectangle, false, false);

            if ((selection == SelectionType.DateRange) && (time.Day == selectionStart.Day))
            {
                Rectangle selectionRectangle = GetHourRangeRectangle(selectionStart, selectionEnd, rect);
                if (selectionRectangle.Top + 1 > this.HeaderHeight)
                renderer.DrawHourRange(e.Graphics, selectionRectangle, false, true);
            }

            e.Graphics.SetClip(rect);

            for (int hour = 0; hour < 24 * 2; hour++)
            {
                int y = rect.Top + (hour * appointmentSlotHeight) - scrollbar.Value;

				using (Pen pen = new Pen(((hour % 2) == 0 ? renderer.HalfHourSeperatorColor : renderer.HourSeperatorColor)))
                    e.Graphics.DrawLine(pen, rect.Left, y, rect.Right, y);

                if (y > rect.Bottom)
                    break;
            }

            renderer.DrawDayGripper(e.Graphics, rect, dayGripWidth);

            e.Graphics.ResetClip();

            AppointmentList appointments = (AppointmentList)cachedAppointments[time.Day];

            if (appointments != null)
            {
                List<string> groups = new List<string>();

                foreach (Appointment app in appointments)
                    if (!groups.Contains(app.Group))
                        groups.Add(app.Group);

                Rectangle rect2 = rect;
                rect2.Width = rect2.Width / groups.Count;

                //groups.Sort();

                foreach (string group in groups)
                {
                    DrawAppointments(ref e, rect2, time, group);

                    rect2.X += rect2.Width;
                }
            }
        }

        private void DrawAppointments(ref PaintEventArgs e, Rectangle rect, DateTime time, string group)
        {
            DateTime timeStart = time.Date;
            DateTime timeEnd = timeStart.AddHours(24);
            timeEnd = timeEnd.AddSeconds(-1);

            AppointmentList appointments = (AppointmentList)cachedAppointments[time.Day];

            if (appointments != null)
            {
                HalfHourLayout[] layout = GetMaxParalelAppointments(appointments);
                
                List<Appointment> drawnItems = new List<Appointment>();

                for (int halfHour = 0; halfHour < 24 * 2; halfHour++)
                {
                    HalfHourLayout hourLayout = layout[halfHour];

                    if ((hourLayout != null) && (hourLayout.Count > 0))
                    {
                        for (int appIndex = 0; appIndex < hourLayout.Count; appIndex++)
                        {
                            Appointment appointment = hourLayout.Appointments[appIndex];

                            if (appointment.Group != group)
                                continue;

                            if (drawnItems.IndexOf(appointment) < 0)
                            {
                                Rectangle appRect = rect;
                                int appointmentWidth;
                                AppointmentView view;

                                appointmentWidth = rect.Width / appointment.conflictCount;

								int lastX = 0;

                                foreach (Appointment app in hourLayout.Appointments)
                                {
                                    if ((app != null) && (app.Group == appointment.Group) && (appointmentViews.ContainsKey(app)))
                                    {
                                        view = appointmentViews[app];

                                        if (lastX < view.Rectangle.X)
                                            lastX = view.Rectangle.X;
                                    }
                                }

                                if ((lastX + (appointmentWidth * 2)) > (rect.X + rect.Width))
                                    lastX = 0;

                                appRect.Width = appointmentWidth - 5;

                                if (lastX > 0)
                                    appRect.X = lastX + appointmentWidth;

                                DateTime appstart = appointment.StartDate;
                                DateTime append = appointment.EndDate;

                                // Draw the appts boxes depending on the height display mode                           
                                // If small appts are to be drawn in half-hour blocks
                                if (this.AppointmentHeightMode == AppHeightDrawMode.FullHalfHourBlocksShort && appointment.EndDate.Subtract(appointment.StartDate).TotalMinutes < 30)
                                {
                                    // Round the start/end time to the last/next halfhour
                                    appstart = appointment.StartDate.AddMinutes(-appointment.StartDate.Minute);
                                    append = appointment.EndDate.AddMinutes(30 - appointment.EndDate.Minute);
                                    
                                    // Make sure we've rounded it to the correct halfhour :)
                                    if (appointment.StartDate.Minute >= 30)
                                        appstart = appstart.AddMinutes(30);
                                    if (appointment.EndDate.Minute > 30)
                                        append = append.AddMinutes(30);
                                }

                                // This is basically the same as previous mode, but for all appts
                                else if (this.AppointmentHeightMode == AppHeightDrawMode.FullHalfHourBlocksAll)
                                {
                                    appstart = appointment.StartDate.AddMinutes(-appointment.StartDate.Minute);
                                    if (appointment.EndDate.Minute != 0 && appointment.EndDate.Minute != 30)
                                        append = appointment.EndDate.AddMinutes(30 - appointment.EndDate.Minute);
                                    else
                                        append = appointment.EndDate;

                                    if (appointment.StartDate.Minute >= 30)
                                        appstart = appstart.AddMinutes(30);
                                    if (appointment.EndDate.Minute > 30)
                                        append = append.AddMinutes(30);
                                }

                                // Based on previous code
                                else if (this.AppointmentHeightMode == AppHeightDrawMode.EndHalfHourBlocksShort && appointment.EndDate.Subtract(appointment.StartDate).TotalMinutes < 30)
                                {
                                    // Round the end time to the next halfhour
                                    append = appointment.EndDate.AddMinutes(30 - appointment.EndDate.Minute);

                                    // Make sure we've rounded it to the correct halfhour :)
                                    if (appointment.EndDate.Minute > 30)
                                        append = append.AddMinutes(30);
                                }

                                else if (this.AppointmentHeightMode == AppHeightDrawMode.EndHalfHourBlocksAll)
                                {
                                    // Round the end time to the next halfhour
                                    if (appointment.EndDate.Minute != 0 && appointment.EndDate.Minute != 30)
                                        append = appointment.EndDate.AddMinutes(30 - appointment.EndDate.Minute);
                                    else
                                        append = appointment.EndDate;
                                    // Make sure we've rounded it to the correct halfhour :)
                                    if (appointment.EndDate.Minute > 30)
                                        append = append.AddMinutes(30);
                                }

                                appRect = GetHourRangeRectangle(appstart, append, appRect);

                                view = new AppointmentView();
                                view.Rectangle = appRect;
                                view.Appointment = appointment;

                                appointmentViews[appointment] = view;

                                e.Graphics.SetClip(rect);

                                if (this.DrawAllAppBorder)
                                    appointment.DrawBorder = true;

                                // Procedure for gripper rectangle is always the same
								Rectangle gripRect = appRect;
                                gripRect.Width = appointmentGripWidth;
                                
                                renderer.DrawAppointment(e.Graphics, appRect, appointment, appointment == selectedAppointment, gripRect, this.EnableShadows, this.enableRoundCorners);

                                e.Graphics.ResetClip();

                                drawnItems.Add(appointment);
                            }
                        }
                    }
                }
            }
        }

        private static HalfHourLayout[] GetMaxParalelAppointments(List<Appointment> appointments)
        {
            HalfHourLayout[] appLayouts = new HalfHourLayout[24 * 2];

            foreach (Appointment appointment in appointments)
            {
                appointment.conflictCount = 1;
            }

            foreach (Appointment appointment in appointments)
            {
                int firstHalfHour = appointment.StartDate.Hour * 2 + (appointment.StartDate.Minute / 30);
                int lastHalfHour = appointment.EndDate.Hour * 2 + (appointment.EndDate.Minute / 30);

                // Added to allow small parts been displayed
                if (lastHalfHour == firstHalfHour)
                {
                    if (lastHalfHour < 24 * 2)
                        lastHalfHour++;
                    else
                        firstHalfHour--;
                }

                for (int halfHour = firstHalfHour; halfHour < lastHalfHour; halfHour++)
                {
                    HalfHourLayout layout = appLayouts[halfHour];

                    if (layout == null)
                    {
                        layout = new HalfHourLayout();
                        layout.Appointments = new Appointment[20];
                        appLayouts[halfHour] = layout;
                    }

                    layout.Appointments[layout.Count] = appointment;

                    layout.Count++;

                    List<string> groups = new List<string>();

                    foreach (Appointment app2 in layout.Appointments)
                    {
                        if ((app2 != null) && (!groups.Contains(app2.Group)))
                            groups.Add(app2.Group);
                    }

                    layout.Groups = groups;

                    // update conflicts
                    foreach (Appointment app2 in layout.Appointments)
                    {
                        if ((app2 != null) && (app2.Group == appointment.Group))
                            if (app2.conflictCount < layout.Count)
                                app2.conflictCount = layout.Count - (layout.Groups.Count - 1);
                    }
                }
            }

            return appLayouts;
        }
        #endregion

        #region " Internal Utility Classes "

        internal class HalfHourLayout
        {
            public int Count;
            public List<string> Groups;
            public Appointment[] Appointments;
        }

        internal class AppointmentView
        {
            public Appointment Appointment;
            public Rectangle Rectangle;
        }

        internal class AppointmentList : List<Appointment>
        {
        }

        #endregion

        #region " Events "
        public event EventHandler<EventArgs> OnSelectionChanged;
		public event EventHandler<ResolveAppointmentsEventArgs> OnResolveAppointments;
		public event EventHandler<NewAppointmentEventArgs> OnNewAppointment;
        public event EventHandler<AppointmentEventArgs> OnAppointmentMove;

		internal void RaiseNewAppointment()
		{
			NewAppointmentEventArgs args = new NewAppointmentEventArgs(selectedAppointment.Subject, selectedAppointment.StartDate, selectedAppointment.EndDate);

			if (OnNewAppointment != null)
			{
				OnNewAppointment(this, args);
			}

			selectedAppointment = null;
			selectedAppointmentIsNew = false;

			Invalidate();
		}

		internal void RaiseSelectionChanged(EventArgs e)
		{
			if (OnSelectionChanged != null)
				OnSelectionChanged(this, e);
		}

		internal void RaiseAppointmentMove(AppointmentEventArgs e)
		{
			if (OnAppointmentMove != null)
				OnAppointmentMove(this, e);
		}
        #endregion
    }
}