/// <summary>
 /// Create a <see cref="CronCalendar" /> with the given cron expression and 
 /// <see cref="BaseCalendar" />. 
 /// </summary>
 /// <param name="baseCalendar">
 /// the base calendar for this calendar instance 
 /// see BaseCalendar for more information on base
 /// calendar functionality
 /// </param>
 /// <param name="expression">a String representation of the desired cron expression</param>
 /// <param name="timeZone"></param>
 public CronCalendar(ICalendar baseCalendar,
                     string expression,
                     TimeZone timeZone)
     : base(baseCalendar, timeZone)
 {
     cronExpression = new CronExpression(expression);
 }

        public static TriggerDetailDto Create(ITrigger trigger, ICalendar calendar)
        {
            var simpleTrigger = trigger as ISimpleTrigger;
            if (simpleTrigger != null)
            {
                return new SimpleTriggerDetailDto(simpleTrigger, calendar);
            }
            var cronTrigger = trigger as ICronTrigger;
            if (cronTrigger != null)
            {
                return new CronTriggerDetailDto(cronTrigger, calendar);
            }
            var calendarIntervalTrigger = trigger as ICalendarIntervalTrigger;
            if (calendarIntervalTrigger != null)
            {
                return new CalendarIntervalTriggerDetailDto(calendarIntervalTrigger, calendar);
            }
            var dailyTimeIntervalTrigger = trigger as IDailyTimeIntervalTrigger;
            if (dailyTimeIntervalTrigger != null)
            {
                return new DailyTimeIntervalTriggerDetailDto(dailyTimeIntervalTrigger, calendar);
            }

            return new TriggerDetailDto(trigger, calendar);
        }

		/// <summary>
		/// Start this instance.
		/// <para xml:lang="es">
		/// Inicia la instancia del objeto Calendar.
		/// </para>
		/// </summary>
		public override void Start()
		{
			base.Start();

			// Create an Stack
			IStack stack = Platform.Current.Create<IStack>();

			// Creates an Label with text and a specific size and adds it to the stack.
			lblLabel = Platform.Current.Create<ILabel>();
			lblLabel.Text = "Select 1 day";
			lblLabel.Height = 30;
			stack.Children.Add(lblLabel);

			// Creates an Calendar with text specific and adds it to the stack.
			calendar = Platform.Current.Create<ICalendar>();
			calendar.Name = "calendar";
			calendar.Bold = true;
			stack.Children.Add(calendar);

			// Creates the Button cmdChange with text specific, with the event also click and adds it to the stack.
			IButton cmdChange = Platform.Current.Create<IButton>();
			cmdChange.Text = "Change";
			cmdChange.Click += CmdChange_Click;
			stack.Children.Add(cmdChange);

			// Creates the Button cmdClose with text specific, with the event also click and adds it to the stack.
			IButton cmdClose = Platform.Current.Create<IButton>();
			cmdClose.Text = "Close";
			cmdClose.Click += CmdClose_Click;
			stack.Children.Add(cmdClose);

			// Establishes the content and title of the page
			Platform.Current.Page.Title = "Test label";
			Platform.Current.Page.Content = stack;
		}

        /// <summary>
        /// Returns a list of Dates that are the next fire times of a
        /// <see cref="ITrigger" />.
        /// The input trigger will be cloned before any work is done, so you need
        /// not worry about its state being altered by this method.
        /// </summary>
        /// <param name="trigg">The trigger upon which to do the work</param>
        /// <param name="cal">The calendar to apply to the trigger's schedule</param>
        /// <param name="numTimes">The number of next fire times to produce</param>
        /// <returns>List of java.util.Date objects</returns>
        public static IList<DateTimeOffset> ComputeFireTimes(IOperableTrigger trigg, ICalendar cal, int numTimes)
        {
            List<DateTimeOffset> lst = new List<DateTimeOffset>();

            IOperableTrigger t = (IOperableTrigger) trigg.Clone();

            if (t.GetNextFireTimeUtc() == null || !t.GetNextFireTimeUtc().HasValue)
            {
                t.ComputeFirstFireTimeUtc(cal);
            }

            for (int i = 0; i < numTimes; i++)
            {
                DateTimeOffset? d = t.GetNextFireTimeUtc();
                if (d.HasValue)
                {
                    lst.Add(d.Value);
                    t.Triggered(cal);
                }
                else
                {
                    break;
                }
            }

            return lst.AsReadOnly();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="calendar"></param>
        public override void SetCalendar(ICalendar calendar) {
            var cal = (HolidayCalendar)calendar;
            if (cal == null)
                return;

            this.Dates = new BindableCollection<DateTime>(cal.ExcludedDates);
            this.NotifyOfPropertyChange(() => this.Dates);
        }

		public Time (ulong timestamp, ICalendar calendar)
		{
			if (calendar == null)
				throw new ArgumentNullException ("calendar");

			this.Calendar = calendar;
			this.Calendar.DecodeTimestamp (timestamp, this);
		}

 public ExpenseReportController(IExpenseReportBuilder expenseReportBuilder, IUserSession session,
     IWorkflowFacilitator workflowFacilitator, Bus bus, ICalendar calendar)
 {
     _expenseReportBuilder = expenseReportBuilder;
     _session = session;
     _workflowFacilitator = workflowFacilitator;
     _bus = bus;
     _calendar = calendar;
 }

 protected CalendarDetailDto(ICalendar calendar)
 {
     CalendarType = calendar.GetType().AssemblyQualifiedNameWithoutVersion();
     Description = calendar.Description;
     if (calendar.CalendarBase != null)
     {
         CalendarBase = Create(calendar.CalendarBase);
     }
 }

 public override IEnumerable<PushedEvent> Push(ICalendar calendar)
 {
     Log.Info(String.Format("Pushing calendar [{0}] to outlook", calendar.Id));
     var result = new List<PushedEvent>();
     foreach (var evt in calendar.Events)
     {
     }
     return result;
 }

 public CalendarSynchronizationWorker(
     ICalendar sourceCalendar,
     ICalendar destinationCalendar,
     ISynchronizationConfiguration synchronizationConfiguration,
     AutoResetEvent saveSynchronizationConfigurationsEvent)
     : this(
         sourceCalendar, destinationCalendar, synchronizationConfiguration, saveSynchronizationConfigurationsEvent,
         new CalendarEventSynchronizer())
 { }

        public AddEvent(GoogleCalendar.Data.Event monEvt, EventControler controler, ICalendar parent)
        {
            this.InitializeComponent();

            this.Title.Text = IConstantes.TITLE_ADD_EVT;
            this.Button_Cancel.Content = IConstantes.BUTTON_CANCEL;
            this.Button_Add.Content = IConstantes.BUTTON_ADD;

            this.DataContext = new VIEWMODEL.Event.EventModelView(monEvt, controler,parent);
        }

        public ModifEvent(GoogleCalendar.Data.Event monEvt,EventControler controler, ICalendar parent)
        {
            this.InitializeComponent();

            this.Title.Text = IConstantes.TITLE_UPDATE_EVT;
            this.Button_Cancel.Content = IConstantes.BUTTON_CANCEL;
            this.Button_Add.Content = IConstantes.BUTTON_UPDATE;
            this.Button_Delete.Content = IConstantes.BUTTON_DELETE;

            this.DataContext = new EventModelView(monEvt, controler, parent);
        }

 protected TriggerDetailDto(ITrigger trigger, ICalendar calendar)
 {
     Description = trigger.Description;
     TriggerType = trigger.GetType().AssemblyQualifiedNameWithoutVersion();
     Name = trigger.Key.Name;
     Group = trigger.Key.Group;
     CalendarName = trigger.CalendarName;
     Priority = trigger.Priority;
     StartTimeUtc = trigger.StartTimeUtc;
     EndTimeUtc = trigger.EndTimeUtc;
     NextFireTimes = TriggerUtils.ComputeFireTimes((IOperableTrigger) trigger, calendar, 10);
 }

 public override async Task<IEnumerable<PushedEvent>> PushAsync(ICalendar calendar)
 {
     Log.Info(String.Format("Pushing calendar to google [{0}]", calendar.Id));
     if (LastCalendar != null)
     {
         var eventsToRemove = LastCalendar.Events.Where(e => !calendar.Events.Any(elc => elc.Id == e.Id));
         RemoveEvents(eventsToRemove);
     }
     LastCalendar = calendar;
     var res = await PushEvents(calendar.Events);
     return res;
 }

 public static PublicItemCollection GetForCalendar(ICalendar calendar)
 {
     var sharingOptions = new PublicItemCollection();
     sharingOptions.Items.Add(new PublicItemWrapper(new ASC.Web.Core.Calendars.SharingOptions.PublicItem()
            {
                Id = calendar.OwnerId,
                IsGroup = false
            },
           calendar.Id.ToString(), calendar.OwnerId));
     foreach (var item in calendar.SharingOptions.PublicItems)            
         sharingOptions.Items.Add(new PublicItemWrapper(item, calendar.Id.ToString(), calendar.OwnerId));
     
     return sharingOptions;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TriggerFiredBundle"/> class.
 /// </summary>
 /// <param name="job">The job.</param>
 /// <param name="trigger">The trigger.</param>
 /// <param name="cal">The calendar.</param>
 /// <param name="jobIsRecovering">if set to <c>true</c> [job is recovering].</param>
 /// <param name="fireTimeUtc">The fire time.</param>
 /// <param name="scheduledFireTimeUtc">The scheduled fire time.</param>
 /// <param name="prevFireTimeUtc">The previous fire time.</param>
 /// <param name="nextFireTimeUtc">The next fire time.</param>
 public TriggerFiredBundle(IJobDetail job, IOperableTrigger trigger, ICalendar cal, bool jobIsRecovering,
     DateTimeOffset? fireTimeUtc,
     DateTimeOffset? scheduledFireTimeUtc,
     DateTimeOffset? prevFireTimeUtc,
     DateTimeOffset? nextFireTimeUtc)
 {
     this.job = job;
     this.trigger = trigger;
     this.cal = cal;
     this.jobIsRecovering = jobIsRecovering;
     this.fireTimeUtc = fireTimeUtc;
     this.scheduledFireTimeUtc = scheduledFireTimeUtc;
     this.prevFireTimeUtc = prevFireTimeUtc;
     this.nextFireTimeUtc = nextFireTimeUtc;
 }

 static void Initialize(ICalendar calendar, IXpandJobTrigger trigger) {
     if (calendar is AnnualCalendar) {
         InitializeAnnual(calendar as AnnualCalendar, trigger.Calendar as IAnnualCalendar);
     } else if (calendar is HolidayCalendar) {
         InitializeHoliday(calendar as HolidayCalendar, trigger.Calendar as IHolidayCalendar);
     } else if (calendar is WeeklyCalendar) {
         InitializeWeekly(calendar as WeeklyCalendar, trigger.Calendar as IWeeklyCalendar);
     } else if (calendar is MonthlyCalendar) {
         InitializeMonthly(calendar as MonthlyCalendar, trigger.Calendar as IMonthlyCalendar);
     } else if (calendar is DailyCalendar) {
         InitializeDaily(calendar as DailyCalendar, trigger.Calendar as IDailyCalendar);
     } else if (calendar is CronCalendar) {
         InitializeCron(calendar as CronCalendar, trigger.Calendar as ICronCalendar);
     }
 }

		public static ICalendar GetCalendar (CalendarType type)
		{
			// Initialize the calendars here

			if (Gregorian == null)
				Gregorian = new GregorianCalendar ();

			// List the calendars here

			switch (type) {
			case CalendarType.Gregorian:
				return Gregorian;
			default:
				return null;
			}
		}

        /// <summary>
        /// Initializes a new instance of UptimeManagement
        /// </summary>
        public UptimeManagement(IDeviceConfiguration device, ICalendarFactory calendarFactory)
        {
            if (device == null)
            {
                throw new ArgumentNullException(nameof(device));
            }

            if (calendarFactory == null)
            {
                throw new ArgumentNullException(nameof(calendarFactory));
            }

            this.m_Device = device;
            this.m_Calendar = calendarFactory.GetCalendar(m_Device.UptimeCalendarType.ToCalendarCalendarType(),
                m_Device.CalendarProviderSettingsDirectory,
                m_Device.UptimeCalendarName);
        }

        public static DbCalendar CreateFromICalendar(ICalendar calendar)
        {
            DbCalendar dbCalendar = new DbCalendar();

            byte[] serializedCalendar = null;
            if (calendar != null)
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    bf.Serialize(ms, calendar);
                    serializedCalendar = ms.ToArray();
                }
            }

            dbCalendar.Calendar = serializedCalendar;

            return dbCalendar;
        }