DateIntervalFormatter.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

import CoreFoundation

#if _runtime(_ObjC)
internal let kCFDateIntervalFormatterNoStyle = CFDateIntervalFormatterStyle.noStyle
internal let kCFDateIntervalFormatterShortStyle = CFDateIntervalFormatterStyle.shortStyle
internal let kCFDateIntervalFormatterMediumStyle = CFDateIntervalFormatterStyle.mediumStyle
internal let kCFDateIntervalFormatterLongStyle = CFDateIntervalFormatterStyle.longStyle
internal let kCFDateIntervalFormatterFullStyle = CFDateIntervalFormatterStyle.fullStyle

internal let kCFDateIntervalFormatterBoundaryStyleDefault = _CFDateIntervalFormatterBoundaryStyle.cfDateIntervalFormatterBoundaryStyleDefault
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
internal let kCFDateIntervalFormatterBoundaryStyleMinimizeAdjacentMonths = _CFDateIntervalFormatterBoundaryStyle.cfDateIntervalFormatterBoundaryStyleMinimizeAdjacentMonths
#endif
#endif

extension DateIntervalFormatter {
    // Keep these in sync with CFDateIntervalFormatterStyle.
    public enum Style: UInt {
        case none = 0
        case short = 1
        case medium = 2
        case long = 3
        case full = 4
    }
}

internal extension DateIntervalFormatter.Style {
    init(_ cfStyle: CFDateIntervalFormatterStyle) {
        switch cfStyle {
        case kCFDateIntervalFormatterNoStyle: self = .none
        case kCFDateIntervalFormatterShortStyle: self = .short
        case kCFDateIntervalFormatterMediumStyle: self = .medium
        case kCFDateIntervalFormatterLongStyle: self = .long
        case kCFDateIntervalFormatterFullStyle: self = .full
        default: fatalError()
        }
    }
}

internal extension CFDateIntervalFormatterStyle {
    init(_ style: DateIntervalFormatter.Style) {
        switch style {
        case .none: self = kCFDateIntervalFormatterNoStyle
        case .short: self = kCFDateIntervalFormatterShortStyle
        case .medium: self = kCFDateIntervalFormatterMediumStyle
        case .long: self = kCFDateIntervalFormatterLongStyle
        case .full: self = kCFDateIntervalFormatterFullStyle
        }
    }
}

internal extension DateIntervalFormatter.BoundaryStyle {
    init(_ cfStyle: _CFDateIntervalFormatterBoundaryStyle) {
        switch cfStyle {
        case kCFDateIntervalFormatterBoundaryStyleDefault: self = .default
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
        case kCFDateIntervalFormatterBoundaryStyleMinimizeAdjacentMonths: self = .minimizeAdjacentMonths
#endif
        default: fatalError()
        }
    }
}

internal extension _CFDateIntervalFormatterBoundaryStyle {
    init(_ style: DateIntervalFormatter.BoundaryStyle) {
        switch style {
        case .default: self = kCFDateIntervalFormatterBoundaryStyleDefault
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
        case .minimizeAdjacentMonths: self = kCFDateIntervalFormatterBoundaryStyleMinimizeAdjacentMonths
#endif
        }
    }
}

// DateIntervalFormatter is used to format the range between two NSDates in a locale-sensitive way.
// DateIntervalFormatter returns nil and NO for all methods in Formatter.

open class DateIntervalFormatter: Formatter {
    let core: CFDateIntervalFormatter
    
    public override init() {
        core = CFDateIntervalFormatterCreate(nil, nil, kCFDateIntervalFormatterShortStyle, kCFDateIntervalFormatterShortStyle)
        super.init()
    }

    private init(cfFormatter: CFDateIntervalFormatter) {
        self.core = cfFormatter
        super.init()
    }
    
    public required init?(coder: NSCoder) {
        guard coder.allowsKeyedCoding else { fatalError("Requires a keyed coding-capable archiver.") }
        
        func cfObject<T: NSObject & _CFBridgeable>(of aClass: T.Type, from coder: NSCoder, forKey key: String) -> T.CFType? {
            if coder.containsValue(forKey: key) {
                let object = coder.decodeObject(forKey: key) as? T
                return object?._cfObject
            } else {
                return nil
            }
        }
        
        let core = CFDateIntervalFormatterCreate(nil, nil, kCFDateIntervalFormatterMediumStyle, kCFDateIntervalFormatterMediumStyle)
        _CFDateIntervalFormatterInitializeFromCoderValues(core,
                                                          coder.decodeInt64(forKey: "NS.dateStyle"),
                                                          coder.decodeInt64(forKey: "NS.timeStyle"),
                                                          cfObject(of: NSString.self, from: coder, forKey: "NS.dateTemplate"),
                                                          cfObject(of: NSString.self, from: coder, forKey: "NS.dateTemplateFromStyle"),
                                                          coder.decodeBool(forKey: "NS.modified"),
                                                          coder.decodeBool(forKey: "NS.useTemplate"),
                                                          cfObject(of: NSLocale.self, from: coder, forKey: "NS.locale"),
                                                          cfObject(of: NSCalendar.self, from: coder, forKey: "NS.calendar"),
                                                          cfObject(of: NSTimeZone.self, from: coder, forKey: "NS.timeZone"))
        self.core = core
        
        super.init(coder: coder)
    }
    
    open override func encode(with aCoder: NSCoder) {
        guard aCoder.allowsKeyedCoding else { fatalError("Requires a keyed coding-capable archiver.") }
        super.encode(with: aCoder)
        
        var dateStyle: Int64 = 0
        var timeStyle: Int64 = 0
        var dateTemplate: Unmanaged<CFString>?
        var dateTemplateFromStyles: Unmanaged<CFString>?
        var modified: Bool = false
        var useTemplate: Bool = false
        var locale: Unmanaged<CFLocale>?
        var calendar: Unmanaged<CFCalendar>?
        var timeZone: Unmanaged<CFTimeZone>?
        
        _CFDateIntervalFormatterCopyCoderValues(core,
                                                &dateStyle,
                                                &timeStyle,
                                                &dateTemplate,
                                                &dateTemplateFromStyles,
                                                &modified,
                                                &useTemplate,
                                                &locale,
                                                &calendar,
                                                &timeZone);
        
        aCoder.encode(dateStyle, forKey: "NS.dateStyle")
        aCoder.encode(timeStyle, forKey: "NS.timeStyle")
        
        let dateTemplateNS = dateTemplate?.takeRetainedValue()._nsObject
        aCoder.encode(dateTemplateNS, forKey: "NS.dateTemplate")
        
        let dateTemplateFromStylesNS = dateTemplateFromStyles?.takeRetainedValue()._nsObject
        aCoder.encode(dateTemplateFromStylesNS, forKey: "NS.dateTemplateFromStyles")
        
        aCoder.encode(modified, forKey: "NS.modified");
        aCoder.encode(useTemplate, forKey: "NS.useTemplate")
        
        let localeNS = locale?.takeRetainedValue()._nsObject
        aCoder.encode(localeNS, forKey: "NS.locale")
        
        let calendarNS = calendar?.takeRetainedValue()._nsObject
        aCoder.encode(calendarNS, forKey: "NS.calendar")
        
        let timeZoneNS = timeZone?.takeRetainedValue()._nsObject
        aCoder.encode(timeZoneNS, forKey: "NS.timeZone")
    }
    
    /*@NSCopying*/ open var locale: Locale! {
        get { return CFDateIntervalFormatterCopyLocale(core)._swiftObject }
        set { CFDateIntervalFormatterSetLocale(core, newValue?._cfObject) }
    }
    
    /*@NSCopying*/ open var calendar: Calendar! {
        get { return CFDateIntervalFormatterCopyCalendar(core)._swiftObject }
        set { CFDateIntervalFormatterSetCalendar(core, newValue?._cfObject) }
    }
    
    /*@NSCopying*/ open var timeZone: TimeZone! {
        get { return CFDateIntervalFormatterCopyTimeZone(core)._swiftObject }
        set { CFDateIntervalFormatterSetTimeZone(core, newValue?._cfObject) }
    }
    
    open var dateTemplate: String! {
        get { return CFDateIntervalFormatterCopyDateTemplate(core)._swiftObject }
        set { CFDateIntervalFormatterSetDateTemplate(core, newValue?._cfObject) }
    }
    
    open var dateStyle: Style {
        get { return Style(CFDateIntervalFormatterGetDateStyle(core)) }
        set { CFDateIntervalFormatterSetDateStyle(core, CFDateIntervalFormatterStyle(newValue)) }
    }
    open var timeStyle: Style {
        get { return Style(CFDateIntervalFormatterGetTimeStyle(core)) }
        set { CFDateIntervalFormatterSetTimeStyle(core, CFDateIntervalFormatterStyle(newValue)) }
    }
    
    internal enum BoundaryStyle: UInt {
        case `default` = 0
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
        case minimizeAdjacentMonths = 1
#endif
    }
    
    internal var boundaryStyle: BoundaryStyle {
        get { return BoundaryStyle(_CFDateIntervalFormatterGetBoundaryStyle(core)) }
        set { _CFDateIntervalFormatterSetBoundaryStyle(core, _CFDateIntervalFormatterBoundaryStyle(newValue) )}
    }
    
    /*
         If the range smaller than the resolution specified by the dateTemplate, a single date format will be produced. If the range is larger than the format specified by the dateTemplate, a locale-specific fallback will be used to format the items missing from the pattern.
         
         For example, if the range is 2010-03-04 07:56 - 2010-03-04 19:56 (12 hours)
         - The pattern jm will produce
            for en_US, "7:56 AM - 7:56 PM"
            for en_GB, "7:56 - 19:56"
         - The pattern MMMd will produce
            for en_US, "Mar 4"
            for en_GB, "4 Mar"
         If the range is 2010-03-04 07:56 - 2010-03-08 16:11 (4 days, 8 hours, 15 minutes)
         - The pattern jm will produce
            for en_US, "3/4/2010 7:56 AM - 3/8/2010 4:11 PM"
            for en_GB, "4/3/2010 7:56 - 8/3/2010 16:11"
         - The pattern MMMd will produce
            for en_US, "Mar 4-8"
            for en_GB, "4-8 Mar"
    */
    open func string(from fromDate: Date, to toDate: Date) -> String {
        return CFDateIntervalFormatterCreateStringFromDateToDate(core, fromDate._cfObject, toDate._cfObject)._swiftObject
    }
    
    open func string(from dateInterval: DateInterval) -> String? {
        let result = CFDateIntervalFormatterCreateStringFromDateToDate(core, dateInterval.start._cfObject, dateInterval.end._cfObject)._swiftObject
        return result.isEmpty ? nil : result
    }
    
    open override func string(for obj: Any) -> String? {
        guard let interval = obj as? DateInterval else {
            return nil
        }
        
        return string(from: interval)
    }
    
    open override func editingString(for obj: Any) -> String? {
        return nil
    }
    
    open override func copy(with zone: NSZone? = nil) -> Any {
        return DateIntervalFormatter(cfFormatter: CFDateIntervalFormatterCreateCopy(nil, core))
    }
}