private static void ArgumentsToSerializable <T>(SerializableSchedule.SerializableRule to, ScheduleRule from)
 {
     foreach (object arg in from.Arguments)
     {
         to.Arguments.Add(((T)arg).ToString());
     }
 }
        private static ScheduleRule ToRule(this SerializableSchedule.SerializableRule from)
        {
            ScheduleRule result = null;

            if (from != null)
            {
                result = new ScheduleRule((ScheduleRuleType)Enum.Parse(typeof(ScheduleRuleType), from.Type));
                switch (result.Type)
                {
                case ScheduleRuleType.Channels:
                case ScheduleRuleType.NotOnChannels:
                    from.Arguments.ForEach(a => result.Arguments.Add(new Guid(a)));
                    break;

                case ScheduleRuleType.AroundTime:
                case ScheduleRuleType.StartingBetween:
                    from.Arguments.ForEach(a => result.Arguments.Add(ParseScheduleTime(a)));
                    break;

                case ScheduleRuleType.OnDate:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(ParseIsoDate(from.Arguments[0]));
                    }
                    break;

                case ScheduleRuleType.ManualSchedule:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(ParseIsoDate(from.Arguments[0]));
                    }
                    if (from.Arguments.Count > 1)
                    {
                        result.Arguments.Add(ParseScheduleTime(from.Arguments[1]));
                    }
                    break;

                case ScheduleRuleType.DaysOfWeek:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(Enum.Parse(typeof(ScheduleDaysOfWeek), from.Arguments[0]));
                    }
                    if (from.Arguments.Count > 1)
                    {
                        result.Arguments.Add(ParseIsoDate(from.Arguments[1]));
                    }
                    break;

                case ScheduleRuleType.TitleDoesNotContain:
                case ScheduleRuleType.SubTitleDoesNotContain:
                case ScheduleRuleType.EpisodeNumberDoesNotContain:
                case ScheduleRuleType.DescriptionDoesNotContain:
                case ScheduleRuleType.ProgramInfoDoesNotContain:
                case ScheduleRuleType.TitleStartsWith:
                case ScheduleRuleType.SubTitleStartsWith:
                case ScheduleRuleType.EpisodeNumberStartsWith:
                case ScheduleRuleType.TitleEquals:
                case ScheduleRuleType.SubTitleEquals:
                case ScheduleRuleType.EpisodeNumberEquals:
                case ScheduleRuleType.TitleContains:
                case ScheduleRuleType.SubTitleContains:
                case ScheduleRuleType.EpisodeNumberContains:
                case ScheduleRuleType.DescriptionContains:
                case ScheduleRuleType.ProgramInfoContains:
                case ScheduleRuleType.CategoryEquals:
                case ScheduleRuleType.CategoryDoesNotEqual:
                case ScheduleRuleType.DirectedBy:
                case ScheduleRuleType.WithActor:
                    from.Arguments.ForEach(a => result.Arguments.Add(a));
                    break;

                case ScheduleRuleType.SkipRepeats:
                case ScheduleRuleType.NewEpisodesOnly:
                case ScheduleRuleType.NewTitlesOnly:
                    from.Arguments.ForEach(a => result.Arguments.Add(bool.Parse(a)));
                    break;
                }
            }
            return(result);
        }
        private static SerializableSchedule.SerializableRule ToSerializableRule(this ScheduleRule from)
        {
            SerializableSchedule.SerializableRule result = null;
            if (from != null)
            {
                result = new SerializableSchedule.SerializableRule()
                {
                    Type      = from.Type.ToString(),
                    Arguments = new List <string>()
                };
                switch (from.Type)
                {
                case ScheduleRuleType.Channels:
                case ScheduleRuleType.NotOnChannels:
                    ArgumentsToSerializable <Guid>(result, from);
                    break;

                case ScheduleRuleType.AroundTime:
                case ScheduleRuleType.StartingBetween:
                    from.Arguments.ForEach(a => result.Arguments.Add(new DateTime(((ScheduleTime)a).Ticks, DateTimeKind.Local).ToString("HH:mm:ss")));
                    break;

                case ScheduleRuleType.ManualSchedule:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(((DateTime)from.Arguments[0]).ToString("yyyy-MM-ddTHH:mm:sszzz"));
                    }
                    if (from.Arguments.Count > 1)
                    {
                        result.Arguments.Add(new DateTime(((ScheduleTime)from.Arguments[1]).Ticks, DateTimeKind.Local).ToString("HH:mm:ss"));
                    }
                    break;

                case ScheduleRuleType.OnDate:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(((DateTime)from.Arguments[0]).ToString("yyyy-MM-ddTHH:mm:sszzz"));
                    }
                    break;

                case ScheduleRuleType.DaysOfWeek:
                    if (from.Arguments.Count > 0)
                    {
                        result.Arguments.Add(((int)from.Arguments[0]).ToString());
                    }
                    if (from.Arguments.Count > 1)
                    {
                        result.Arguments.Add(((DateTime)from.Arguments[1]).ToString("yyyy-MM-ddTHH:mm:sszzz"));
                    }
                    break;

                case ScheduleRuleType.TitleDoesNotContain:
                case ScheduleRuleType.SubTitleDoesNotContain:
                case ScheduleRuleType.EpisodeNumberDoesNotContain:
                case ScheduleRuleType.DescriptionDoesNotContain:
                case ScheduleRuleType.ProgramInfoDoesNotContain:
                case ScheduleRuleType.TitleStartsWith:
                case ScheduleRuleType.SubTitleStartsWith:
                case ScheduleRuleType.EpisodeNumberStartsWith:
                case ScheduleRuleType.TitleEquals:
                case ScheduleRuleType.SubTitleEquals:
                case ScheduleRuleType.EpisodeNumberEquals:
                case ScheduleRuleType.TitleContains:
                case ScheduleRuleType.SubTitleContains:
                case ScheduleRuleType.EpisodeNumberContains:
                case ScheduleRuleType.DescriptionContains:
                case ScheduleRuleType.ProgramInfoContains:
                case ScheduleRuleType.CategoryEquals:
                case ScheduleRuleType.CategoryDoesNotEqual:
                case ScheduleRuleType.DirectedBy:
                case ScheduleRuleType.WithActor:
                    ArgumentsToSerializable <string>(result, from);
                    break;

                case ScheduleRuleType.SkipRepeats:
                case ScheduleRuleType.NewEpisodesOnly:
                case ScheduleRuleType.NewTitlesOnly:
                    ArgumentsToSerializable <bool>(result, from);
                    break;
                }
            }
            return(result);
        }