22 · Date·Calendar·TimeZone

import Foundation

let now = Date(timeIntervalSinceReferenceDate: 800_000_000)

var calSeoul = Calendar(identifier: .gregorian)
calSeoul.timeZone = TimeZone(identifier: "Asia/Seoul")!

var calLA = Calendar(identifier: .gregorian)
calLA.timeZone = TimeZone(identifier: "America/Los_Angeles")!

let seoul = calSeoul.dateComponents([.year, .month, .day, .hour, .minute], from: now)
let la = calLA.dateComponents([.year, .month, .day, .hour, .minute], from: now)

print(seoul.year!, seoul.month!, seoul.day!, seoul.hour!, seoul.minute!)
// 2026 5 9 15 13  — 서울은 5/9 오후 3시 13분

print(la.year!, la.month!, la.day!, la.hour!, la.minute!)
// 2026 5 8 23 13  — LA는 아직 5/8 밤 11시 13분(날짜까지 다르다)

import Foundation

let delta = 1e-6 // 1마이크로초 차이

func distinguishable(at t: TimeInterval) -> Bool {
    Date(timeIntervalSinceReferenceDate: t) != Date(timeIntervalSinceReferenceDate: t + delta)
}

print(distinguishable(at: 800_000_000))
// true — 2026년 근처에서는 1마이크로초 차이가 구분된다

let farFuture = Date.distantFuture.timeIntervalSinceReferenceDate // 63_113_904_000.0 (약 4001년)
print(distinguishable(at: farFuture))
// false — 4001년 근처에서는 같은 1마이크로초 차이가 "같은 값"으로 뭉개진다

print(farFuture.ulp)
// 7.62939453125e-06 — 이 지점에서 Double이 표현 가능한 최소 간격(약 7.6마이크로초)

import Foundation

// ✅ 모델은 절대 시각(Date)만 들고 있는다 — 타임존은 표시 시점의 몫
struct Meeting {
    let startsAt: Date
}

func displayText(for meeting: Meeting, in identifier: String) -> String {
    var calendar = Calendar(identifier: .gregorian)
    calendar.timeZone = TimeZone(identifier: identifier) ?? .current
    let comps = calendar.dateComponents([.month, .day, .hour, .minute], from: meeting.startsAt)
    return "\(comps.month!)/\(comps.day!) \(comps.hour!):\(comps.minute!)"
}

let meeting = Meeting(startsAt: Date(timeIntervalSinceReferenceDate: 800_000_000))
print(displayText(for: meeting, in: "Asia/Seoul"))            // 5/9 15:13
print(displayText(for: meeting, in: "America/Los_Angeles"))    // 5/8 23:13
// ❌ 만약 Meeting이 startsAt과 함께 "표시용 타임존 문자열"까지 저장해뒀다면,
//    사용자가 여행 중 다른 지역으로 이동하는 순간 화면에 옛 타임존 시각이 남는다.

// ❌ "만료 없음"을 distantFuture로 흉내
struct TokenBad {
    let expiresAt: Date   // 무제한이면 .distantFuture를 넣는 관행
}

// ✅ 옵셔널로 "없음"을 명시 — distantFuture 근처의 정밀도 문제와 무관해진다
struct TokenGood {
    let expiresAt: Date?  // nil == 만료 없음
}

func isExpired(_ token: TokenGood, now: Date = Date()) -> Bool {
    guard let expiresAt = token.expiresAt else { return false }
    return now > expiresAt
}

import Foundation

let gregorian = Calendar(identifier: .gregorian)
print(gregorian.firstWeekday, gregorian.minimumDaysInFirstWeek) // 1 1

let iso = Calendar(identifier: .iso8601)
print(iso.firstWeekday, iso.minimumDaysInFirstWeek)             // 2 4

var chineseCal = Calendar(identifier: .chinese)
chineseCal.timeZone = TimeZone(identifier: "Asia/Seoul")!
var seoulGregorian = Calendar(identifier: .gregorian)
seoulGregorian.timeZone = TimeZone(identifier: "Asia/Seoul")!

let feb6_2027 = seoulGregorian.date(from: DateComponents(year: 2027, month: 2, day: 6))!
let lunar = chineseCal.dateComponents([.year, .month, .day], from: feb6_2027)
print(lunar.year!, lunar.month!, lunar.day!)
// 44 1 1  — 그레고리력 2027-02-06이 음력으로는 설날(1월 1일)이다

final class ScheduleViewModel {
    // ✅ 앱이 오래 떠 있는 동안 사용자가 지역 설정을 바꿔도 즉시 반영된다
    private let calendar = Calendar.autoupdatingCurrent

    func isToday(_ date: Date) -> Bool {
        calendar.isDateInToday(date)
    }
}

func quickWeekday(of date: Date) -> Int {
    // ✅ 함수 안에서 한 번 쓰고 버릴 계산은 current로 충분
    Calendar.current.component(.weekday, from: date)
}

func billingCutoff(for month: DateComponents) -> Date {
    var calendar = Calendar(identifier: .gregorian)   // 사용자 설정과 무관하게 고정
    calendar.timeZone = TimeZone(identifier: "UTC")!  // wire format은 항상 UTC
    return calendar.date(from: month)!
}
// ❌ 여기서 Calendar.current를 쓰면, 사용자가 캘린더/지역 설정을 바꾸는 순간
//    같은 로직이 다른 결과를 내는 "재현 불가능한" 정산 버그가 된다.

func isLunarNewYear(_ date: Date, timeZone: TimeZone) -> Bool {
    var chineseCal = Calendar(identifier: .chinese)
    chineseCal.timeZone = timeZone
    let comps = chineseCal.dateComponents([.month, .day], from: date)
    return comps.month == 1 && comps.day == 1
}

import Foundation

let tz = TimeZone(identifier: "America/Los_Angeles")!
var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = tz

let base = calendar.date(from: DateComponents(year: 2026, month: 3, day: 7, hour: 12))!

let plus86400 = base.addingTimeInterval(86400)
let byAddingDay = calendar.date(byAdding: .day, value: 1, to: base)!

print(plus86400 == byAddingDay) // false — 두 결과가 다르다

let a = calendar.dateComponents([.month, .day, .hour], from: plus86400)
let b = calendar.dateComponents([.month, .day, .hour], from: byAddingDay)
print(a.hour!) // 13 — 벽시계 1시간 밀림
print(b.hour!) // 12 — 정오 보존

var comps = DateComponents()
comps.year = 2026; comps.month = 3; comps.day = 8
comps.hour = 2; comps.minute = 30
comps.timeZone = tz

let d = calendar.date(from: comps)!
let back = calendar.dateComponents([.hour, .minute], from: d)
print(back.hour!, back.minute!) // 3 30 — 요청한 02:30이 존재하지 않아 03:30으로 밀렸다

// TimeZone API로 전환 시각을 직접 조회할 수도 있다
let justBefore = calendar.date(from: DateComponents(year: 2026, month: 3, day: 8, hour: 1, minute: 59))!
print(tz.isDaylightSavingTime(for: justBefore))              // false
if let transition = tz.nextDaylightSavingTimeTransition(after: justBefore) {
    print(calendar.dateComponents([.hour, .minute], from: transition).hour!) // 3 — 02:00이 아니라 03:00에 착지
}

// ❌ "내일 같은 시각"을 초 산술로
let wrongTomorrow = Date().addingTimeInterval(86400)

// ✅ 달력 개념의 연산은 Calendar가 대신 DST를 처리해준다
let rightTomorrow = Calendar.current.date(byAdding: .day, value: 1, to: Date())!

var comps = DateComponents()
comps.hour = 2; comps.minute = 30 // 스프링포워드 날엔 존재하지 않을 수 있는 시각

// .nextTime: 존재하지 않으면 다음으로 유효한 시각으로 밀어준다(기본값과 동일 계열)
let next = Calendar.current.nextDate(
    after: Date(),
    matching: comps,
    matchingPolicy: .nextTime
)

import Foundation

var utc = Calendar(identifier: .gregorian)
utc.timeZone = TimeZone(identifier: "UTC")!

// 2016-12-31 23:59:60 UTC에 실제로 윤초가 삽입됐던 구간을 걸친다
let before = utc.date(from: DateComponents(year: 2016, month: 12, day: 31))!
let after  = utc.date(from: DateComponents(year: 2017, month: 1, day: 1))!

print(after.timeIntervalSince(before))
// 86400.0 — 실제로는 윤초 때문에 86401초가 흘렀지만 Date 산술은 이를 반영하지 않는다

import Foundation

// ❌ 벽시계(Date)로 경과 시간 측정 — 시스템 시각 조정에 취약하다
let wallStart = Date()
// ... 작업 수행 ...
let wallElapsed = Date().timeIntervalSince(wallStart)

// ✅ ContinuousClock — 시스템 시각이 어떻게 조정되든 실제 물리적 경과만 잰다
let clock = ContinuousClock()
let start = clock.now
// ... 작업 수행 ...
let elapsed = clock.now - start
print(elapsed) // 예: 0.203808958 seconds

// SuspendingClock: 기기가 완전히 잠들어(sleep) 있는 동안은 멈춘다는 점만 다르다
let sclock = SuspendingClock()
let sstart = sclock.now
// ... 작업 수행 ...
print(sclock.now - sstart)

func measure<T>(_ label: String, _ work: () async throws -> T) async rethrows -> T {
    let clock = ContinuousClock()
    let start = clock.now
    defer {
        let elapsed = clock.now - start
        print("[\(label)] 소요:", elapsed)
    }
    return try await work()
}

struct RequestLog {
    let firedAt: Date          // "언제" 일어났는지 — 로그·타임스탬프용
    let duration: Duration     // "얼마나 걸렸는지" — ContinuousClock 결과
}

import Foundation

var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = TimeZone(identifier: "Asia/Seoul")!

// 기준: 2026-07-27(월) 오후 3시
let now = calendar.date(from: DateComponents(year: 2026, month: 7, day: 27, hour: 15))!

var matching = DateComponents()
matching.weekday = 2 // 1=일요일 기준이므로 월요일은 2
matching.hour = 9
matching.minute = 0

let next = calendar.nextDate(after: now, matching: matching, matchingPolicy: .nextTime)!
print(next)
// 2026-08-03 09:00 KST — 오늘 월요일이지만 9시가 이미 지났으므로 다음 주로 건너뛴다

let interval1 = DateInterval(
    start: calendar.date(from: DateComponents(year: 2026, month: 7, day: 1))!,
    end:   calendar.date(from: DateComponents(year: 2026, month: 7, day: 15))!
)
let interval2 = DateInterval(
    start: calendar.date(from: DateComponents(year: 2026, month: 7, day: 10))!,
    end:   calendar.date(from: DateComponents(year: 2026, month: 7, day: 20))!
)

print(interval1.intersects(interval2))         // true
print(interval1.intersection(with: interval2)) // 7/10 ~ 7/15 구간

let probe = calendar.date(from: DateComponents(year: 2026, month: 7, day: 12))!
print(interval1.contains(probe), interval2.contains(probe)) // true true

func nextTuesday9AM(after date: Date, calendar: Calendar) -> Date? {
    var matching = DateComponents()
    matching.weekday = 3 // 화요일
    matching.hour = 9
    matching.minute = 0
    return calendar.nextDate(after: date, matching: matching, matchingPolicy: .nextTime)
}

struct Reservation {
    let interval: DateInterval
}

func hasConflict(_ new: Reservation, with existing: [Reservation]) -> Bool {
    existing.contains { $0.interval.intersects(new.interval) }
}