// ----------------------------------------------------------------------
 protected HourTimeRange( int startYear, int startMonth, int startDay, int startHour, int hourCount, ITimeCalendar calendar )
     : base(GetPeriodOf( startYear, startMonth, startDay, startHour, hourCount ), calendar)
 {
     this.startHour = new DateTime( startYear, startMonth, startDay, startHour, 0, 0 );
     this.hourCount = hourCount;
     endHour = this.startHour.AddHours( hourCount );
 }

 // ----------------------------------------------------------------------
 protected DayTimeRange( int startYear, int startMonth, int startDay, int dayCount, ITimeCalendar calendar )
     : base(GetPeriodOf( startYear, startMonth, startDay, dayCount ), calendar)
 {
     this.startDay = new DateTime( startYear, startMonth, startDay );
     this.dayCount = dayCount;
     endDay = calendar.MapEnd( this.startDay.AddDays( dayCount ) );
 }

 // ----------------------------------------------------------------------
 protected MinuteTimeRange( int startYear, int startMonth, int startDay, int startHour, int startMinute, int minuteCount, ITimeCalendar calendar )
     : base(GetPeriodOf( startYear, startMonth, startDay, startHour, startMinute, minuteCount ), calendar)
 {
     this.startMinute = new DateTime( startYear, startMonth, startDay, startHour, startMinute, 0 );
     this.minuteCount = minuteCount;
     endMinute = this.startMinute.AddMinutes( minuteCount );
 }

        public CalendarDateDiff(ITimeCalendar timeCalendar) {
            timeCalendar.ShouldNotBeNull("timeCalendar");
            Guard.Assert(timeCalendar.StartOffset == TimeSpan.Zero, "Calendar의 StartOffset은 TimeSpan.Zero이어야 합니다.");
            Guard.Assert(timeCalendar.EndOffset == TimeSpan.Zero, "Calendar의 StartOffset은 TimeSpan.Zero이어야 합니다.");

            _calendar = timeCalendar;
        }

 // ----------------------------------------------------------------------
 protected YearTimeRange( int startYear, int yearCount, ITimeCalendar calendar )
     : base(GetPeriodOf( calendar.YearBaseMonth, startYear, yearCount ), calendar)
 {
     this.startYear = startYear;
     this.yearCount = yearCount;
     endYear = End.Year;
 }

 // ----------------------------------------------------------------------
 public static DateTime CalcTimeMoment( DateTime baseMoment, TimeUnit offsetUnit, long offsetCount = 1, ITimeCalendar calendar = null )
 {
     switch ( offsetUnit )
     {
         case TimeUnit.Tick:
             return baseMoment.AddTicks( offsetCount );
         case TimeUnit.Millisecond:
             DateTime offsetMillisecond = baseMoment.AddSeconds( offsetCount );
             return TimeTrim.Millisecond( offsetMillisecond, offsetMillisecond.Millisecond );
         case TimeUnit.Second:
             DateTime offsetSecond = baseMoment.AddSeconds( offsetCount );
             return TimeTrim.Second( offsetSecond, offsetSecond.Second );
         case TimeUnit.Minute:
             return new Minute(baseMoment, calendar).AddMinutes( ToInt( offsetCount ) ).Start;
         case TimeUnit.Hour:
             return new Hour( baseMoment, calendar ).AddHours( ToInt( offsetCount ) ).Start;
         case TimeUnit.Day:
             return new Day( baseMoment, calendar ).AddDays( ToInt( offsetCount ) ).Start;
         case TimeUnit.Week:
             return new Week( baseMoment, calendar ).AddWeeks( ToInt( offsetCount ) ).Start;
         case TimeUnit.Month:
             return new Month( baseMoment, calendar ).AddMonths( ToInt( offsetCount ) ).Start;
         case TimeUnit.Quarter:
             return new Quarter( baseMoment, calendar ).AddQuarters( ToInt( offsetCount ) ).Start;
         case TimeUnit.Halfyear:
             return new Halfyear( baseMoment, calendar ).AddHalfyears( ToInt( offsetCount ) ).Start;
         case TimeUnit.Year:
             return new Year( baseMoment, calendar ).AddYears( ToInt( offsetCount ) ).Start;
         default:
             throw new InvalidOperationException();
     }
 }

 // ----------------------------------------------------------------------
 protected WeekTimeRange( int year, int startWeek, int weekCount, ITimeCalendar calendar )
     : base(GetPeriodOf( year, startWeek, weekCount, calendar ), calendar)
 {
     this.year = year;
     this.startWeek = startWeek;
     this.weekCount = weekCount;
 }

 // ----------------------------------------------------------------------
 protected HalfyearTimeRange( int startYear, YearHalfyear startHalfyear, int halfyearCount, ITimeCalendar calendar )
     : base(GetPeriodOf( calendar.YearBaseMonth, startYear, startHalfyear, halfyearCount ), calendar)
 {
     this.startYear = startYear;
     this.startHalfyear = startHalfyear;
     this.halfyearCount = halfyearCount;
     TimeTool.AddHalfyear( startYear, startHalfyear, halfyearCount - 1, out endYear, out endHalfyear );
 }

 // ----------------------------------------------------------------------
 protected QuarterTimeRange( int startYear, YearQuarter startQuarter, int quarterCount, ITimeCalendar calendar )
     : base(GetPeriodOf( calendar.YearBaseMonth, startYear, startQuarter, quarterCount ), calendar)
 {
     this.startYear = startYear;
     this.startQuarter = startQuarter;
     this.quarterCount = quarterCount;
     TimeTool.AddQuarter( startYear, startQuarter, quarterCount - 1, out endYear, out endQuarter );
 }

 // ----------------------------------------------------------------------
 protected MonthTimeRange( int startYear, YearMonth startMonth, int monthCount, ITimeCalendar calendar )
     : base(GetPeriodOf( startYear, startMonth, monthCount ), calendar)
 {
     this.startYear = startYear;
     this.startMonth = startMonth;
     this.monthCount = monthCount;
     TimeTool.AddMonth( startYear, startMonth, monthCount - 1, out endYear, out endMonth );
 }

        protected HalfyearTimeRange(int startYear, HalfyearKind startHalfyearKind, int halfyearCount, ITimeCalendar calendar)
            : base(GetPeriodOf(calendar.YearBaseMonth, startYear, startHalfyearKind, halfyearCount), calendar) {
            StartYear = startYear;
            StartHalfyear = startHalfyearKind;

            HalfyearCount = halfyearCount;

            var endYearAndHalfyear = TimeTool.AddHalfyear(startHalfyearKind, startYear, halfyearCount - 1);
            EndYear = endYearAndHalfyear.Year ?? StartYear;
            EndHalfyear = endYearAndHalfyear.Halfyear ?? StartHalfyear;
        }

 // ----------------------------------------------------------------------
 public CalendarDateDiff( ITimeCalendar calendar )
 {
     if ( calendar == null )
     {
         throw new ArgumentNullException( "calendar" );
     }
     if ( calendar.StartOffset != TimeSpan.Zero )
     {
         throw new ArgumentOutOfRangeException( "calendar", "start offset" );
     }
     if ( calendar.EndOffset != TimeSpan.Zero )
     {
         throw new ArgumentOutOfRangeException( "calendar", "end offset" );
     }
     this.calendar = calendar;
 }

 // ----------------------------------------------------------------------
 public static ITimePeriod CalcTimePeriod( DateTime baseMoment, TimeUnit periodUnit, long periodDuration = 1,
     TimeUnit? offsetUnit = null, long offsetCount = 1, ITimeCalendar calendar = null)
 {
     if ( !offsetUnit.HasValue )
     {
         offsetUnit = periodUnit;
     }
     DateTime start = CalcTimeMoment( baseMoment, offsetUnit.Value, offsetCount, calendar );
     switch ( periodUnit )
     {
         case TimeUnit.Tick:
             return new TimeRange( start, start.AddTicks( periodDuration ) );
         case TimeUnit.Millisecond:
             return new TimeRange( start, start.AddMilliseconds( periodDuration ) );
         case TimeUnit.Second:
             return new TimeRange( start, start.AddSeconds( periodDuration ) );
         case TimeUnit.Minute:
             return periodDuration == 1 ? new Minute( start, calendar ) as ITimePeriod : new Minutes( start, ToInt( periodDuration ), calendar );
         case TimeUnit.Hour:
             return periodDuration == 1 ? new Hour( start, calendar ) as ITimePeriod : new Hours( start, ToInt( periodDuration ), calendar );
         case TimeUnit.Day:
             return periodDuration == 1 ? new Day( start, calendar ) as ITimePeriod : new Days( start, ToInt( periodDuration ), calendar );
         case TimeUnit.Week:
             return periodDuration == 1 ? new Week( start, calendar ) as ITimePeriod : new Weeks( start, ToInt( periodDuration ), calendar );
         case TimeUnit.Month:
             YearMonth startMonth = calendar != null ? calendar.YearBaseMonth : TimeSpec.CalendarYearStartMonth;
             return periodDuration == 1 ? new Month( start, calendar ) as ITimePeriod : new Months( start, startMonth, ToInt( periodDuration ), calendar );
         case TimeUnit.Quarter:
             return periodDuration == 1 ? new Quarter( start, calendar ) as ITimePeriod : new Quarters( start, YearQuarter.First, ToInt( periodDuration ), calendar );
         case TimeUnit.Halfyear:
             return periodDuration == 1 ? new Halfyear( start, calendar ) as ITimePeriod : new Halfyears( start, YearHalfyear.First, ToInt( periodDuration ), calendar );
         case TimeUnit.Year:
             return periodDuration == 1 ? new Year( start, calendar ) as ITimePeriod : new Years( start, ToInt( periodDuration ), calendar );
         default:
             throw new InvalidOperationException();
     }
 }

 /// <summary>
 /// <paramref name="moment"/>가 속한 시간의 기간을 반환합니다 (1시간)
 /// </summary>
 public static HourRange GetHourRange(this DateTime moment, ITimeCalendar timeCalendar = null) {
     return new HourRange(moment, timeCalendar ?? TimeCalendar.New());
 }

 /// <summary>
 /// <paramref name="moment"/>가 속한 하루서부터 <paramref name="dayCount"/>만큼의 일자의 기간
 /// </summary>
 public static DayRangeCollection GetDayRanges(this DateTime moment, int dayCount, ITimeCalendar timeCalendar = null) {
     return new DayRangeCollection(moment, dayCount, timeCalendar ?? TimeCalendar.New());
 }

 /// <summary>
 /// <paramref name="moment"/>가 속한 주에서 <paramref name="weekCount"/>만큼의 주의 기간
 /// </summary>
 public static WeekRangeCollection GetWeekRanges(this DateTime moment, int weekCount, ITimeCalendar timeCalendar = null) {
     return new WeekRangeCollection(moment, weekCount, timeCalendar ?? TimeCalendar.New());
 }

 /// <summary>
 /// <paramref name="moment"/>가 속한 분기부터 <paramref name="quarterCount"/> 갯수의 분기까지의 기간
 /// </summary>
 /// <param name="moment">기준 일자</param>
 /// <param name="quarterCount">분기 수</param>
 /// <param name="timeCalendar">기준 TimeCalendar</param>
 public static QuarterRangeCollection GetQuarterRanges(this DateTime moment, int quarterCount, ITimeCalendar timeCalendar = null) {
     return new QuarterRangeCollection(moment, quarterCount, timeCalendar ?? TimeCalendar.New());
 }

 /// <summary>
 /// <paramref name="moment"/>가 속한 년과 <paramref name="yearCount"/> 만큼의 기간
 /// </summary>
 public static YearRangeCollection GetYearRanges(this DateTime moment, int yearCount, ITimeCalendar timeCalendar = null) {
     return new YearRangeCollection(moment, yearCount, timeCalendar ?? TimeCalendar.New());
 }

        /// <summary>
        ///  <paramref name="moment"/>이 속하면서, <paramref name="periodKind"/>에 해당하는 <see cref="ICalendarTimeRange"/>을 구합니다.
        /// </summary>
        /// <param name="moment"></param>
        /// <param name="periodKind"></param>
        /// <param name="periodCount"></param>
        /// <param name="timeCalendar"></param>
        /// <returns></returns>
        public static ICalendarTimeRange GetPeriodsOf(this DateTime moment, PeriodKind periodKind, int periodCount,
                                                      ITimeCalendar timeCalendar) {
            if(IsDebugEnabled)
                log.Debug("날짜[{0}]가 속한 기간종류[{1}]의 기간을 구합니다. periodCount=[{2}], timeCalendar=[{3}]",
                          moment.ToSortableString(), periodKind, periodCount, timeCalendar);

            switch(periodKind) {
                case PeriodKind.Year:
                    return GetYearRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Halfyear:
                    return GetHalfyearRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Quarter:
                    return GetQuarterRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Month:
                    return GetMonthRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Week:
                    return GetWeekRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Day:
                    return GetDayRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Hour:
                    return GetHourRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Minute:
                    return GetMinuteRanges(moment, periodCount, timeCalendar);

                case PeriodKind.Second:
                    return new CalendarTimeRange(moment.TrimToMillisecond(), DurationUtil.Seconds(periodCount), timeCalendar);

                default:
                    throw new NotSupportedException("지원하지 않는 TimePeriod 종류입니다. periodKind=" + periodKind);
            }
        }

 // ----------------------------------------------------------------------
 public Year( int year, ITimeCalendar calendar )
     : base(year, 1, calendar)
 {
 }