//
//  SwiftDate
//  Parse, validate, manipulate, and display dates, time and timezones in Swift
//
//  Created by Daniele Margutti
//   - Web: https://www.danielemargutti.com
//   - Twitter: https://twitter.com/danielemargutti
//   - Mail: hello@danielemargutti.com
//
//  Copyright © 2019 Daniele Margutti. Licensed under MIT License.
//

import Foundation

public extension DateInRegion {

	// MARK: - Random Date Generator

	/// Generate a sequence of dates between a range.
	///
	/// - Parameters:
	///   - count: number of dates to generate.
	///   - initial: lower date bound.
	///   - final: upper date bound.
	///   - region: region of the dates.
	/// - Returns: array of dates
	static func randomDates(count: Int, between initial: DateInRegion, and final: DateInRegion,
								   region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {
		var list: [DateInRegion] = []
		for _ in 0..<count {
			list.append(DateInRegion.randomDate(between: initial, and: final, region: region))
		}
		return list
	}

	/// Return a date between now and a specified amount days ealier.
	///
	/// - Parameters:
	///   - days: days range
	///   - region: destination region, `nil` to use the default region
	/// - Returns: random date
	static func randomDate(withinDaysBeforeToday days: Int,
								  region: Region = SwiftDate.defaultRegion) -> DateInRegion {
		let today = DateInRegion(region: region)
		let earliest = DateInRegion(today.date.addingTimeInterval(TimeInterval(-days * 24 * 60 * 60)), region: region)
		return DateInRegion.randomDate(between: earliest, and: today)
	}

	/// Generate a random date in given region.
	///
	/// - Parameter region: destination region, `nil` to use the default region
	/// - Returns: random date
	static func randomDate(region: Region = SwiftDate.defaultRegion) -> DateInRegion {
		let randomTime = TimeInterval(UInt32.random(in: UInt32.min..<UInt32.max))
		let absoluteDate = Date(timeIntervalSince1970: randomTime)
		return DateInRegion(absoluteDate, region: region)
	}

	/// Generate a random date between two intervals.
	///
	/// - Parameters:
	///   - initial: lower bound date
	///   - final: upper bound date
	///   - region: destination region, `nil` to use the default region
	/// - Returns: random Date
	static func randomDate(between initial: DateInRegion, and final: DateInRegion,
								  region: Region = SwiftDate.defaultRegion) -> DateInRegion {
		let interval = final.timeIntervalSince(initial)
		let randomInterval = TimeInterval(UInt32.random(in: UInt32.min..<UInt32(interval)))
		return initial.addingTimeInterval(randomInterval)
	}

	/// Return the oldest date in given list (timezone is ignored, comparison uses absolute date).
	///
	/// - Parameter list: list of dates
	/// - Returns: a tuple with the index of the oldest date and its instance.
	static func oldestIn(list: [DateInRegion]) -> DateInRegion? {
		guard list.count > 0 else { return nil }
		guard list.count > 1 else { return list.first! }
		return list.min(by: {
			return $0 < $1
		})
	}

	/// Sort date by oldest, with the oldest date on top.
	///
	/// - Parameter list: list to sort
	/// - Returns: sorted array
	static func sortedByOldest(list: [DateInRegion]) -> [DateInRegion] {
		return list.sorted(by: { $0.date.compare($1.date) == .orderedAscending })
	}

	/// Sort date by newest, with the newest date on top.
	///
	/// - Parameter list: list to sort
	/// - Returns: sorted array
	static func sortedByNewest(list: [DateInRegion]) -> [DateInRegion] {
		return list.sorted(by: { $0.date.compare($1.date) == .orderedDescending })
	}

	/// Return the newest date in given list (timezone is ignored, comparison uses absolute date).
	///
	/// - Parameter list: list of dates
	/// - Returns: a tuple with the index of the newest date and its instance.
	static func newestIn(list: [DateInRegion]) -> DateInRegion? {
		guard list.count > 0 else { return nil }
		guard list.count > 1 else { return list.first! }
		return list.max(by: {
			return $0 < $1
		})
	}

	/// Enumerate dates between two intervals by adding specified time components and return an array of dates.
	/// `startDate` interval will be the first item of the resulting array.
	/// The last item of the array is evaluated automatically and maybe not equal to `endDate`.
	///
	/// - Parameters:
	///   - start: starting date
	///   - endDate: ending date
	///   - increment: components to add
	/// - Returns: array of dates
	static func enumerateDates(from startDate: DateInRegion, to endDate: DateInRegion, increment: DateComponents) -> [DateInRegion] {
		return DateInRegion.enumerateDates(from: startDate, to: endDate, increment: { _ in
			return increment
		})
	}

	/// Enumerate dates between two intervals by adding specified time components defined in a closure and return an array of dates.
	/// `startDate` interval will be the first item of the resulting array.
	/// The last item of the array is evaluated automatically and maybe not equal to `endDate`.
	///
	/// - Parameters:
	///   - start: starting date
	///   - endDate: ending date
	///   - increment: increment function. It get the last generated date and require a valida `DateComponents` instance which define the increment
	/// - Returns: array of dates
	static func enumerateDates(from startDate: DateInRegion, to endDate: DateInRegion, increment: ((DateInRegion) -> (DateComponents))) -> [DateInRegion] {
		guard startDate.calendar == endDate.calendar else {
			debugPrint("Cannot enumerate dates between two different region's calendars. Return empty array.")
			return []
		}

		var dates: [DateInRegion] = []
		var currentDate = startDate
		while currentDate <= endDate {
			dates.append(currentDate)
			currentDate = (currentDate + increment(currentDate))
		}
		return dates
	}

	/// Returns a new DateInRegion that is initialized at the start of a specified unit of time.
	///
	/// - Parameter unit: time unit value.
	/// - Returns: instance at the beginning of the time unit; `self` if fails.
	func dateAtStartOf(_ unit: Calendar.Component) -> DateInRegion {
		#if os(Linux)
		guard let result = (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, for: date) else {
			return self
		}
		return DateInRegion(result.start, region: region)
		#else
		var start: NSDate?
		var interval: TimeInterval = 0
		guard (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, start: &start, interval: &interval, for: date),
			let startDate = start else {
				return self
		}
		return DateInRegion(startDate as Date, region: region)
		#endif
	}

	/// Return a new DateInRegion that is initialized at the start of the specified components
	/// executed in order.
	///
	/// - Parameter units: sequence of transformations as time unit components
	/// - Returns: new date at the beginning of the passed components, intermediate results if fails.
	func dateAtStartOf(_ units: [Calendar.Component]) -> DateInRegion {
		return units.reduce(self) { (currentDate, currentUnit) -> DateInRegion in
			return currentDate.dateAtStartOf(currentUnit)
		}
	}

	/// Returns a new Moment that is initialized at the end of a specified unit of time.
	///
	/// - parameter unit: time unit value.
	///
	/// - returns: A new Moment instance.
	func dateAtEndOf(_ unit: Calendar.Component) -> DateInRegion {
		// RangeOfUnit returns the start of the next unit; we will subtract one thousandth of a second
		#if os(Linux)
		guard let result = (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, for: date) else {
			return self
		}
		let startOfNextUnit = result.start.addingTimeInterval(result.duration)
		let endOfThisUnit = Date(timeInterval: -0.001, since: startOfNextUnit)
		return DateInRegion(endOfThisUnit, region: region)
		#else
		var start: NSDate?
		var interval: TimeInterval = 0
		guard (self.region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, start: &start, interval: &interval, for: date),
		let startDate = start else {
			return self
		}
		let startOfNextUnit = startDate.addingTimeInterval(interval)
		let endOfThisUnit = Date(timeInterval: -0.001, since: startOfNextUnit as Date)
		return DateInRegion(endOfThisUnit, region: region)
		#endif
	}

	/// Return a new DateInRegion that is initialized at the end of the specified components
	/// executed in order.
	///
	/// - Parameter units: sequence of transformations as time unit components
	/// - Returns: new date at the end of the passed components, intermediate results if fails.
	func dateAtEndOf(_ units: [Calendar.Component]) -> DateInRegion {
		return units.reduce(self) { (currentDate, currentUnit) -> DateInRegion in
			return currentDate.dateAtEndOf(currentUnit)
		}
	}

	/// Create a new date by altering specified components of the receiver.
	/// Note: `calendar` and `timezone` are ignored.
	/// Note: some components may alter the date cyclically (like setting both `.year` and `.yearForWeekOfYear`) and
	/// may results in a wrong evaluated date.
	///
	/// - Parameter components: components to alter with their new values.
	/// - Returns: new altered `DateInRegion` instance
	func dateBySet(_ components: [Calendar.Component: Int?]) -> DateInRegion? {
		var dateComponents = DateComponents()
		dateComponents.year = (components[.year] ?? year)
		dateComponents.month = (components[.month] ?? month)
		dateComponents.day = (components[.day] ?? day)
		dateComponents.hour = (components[.hour] ?? hour)
		dateComponents.minute = (components[.minute] ?? minute)
		dateComponents.second = (components[.second] ?? second)
		dateComponents.nanosecond = (components[.nanosecond] ?? nanosecond)

		// Some components may interfer with others, so we'll set it them only if explicitly set.
		if let weekday = components[.weekday] {
			dateComponents.weekday = weekday
		}
		if let weekOfYear = components[.weekOfYear] {
			dateComponents.weekOfYear = weekOfYear
		}
		if let weekdayOrdinal = components[.weekdayOrdinal] {
			dateComponents.weekdayOrdinal = weekdayOrdinal
		}
		if let yearForWeekOfYear = components[.yearForWeekOfYear] {
			dateComponents.yearForWeekOfYear = yearForWeekOfYear
		}

		guard let newDate = calendar.date(from: dateComponents) else { return nil }
		return DateInRegion(newDate, region: region)
	}

	/// Create a new date by altering specified time components.
	///
	/// - Parameters:
	///   - hour: hour to set (`nil` to leave it unaltered)
	///   - min: min to set (`nil` to leave it unaltered)
	///   - secs: sec to set (`nil` to leave it unaltered)
	///   - ms: milliseconds to set (`nil` to leave it unaltered)
	///   - options: options for calculation
	/// - Returns: new altered `DateInRegion` instance
	func dateBySet(hour: Int?, min: Int?, secs: Int?, ms: Int? = nil, options: TimeCalculationOptions = TimeCalculationOptions()) -> DateInRegion? {
		guard let date = calendar.date(bySettingHour: (hour ?? self.hour),
											minute: (min ?? self.minute),
											second: (secs ?? self.second),
											of: self.date,
											matchingPolicy: options.matchingPolicy,
											repeatedTimePolicy: options.repeatedTimePolicy,
											direction: options.direction) else { return nil }
		guard let ms = ms else {
			return DateInRegion(date, region: region)
		}
		var timestamp = date.timeIntervalSince1970.rounded(.down)
		timestamp += Double(ms) / 1000.0
		return DateInRegion(Date(timeIntervalSince1970: timestamp), region: region)
	}

	/// Creates a new instance by truncating the components
	///
	/// - Parameter components: components to truncate.
	/// - Returns: new date with truncated components.
	func dateTruncated(at components: [Calendar.Component]) -> DateInRegion? {
		var dateComponents = self.dateComponents

		for component in components {
			switch component {
			case .month:		dateComponents.month = 1
			case .day:			dateComponents.day = 1
			case .hour:			dateComponents.hour = 0
			case .minute:		dateComponents.minute = 0
			case .second:		dateComponents.second = 0
			case .nanosecond:	dateComponents.nanosecond = 0
			default:			continue
			}
		}

		guard let newDate = calendar.date(from: dateComponents) else { return nil }
		return DateInRegion(newDate, region: region)
	}

	/// Creates a new instance by truncating the components starting from given components down the granurality.
	///
	/// - Parameter component: The component to be truncated from.
	/// - Returns: new date with truncated components.
	func dateTruncated(from component: Calendar.Component) -> DateInRegion? {
		switch component {
		case .month:		return dateTruncated(at: [.month, .day, .hour, .minute, .second, .nanosecond])
		case .day:			return dateTruncated(at: [.day, .hour, .minute, .second, .nanosecond])
		case .hour:			return dateTruncated(at: [.hour, .minute, .second, .nanosecond])
		case .minute:		return dateTruncated(at: [.minute, .second, .nanosecond])
		case .second:		return dateTruncated(at: [.second, .nanosecond])
		case .nanosecond:	return dateTruncated(at: [.nanosecond])
		default:			return self
		}
	}

	/// Round a given date time to the passed style (off|up|down).
	///
	/// - Parameter style: rounding mode.
	/// - Returns: rounded date
	func dateRoundedAt(_ style: RoundDateMode) -> DateInRegion {
		switch style {
		case .to5Mins:			return dateRoundedAt(.toMins(5))
		case .to10Mins:			return dateRoundedAt(.toMins(10))
		case .to30Mins:			return dateRoundedAt(.toMins(30))
		case .toCeil5Mins:		return dateRoundedAt(.toCeilMins(5))
		case .toCeil10Mins:		return dateRoundedAt(.toCeilMins(10))
		case .toCeil30Mins:		return dateRoundedAt(.toCeilMins(30))
		case .toFloor5Mins:		return dateRoundedAt(.toFloorMins(5))
		case .toFloor10Mins:	return dateRoundedAt(.toFloorMins(10))
		case .toFloor30Mins:	return dateRoundedAt(.toFloorMins(30))

		case .toMins(let minuteInterval):
			let onesDigit: Int = (minute % 10)
			if onesDigit < 5 {
				return dateRoundedAt(.toFloorMins(minuteInterval))
			} else {
				return dateRoundedAt(.toCeilMins(minuteInterval))
			}

		case .toCeilMins(let minuteInterval):
			let remain: Int = (minute % minuteInterval)
			let value = (( Int(1.minutes.timeInterval) * (minuteInterval - remain)) - second)
			return dateByAdding(value, .second)

		case .toFloorMins(let minuteInterval):
			let remain: Int = (minute % minuteInterval)
			let value = -((Int(1.minutes.timeInterval) * remain) + second)
			return dateByAdding(value, .second)

		}
	}

	/// Offset a date by n calendar components.
	/// Note: This operation can be functionally chained.
	///
	/// - Parameters:
	///   - count: value of the offset (maybe negative).
	///   - component: component to offset.
	/// - Returns: new altered date.
	func dateByAdding(_ count: Int, _ component: Calendar.Component) -> DateInRegion {
		var newComponent = DateComponents(second: 0)
		switch component {
		case .era: 					newComponent = DateComponents(era: count)
		case .year: 				newComponent = DateComponents(year: count)
		case .month: 				newComponent = DateComponents(month: count)
		case .day: 					newComponent = DateComponents(day: count)
		case .hour: 				newComponent = DateComponents(hour: count)
		case .minute: 				newComponent = DateComponents(minute: count)
		case .second:				newComponent = DateComponents(second: count)
		case .weekday:				newComponent = DateComponents(weekday: count)
		case .weekdayOrdinal: 		newComponent = DateComponents(weekdayOrdinal: count)
		case .quarter: 				newComponent = DateComponents(quarter: count)
		case .weekOfMonth: 			newComponent = DateComponents(weekOfMonth: count)
		case .weekOfYear: 			newComponent = DateComponents(weekOfYear: count)
		case .yearForWeekOfYear: 	newComponent = DateComponents(yearForWeekOfYear: count)
		case .nanosecond: 			newComponent = DateComponents(nanosecond: count)
		default: break // .calendar and .timezone does nothing in this context
		}

		guard let newDate = region.calendar.date(byAdding: newComponent, to: date) else {
			return self // failed to add component, return unmodified date
		}
		return DateInRegion(newDate, region: region)
	}

	/// Return related date starting from the receiver attributes.
	///
	/// - Parameter type: related date to obtain.
	/// - Returns: instance of the related date; if fails the same unmodified date is returned
	func dateAt(_ type: DateRelatedType) -> DateInRegion {
		switch type {
		case .startOfDay:
			return calendar.startOfDay(for: date).in(region: region)
		case .endOfDay:
			return dateByAdding(1, .day).dateAt(.startOfDay).dateByAdding(-1, .second)
		case .startOfWeek:
			let components = calendar.dateComponents([.yearForWeekOfYear, .weekOfYear], from: date)
			return calendar.date(from: components)!.in(region: region)
		case .endOfWeek:
			return dateAt(.startOfWeek).dateByAdding(7, .day).dateByAdding(-1, .second)
		case .startOfMonth:
			return dateBySet([.day: 1, .hour: 1, .minute: 1, .second: 1, .nanosecond: 1])!
		case .endOfMonth:
			return dateByAdding((monthDays - day), .day).dateAtEndOf(.day)
		case .tomorrow:
			return dateByAdding(1, .day)
		case .tomorrowAtStart:
			return dateByAdding(1, .day).dateAtStartOf(.day)
		case .yesterday:
			return dateByAdding(-1, .day)
		case .yesterdayAtStart:
			return dateByAdding(-1, .day).dateAtStartOf(.day)
		case .nearestMinute(let nearest):
			let minutes = (minute + nearest / 2) / nearest * nearest
			return dateBySet([.minute: minutes])!
		case .nearestHour(let nearest):
			let hours = (hour + nearest / 2) / nearest * nearest
			return dateBySet([.hour: hours, .minute: 0])!
		case .nextWeekday(let weekday):
			var cal = Calendar(identifier: calendar.identifier)
			cal.firstWeekday = 2 // Sunday = 1, Saturday = 7
			var components = DateComponents()
			components.weekday = weekday.rawValue
			guard let next = cal.nextDate(after: date, matching: components, matchingPolicy: .nextTimePreservingSmallerComponents) else {
				return self
			}
			return DateInRegion(next, region: region)
		case .nextDSTDate:
			guard let nextDate = region.timeZone.nextDaylightSavingTimeTransition(after: date) else {
				return self
			}
			return DateInRegion(nextDate, region: region)
		case .prevMonth:
			return dateByAdding(-1, .month).dateAtStartOf(.month).dateAtStartOf(.day)
		case .nextMonth:
			return dateByAdding(1, .month).dateAtStartOf(.month).dateAtStartOf(.day)
		case .prevWeek:
			return dateByAdding(-1, .weekOfYear).dateAtStartOf(.weekOfYear).dateAtStartOf(.day)
		case .nextWeek:
			return dateByAdding(1, .weekOfYear).dateAtStartOf(.weekOfYear).dateAtStartOf(.day)
		case .nextYear:
			return dateByAdding(1, .year).dateAtStartOf(.year)
		case .prevYear:
			return dateByAdding(-1, .year).dateAtStartOf(.year)
		case .nextDSTTransition:
			guard let transitionDate = region.timeZone.nextDaylightSavingTimeTransition(after: date) else {
				return self
			}
			return DateInRegion(transitionDate, region: region)
		}
	}

	/// Create a new instance of the date in the same region with time shifted by given time interval.
	///
	/// - Parameter interval: time interval to shift; maybe negative.
	/// - Returns: new instance of the `DateInRegion`
	func addingTimeInterval(_ interval: TimeInterval) -> DateInRegion {
		return DateInRegion(date.addingTimeInterval(interval), region: region)
	}

	// MARK: - Conversion

	/// Convert a date to a new calendar/timezone/locale.
	/// Only non `nil` values are used, other values are inherithed by the receiver's region.
	///
	/// - Parameters:
	///   - calendar: non `nil` value to change the calendar
	///   - timezone: non `nil` value to change the timezone
	///   - locale: non `nil` value to change the locale
	/// - Returns: converted date
	func convertTo(calendar: CalendarConvertible? = nil, timezone: ZoneConvertible? = nil, locale: LocaleConvertible? = nil) -> DateInRegion {
		let newRegion = Region(calendar: (calendar ?? region.calendar),
							   zone: (timezone ?? region.timeZone),
							   locale: (locale ?? region.locale))
		return convertTo(region: newRegion)
	}

	/// Return the dates for a specific weekday inside given month of specified year.
	/// Ie. get me all the saturdays of Feb 2018.
	/// NOTE: Values are returned in order.
	///
	/// - Parameters:
	///   - weekday: weekday target.
	///   - month: month target.
	///   - year: year target.
	///   - region: region target, omit to use `SwiftDate.defaultRegion`
	/// - Returns: Ordered list of the dates for given weekday into given month.
	static func datesForWeekday(_ weekday: WeekDay, inMonth month: Int, ofYear year: Int,
									   region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {
		let fromDate = DateInRegion(year: year, month: month, day: 1, hour: 0, minute: 0, second: 0, nanosecond: 0, region: region)
		let toDate = fromDate.dateAt(.endOfMonth)
		return DateInRegion.datesForWeekday(weekday, from: fromDate, to: toDate, region: region)
	}

	/// Return the dates for a specific weekday inside a specified date range.
	/// NOTE: Values are returned in order.
	///
	/// - Parameters:
	///   - weekday: weekday target.
	///   - startDate: from date of the range.
	///   - endDate: to date of the range.
	///   - region: region target, omit to use `SwiftDate.defaultRegion`
	/// - Returns: Ordered list of the dates for given weekday in passed range.
	static func datesForWeekday(_ weekday: WeekDay, from startDate: DateInRegion, to endDate: DateInRegion,
									   region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {

		let calendarObj = region.calendar
		let startDateWeekDay = Int(calendarObj.component(.weekday, from: startDate.date))
		let desiredDay = weekday.rawValue

		let offset = (desiredDay - startDateWeekDay + 7) % 7
		let firstOccurrence = calendarObj.startOfDay(for: calendarObj.date(byAdding: DateComponents(day: offset), to: startDate.date)!)
		guard firstOccurrence.timeIntervalSince1970 < endDate.timeIntervalSince1970 else {
			return []
		}
		var dateOccurrences = [DateInRegion(firstOccurrence, region: region)]
		while true {
			let nextDate = DateInRegion(calendarObj.date(byAdding: DateComponents(day: 7), to: dateOccurrences.last!.date)!,
										region: region)
			guard nextDate < endDate else {
				break
			}
			dateOccurrences.append(nextDate)
		}
		return dateOccurrences
	}

}

public extension DateInRegion {

    /// Returns the date at the given week number and week day preserving smaller components (hour, minute, seconds)
    ///
    /// For example: to get the third friday of next month
    ///         let today = DateInRegion()
    ///         let result = today.dateAt(weekdayOrdinal: 3, weekday: .friday, monthNumber: today.month + 1)
    ///
    /// - Parameters:
    ///     - weekdayOrdinal: the week number (by set position in a recurrence rule)
    ///     - weekday: WeekDay
    ///     - monthNumber: a number from 1 to 12 representing the month, optional parameter
    ///     - yearNumber: a number representing the year, optional parameter
    /// - Returns: new date created with the given parameters
    func dateAt(weekdayOrdinal: Int, weekday: WeekDay, monthNumber: Int? = nil,
                yearNumber: Int? = nil) -> DateInRegion {
        let monthNum = monthNumber ?? month
        let yearNum = yearNumber ?? year

        var requiredWeekNum = weekdayOrdinal
        var result = DateInRegion(year: yearNum, month: monthNum, day: 1, hour: hour,
                                  minute: minute, second: second, nanosecond: nanosecond, region: region)

        if result.weekday == weekday.rawValue {
            requiredWeekNum -= 1
        }

        while requiredWeekNum > 0 {
            result = result.nextWeekday(weekday)
            requiredWeekNum -= 1
        }

        return result
    }

    /// Returns the date on the given day of month preserving smaller components
    func dateAt(dayOfMonth: Int, monthNumber: Int? = nil,
                yearNumber: Int? = nil) -> DateInRegion {
        let monthNum = monthNumber ?? month
        let yearNum = yearNumber ?? year

        let result = DateInRegion(year: yearNum, month: monthNum, day: dayOfMonth,
                                  hour: hour, minute: minute, second: second,
                                  nanosecond: nanosecond, region: region)

        return result
    }

    /// Returns the date after given number of weeks on the given day of week
    func dateAfter(weeks count: Int, on weekday: WeekDay) -> DateInRegion {
        var result = self.dateByAdding(count, .weekOfMonth)
        if result.weekday == weekday.rawValue {
            return result
        } else if result.weekday > weekday.rawValue {
            result = result.dateByAdding(-1, .weekOfMonth)
        }
        return result.nextWeekday(weekday)
    }

    /// Returns the next weekday preserving smaller components
    ///
    /// - Parameters:
    ///   - weekday: weekday to get.
    ///   - region: region target, omit to use `SwiftDate.defaultRegion`
    /// - Returns: `DateInRegion`
    func nextWeekday(_ weekday: WeekDay) -> DateInRegion {
        var components = DateComponents()
        components.weekday = weekday.rawValue
        components.hour = hour
        components.second = second
        components.minute = minute

        guard let next = region.calendar.nextDate(after: date, matching: components,
                                                  matchingPolicy: .nextTimePreservingSmallerComponents) else {
                                                    return self
        }

        return DateInRegion(next, region: region)
    }

    /// Returns next date with the given weekday and the given week number
    func next(_ weekday: WeekDay, withWeekOfMonth weekNumber: Int,
              andMonthNumber monthNumber: Int? = nil) -> DateInRegion {
        var result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday, monthNumber: monthNumber)

        if result <= self {

            if let monthNum = monthNumber {
                result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday,
                                     monthNumber: monthNum, yearNumber: self.year + 1)
            } else {
                result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday, monthNumber: self.month + 1)
            }

        }

        return result
    }

    /// Returns the next day of month preserving smaller components (hour, minute, seconds)
    func next(dayOfMonth: Int, monthOfYear: Int? = nil) -> DateInRegion {
        var components = DateComponents()
        components.day = dayOfMonth
        components.month = monthOfYear
        components.hour = hour
        components.second = second
        components.minute = minute

        guard let next = region.calendar.nextDate(after: date, matching: components,
                                                  matchingPolicy: .nextTimePreservingSmallerComponents) else {
                                                    return self
        }

        return DateInRegion(next, region: region)
    }
}