// UTC+0 기준 2021년 3월 20일 9시
2021-03-20T09:00:00.000Z

// UTC+9 (한국 시간) 기준 2021년 3월 20일 9시
2021-03-20T09:00:00.000+09:00

{
  "userId": 1,
  "name": "이선협",
  "zoneId": "Asia/Seoul", // Time Zone을 위한 Zone Id
  "birthdate": "1994-01-26", // 순수한 시간
  "createdAt": "2021-03-20T04:59:25Z", // 기준 시간 UTC
  "updatedAt": "2021-03-20T05:12:38Z",
  "posts": [
    {
      "postId": 1,
      "publishedAt": "2021-03-20T06:00:00Z", // 기준 시간 오전 6시에 발행됨
      // publishedAt은 user의 zondId에 따라 다르게 보일 수 있다.
    }
  ]
}

/**
 * 모든 시간 관련 개념의 기본 인터페이스
 */
interface Temporal {
  // 다른 시간 개념으로 변환하는 메서드들
  fun asInstant(): Instant
  fun withZone(zone: ZoneId): ZonedTemporal
  
  // 비교 메서드
  fun isBefore(other: Temporal): Boolean
  fun isAfter(other: Temporal): Boolean
  fun isEqual(other: Temporal): Boolean
  
  // 포맷팅
  fun format(pattern: String, zone: ZoneId = ZoneId.systemDefault()): String
}

/**
 * 시간대 정보를 포함하는 시간 개념
 */
interface ZonedTemporal : Temporal {
  val zone: ZoneId
}

import java.time.Instant
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter

/**
 * 시간의 특정 시점을 표현하는 클래스
 */
class TimePoint private constructor(private val instant: Instant) {
  companion object {
    // 현재 시점 생성
    fun now(): TimePoint = TimePoint(Instant.now())
    
    // Epoch 밀리초로부터 시점 생성
    fun fromEpochMilli(epochMilli: Long): TimePoint = TimePoint(Instant.ofEpochMilli(epochMilli))
    
    // ISO 8601 문자열로부터 시점 생성
    fun fromIsoString(isoString: String): TimePoint = TimePoint(Instant.parse(isoString))
    
    // 날짜/시간 컴포넌트로부터 시점 생성
    fun of(year: Int, month: Int, day: Int, hour: Int = 0, minute: Int = 0, 
            second: Int = 0, nanoOfSecond: Int = 0, zone: ZoneId = ZoneId.systemDefault()): TimePoint {
      val zonedDateTime = ZonedDateTime.of(year, month, day, hour, minute, second, nanoOfSecond, zone)
      return TimePoint(zonedDateTime.toInstant())
    }
  }
  
  // 다양한 포맷으로 시점 표현
  fun toIsoString(): String = instant.toString()
  
  fun toEpochMilli(): Long = instant.toEpochMilli()
  
  fun format(pattern: String, zone: ZoneId = ZoneId.systemDefault()): String {
    val formatter = DateTimeFormatter.ofPattern(pattern)
    val zonedDateTime = ZonedDateTime.ofInstant(instant, zone)
    return zonedDateTime.format(formatter)
  }
  
  // 특정 타임존에서의 시간 정보 가져오기
  fun inZone(zone: ZoneId): ZonedDateTime = ZonedDateTime.ofInstant(instant, zone)
  
  // 시점 비교
  fun isBefore(other: TimePoint): Boolean = instant.isBefore(other.instant)
  
  fun isAfter(other: TimePoint): Boolean = instant.isAfter(other.instant)
  
  // 시점 연산
  fun plus(duration: Duration): TimePoint = TimePoint(instant.plus(duration.toJavaDuration()))
  
  fun minus(duration: Duration): TimePoint = TimePoint(instant.minus(duration.toJavaDuration()))
  
  // 시점 간 기간 계산
  fun until(other: TimePoint): Duration = Duration.between(this, other)
  
  override fun equals(other: Any?): Boolean {
    if (this === other) return true
    if (other !is TimePoint) return false
    return instant == other.instant
  }
  
  override fun hashCode(): Int = instant.hashCode()
  
  override fun toString(): String = toIsoString()
}

import java.time.temporal.ChronoUnit
import java.util.concurrent.TimeUnit

/**
 * 시간의 양(기간)을 표현하는 클래스
 */
class Duration private constructor(
  val value: Long,
  val unit: TimeUnit
) {
  companion object {
    // 기본 팩토리 메서드
    fun of(value: Long, unit: TimeUnit): Duration = Duration(value, unit)
    
    // 편의 메서드
    fun ofNanos(nanos: Long): Duration = of(nanos, TimeUnit.NANOSECONDS)
    fun ofMicros(micros: Long): Duration = of(micros, TimeUnit.MICROSECONDS)
    fun ofMillis(millis: Long): Duration = of(millis, TimeUnit.MILLISECONDS)
    fun ofSeconds(seconds: Long): Duration = of(seconds, TimeUnit.SECONDS)
    fun ofMinutes(minutes: Long): Duration = of(minutes, TimeUnit.MINUTES)
    fun ofHours(hours: Long): Duration = of(hours, TimeUnit.HOURS)
    fun ofDays(days: Long): Duration = of(days, TimeUnit.DAYS)
    
    // 두 시점 사이의 기간 계산
    fun between(start: TimePoint, end: TimePoint): Duration {
      val millis = end.toEpochMilli() - start.toEpochMilli()
      return ofMillis(millis)
    }
    
    val ZERO = ofMillis(0)
  }
  
  // 단위 변환
  fun to(targetUnit: TimeUnit): Duration {
    val convertedValue = targetUnit.convert(value, unit)
    return of(convertedValue, targetUnit)
  }
  
  // 기간 연산
  fun plus(other: Duration): Duration {
    val thisNanos = unit.toNanos(value)
    val otherNanos = other.unit.toNanos(other.value)
    return ofNanos(thisNanos + otherNanos)
  }
  
  fun minus(other: Duration): Duration {
    val thisNanos = unit.toNanos(value)
    val otherNanos = other.unit.toNanos(other.value)
    return ofNanos(thisNanos - otherNanos)
  }
  
  fun multipliedBy(factor: Long): Duration = of(value * factor, unit)
  
  fun dividedBy(divisor: Long): Duration = of(value / divisor, unit)
  
  // Java Duration으로 변환
  fun toJavaDuration(): java.time.Duration = java.time.Duration.of(value, chronoUnit())
  
  // 시간 단위를 ChronoUnit으로 변환
  private fun chronoUnit(): ChronoUnit = when (unit) {
    TimeUnit.NANOSECONDS -> ChronoUnit.NANOS
    TimeUnit.MICROSECONDS -> ChronoUnit.MICROS
    TimeUnit.MILLISECONDS -> ChronoUnit.MILLIS
    TimeUnit.SECONDS -> ChronoUnit.SECONDS
    TimeUnit.MINUTES -> ChronoUnit.MINUTES
    TimeUnit.HOURS -> ChronoUnit.HOURS
    TimeUnit.DAYS -> ChronoUnit.DAYS
    else -> throw IllegalArgumentException("Unsupported time unit: $unit")
  }
  
  // 비교 연산
  fun isZero(): Boolean = value == 0L
  
  fun isPositive(): Boolean = value > 0
  
  fun isNegative(): Boolean = value < 0
  
  override fun equals(other: Any?): Boolean {
    if (this === other) return true
    if (other !is Duration) return false
    
    // 같은 단위로 변환하여 비교
    val thisNanos = unit.toNanos(value)
    val otherNanos = other.unit.toNanos(other.value)
    return thisNanos == otherNanos
  }
  
  override fun hashCode(): Int {
    val nanos = unit.toNanos(value)
    return nanos.hashCode()
  }
  
  override fun toString(): String {
    return when (unit) {
      TimeUnit.NANOSECONDS -> "${value}ns"
      TimeUnit.MICROSECONDS -> "${value}µs"
      TimeUnit.MILLISECONDS -> "${value}ms"
      TimeUnit.SECONDS -> "${value}s"
      TimeUnit.MINUTES -> "${value}m"
      TimeUnit.HOURS -> "${value}h"
      TimeUnit.DAYS -> "${value}d"
      else -> "${value} ${unit.name.lowercase()}"
    }
  }
}

/**
 * 시작 시점과 끝 시점 사이의 시간 간격을 표현하는 클래스
 */
class TimeInterval private constructor(
  val start: TimePoint,
  val end: TimePoint
) {
  init {
    require(!end.isBefore(start)) { "End time must not be before start time" }
  }
  
  companion object {
    fun of(start: TimePoint, end: TimePoint): TimeInterval = TimeInterval(start, end)
    
    // 특정 시점으로부터 기간을 더한 간격 생성
    fun startingAt(start: TimePoint, duration: Duration): TimeInterval =
      of(start, start.plus(duration))
    
    // 특정 시점으로부터 기간을 뺀 간격 생성
    fun endingAt(end: TimePoint, duration: Duration): TimeInterval =
      of(end.minus(duration), end)
  }
  
  // 간격의 기간 계산
  fun duration(): Duration = start.until(end)
  
  // 간격 연산
  fun shift(duration: Duration): TimeInterval =
    of(start.plus(duration), end.plus(duration))
  
  fun expand(duration: Duration): TimeInterval =
    of(start.minus(duration), end.plus(duration))
  
  fun shrink(duration: Duration): TimeInterval {
    val halfDuration = duration.dividedBy(2)
    val newStart = start.plus(halfDuration)
    val newEnd = end.minus(halfDuration)
    
    // 축소 후 유효한 간격인지 확인
    return if (newEnd.isBefore(newStart)) {
      // 간격이 너무 작아 유효하지 않은 경우, 중간 시점으로 축소
      val midPoint = start.plus(duration().dividedBy(2))
      of(midPoint, midPoint)
    } else {
      of(newStart, newEnd)
    }
  }
  
  // 간격 관계 확인
  fun contains(point: TimePoint): Boolean =
    !point.isBefore(start) && !point.isAfter(end)
  
  fun contains(other: TimeInterval): Boolean =
    !other.start.isBefore(start) && !other.end.isAfter(end)
  
  fun overlaps(other: TimeInterval): Boolean =
    !end.isBefore(other.start) && !start.isAfter(other.end)
  
  fun abuts(other: TimeInterval): Boolean =
    start.equals(other.end) || end.equals(other.start)
  
  // 간격 병합 및 교차
  fun union(other: TimeInterval): TimeInterval? {
    return if (!overlaps(other) && !abuts(other)) {
      null // 겹치거나 인접하지 않으면 병합 불가
    } else {
      of(
        if (start.isBefore(other.start)) start else other.start,
        if (end.isAfter(other.end)) end else other.end
      )
    }
  }
  
  fun intersection(other: TimeInterval): TimeInterval? {
    return if (!overlaps(other)) {
      null // 겹치지 않으면 교집합 없음
    } else {
      of(
        if (start.isAfter(other.start)) start else other.start,
        if (end.isBefore(other.end)) end else other.end
      )
    }
  }
  
  override fun equals(other: Any?): Boolean {
    if (this === other) return true
    if (other !is TimeInterval) return false
    return start == other.start && end == other.end
  }
  
  override fun hashCode(): Int {
    var result = start.hashCode()
    result = 31 * result + end.hashCode()
    return result
  }
  
  override fun toString(): String = "[$start, $end]"
}

import java.time.DayOfWeek
import java.time.LocalTime
import java.time.ZoneId
import java.time.temporal.TemporalAdjusters
import java.util.*

/**
 * 반복되는 시간 패턴을 표현하는 클래스
 */
abstract class TimeRecurrence {
  // 특정 간격 내에서 발생하는 모든 시점 계산
  abstract fun occurrencesIn(interval: TimeInterval): List<TimePoint>
  
  // 특정 시점 이후의 다음 발생 시점 계산
  abstract fun nextOccurrenceAfter(point: TimePoint): TimePoint?
}

/**
 * 매일 반복되는 패턴
 */
class DailyRecurrence(
  private val timeOfDay: LocalTime,
  private val zone: ZoneId = ZoneId.systemDefault()
) : TimeRecurrence() {
  
  override fun occurrencesIn(interval: TimeInterval): List<TimePoint> {
    val result = mutableListOf<TimePoint>()
    var current = nextOccurrenceAfter(interval.start.minus(Duration.ofSeconds(1)))
    
    while (current != null && !current.isAfter(interval.end)) {
      result.add(current)
      current = nextOccurrenceAfter(current)
    }
    
    return result
  }
  
  override fun nextOccurrenceAfter(point: TimePoint): TimePoint {
    val zonedDateTime = point.inZone(zone)
    val today = zonedDateTime.toLocalDate()
    val todayOccurrence = today.atTime(timeOfDay).atZone(zone).toInstant()
    val todayPoint = TimePoint.fromEpochMilli(todayOccurrence.toEpochMilli())
    
    return if (point.isBefore(todayPoint)) {
      todayPoint
    } else {
      val tomorrow = today.plusDays(1)
      val tomorrowOccurrence = tomorrow.atTime(timeOfDay).atZone(zone).toInstant()
      TimePoint.fromEpochMilli(tomorrowOccurrence.toEpochMilli())
    }
  }
}

/**
 * 매주 특정 요일에 반복되는 패턴
 */
class WeeklyRecurrence(
  private val daysOfWeek: Set<DayOfWeek>,
  private val timeOfDay: LocalTime,
  private val zone: ZoneId = ZoneId.systemDefault()
) : TimeRecurrence() {
    
  override fun occurrencesIn(interval: TimeInterval): List<TimePoint> {
    val result = mutableListOf<TimePoint>()
    var current = nextOccurrenceAfter(interval.start.minus(Duration.ofSeconds(1)))
    
    while (current != null && !current.isAfter(interval.end)) {
      result.add(current)
      current = nextOccurrenceAfter(current)
    }
    
    return result
  }
  
  override fun nextOccurrenceAfter(point: TimePoint): TimePoint? {
    if (daysOfWeek.isEmpty()) return null
    
    val zonedDateTime = point.inZone(zone)
    val today = zonedDateTime.toLocalDate()
    val currentDayOfWeek = today.dayOfWeek
    
    // 오늘의 발생 시점 확인
    val todayOccurrence = today.atTime(timeOfDay).atZone(zone).toInstant()
    val todayPoint = TimePoint.fromEpochMilli(todayOccurrence.toEpochMilli())
    
    if (daysOfWeek.contains(currentDayOfWeek) && point.isBefore(todayPoint)) {
      return todayPoint
    }
    
    // 다음 발생 요일 찾기
    for (i in 1..7) {
      val nextDay = today.plusDays(i.toLong())
      if (daysOfWeek.contains(nextDay.dayOfWeek)) {
        val nextOccurrence = nextDay.atTime(timeOfDay).atZone(zone).toInstant()
        return TimePoint.fromEpochMilli(nextOccurrence.toEpochMilli())
      }
    }
    
    return null // 발생하지 않는 케이스 (daysOfWeek가 비어있는 경우)
  }
}

/**
 * 매월 특정 일에 반복되는 패턴
 */
class MonthlyRecurrence(
  private val dayOfMonth: Int,
  private val timeOfDay: LocalTime,
  private val zone: ZoneId = ZoneId.systemDefault()
) : TimeRecurrence() {
    
  init {
    require(dayOfMonth in 1..31) { "Day of month must be between 1 and 31" }
  }
  
  override fun occurrencesIn(interval: TimeInterval): List<TimePoint> {
    val result = mutableListOf<TimePoint>()
    var current = nextOccurrenceAfter(interval.start.minus(Duration.ofSeconds(1)))
    
    while (current != null && !current.isAfter(interval.end)) {
      result.add(current)
      current = nextOccurrenceAfter(current)
    }
    
    return result
  }
  
  override fun nextOccurrenceAfter(point: TimePoint): TimePoint {
    val zonedDateTime = point.inZone(zone)
    val today = zonedDateTime.toLocalDate()
    
    // 이번 달의 발생일 계산
    val dayOfMonthAdjusted = Math.min(dayOfMonth, today.lengthOfMonth())
    val thisMonth = today.withDayOfMonth(dayOfMonthAdjusted)
    val thisMonthOccurrence = thisMonth.atTime(timeOfDay).atZone(zone).toInstant()
    val thisMonthPoint = TimePoint.fromEpochMilli(thisMonthOccurrence.toEpochMilli())
    
    if (point.isBefore(thisMonthPoint)) {
      return thisMonthPoint
    }
    
    // 다음 달의 발생일 계산
    val nextMonth = today.plusMonths(1)
    val nextMonthDayAdjusted = Math.min(dayOfMonth, nextMonth.lengthOfMonth())
    val nextMonthDate = nextMonth.withDayOfMonth(nextMonthDayAdjusted)
    val nextMonthOccurrence = nextMonthDate.atTime(timeOfDay).atZone(zone).toInstant()
    
    return TimePoint.fromEpochMilli(nextMonthOccurrence.toEpochMilli())
  }
}

/**
 * 시간 관련 유틸리티 클래스
 */
object TimeUtils {
  // 시점 비교 및 확인
  fun isLeapYear(year: Int): Boolean {
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
  }
  
  fun daysInMonth(year: Int, month: Int): Int {
    return when (month) {
      1, 3, 5, 7, 8, 10, 12 -> 31
      4, 6, 9, 11 -> 30
      2 -> if (isLeapYear(year)) 29 else 28
      else -> throw IllegalArgumentException("Invalid month: $month")
    }
  }
  
  // 기간 표시 및 변환
  fun formatDuration(duration: Duration): String {
    val millis = duration.to(TimeUnit.MILLISECONDS).value
    
    val days = TimeUnit.MILLISECONDS.toDays(millis)
    val hours = TimeUnit.MILLISECONDS.toHours(millis) % 24
    val minutes = TimeUnit.MILLISECONDS.toMinutes(millis) % 60
    val seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60
    
    val parts = mutableListOf<String>()
    if (days > 0) parts.add("${days}d")
    if (hours > 0) parts.add("${hours}h")
    if (minutes > 0) parts.add("${minutes}m")
    if (seconds > 0 || parts.isEmpty()) parts.add("${seconds}s")
    
    return parts.joinToString(" ")
  }
  
  // 시간 간격 조작
  fun splitInterval(interval: TimeInterval, parts: Int): List<TimeInterval> {
    require(parts > 0) { "Number of parts must be positive" }
    
    val result = mutableListOf<TimeInterval>()
    val duration = interval.duration()
    val partDuration = duration.dividedBy(parts.toLong())
    
    var current = interval.start
    repeat(parts) {
      val next = if (it == parts - 1) interval.end else current.plus(partDuration)
      result.add(TimeInterval.of(current, next))
      current = next
    }
    
    return result
  }
  
  // 반복 패턴 조합
  fun combineRecurrences(recurrences: List<TimeRecurrence>): TimeRecurrence {
    return object : TimeRecurrence() {
      override fun occurrencesIn(interval: TimeInterval): List<TimePoint> {
        return recurrences.flatMap { it.occurrencesIn(interval) }
          .distinct()
          .sortedBy { it.toEpochMilli() }
      }
      
      override fun nextOccurrenceAfter(point: TimePoint): TimePoint? {
        return recurrences.mapNotNull { it.nextOccurrenceAfter(point) }
          .minByOrNull { it.toEpochMilli() }
      }
    }
  }
}

// 회의 스케줄링
val meetingStart = TimePoint.of(2023, 5, 10, 14, 0) // 2023년 5월 10일 오후 2시
val meetingDuration = Duration.ofMinutes(60) // 1시간 회의
val meetingInterval = TimeInterval.startingAt(meetingStart, meetingDuration)

// 참석자의 가용 시간 확인
val availabilityStart = TimePoint.of(2023, 5, 10, 13, 0) // 오후 1시부터
val availabilityEnd = TimePoint.of(2023, 5, 10, 17, 0)   // 오후 5시까지
val availabilityInterval = TimeInterval.of(availabilityStart, availabilityEnd)

// 회의가 가용 시간 내에 있는지 확인
val canAttend = availabilityInterval.contains(meetingInterval)
println("Can attend meeting: $canAttend") // true

// 다음 정기 회의 시간 계산 (매주 월요일 오전 10시)
val weeklyMeeting = WeeklyRecurrence(
    setOf(DayOfWeek.MONDAY),
    LocalTime.of(10, 0)
)

val today = TimePoint.now()
val nextMeeting = weeklyMeeting.nextOccurrenceAfter(today)
println("Next meeting: ${nextMeeting?.format("yyyy-MM-dd HH:mm")}")

// 여러 이벤트의 타임라인 생성
data class Event(val name: String, val interval: TimeInterval)

val events = listOf(
  Event("프로젝트 계획", TimeInterval.of(
    TimePoint.of(2023, 5, 1, 9, 0),
    TimePoint.of(2023, 5, 3, 17, 0)
  )),
  Event("디자인 단계", TimeInterval.of(
    TimePoint.of(2023, 5, 4, 9, 0),
    TimePoint.of(2023, 5, 10, 17, 0)
  )),
  Event("개발 단계", TimeInterval.of(
    TimePoint.of(2023, 5, 8, 9, 0),
    TimePoint.of(2023, 5, 20, 17, 0)
  )),
  Event("테스트", TimeInterval.of(
    TimePoint.of(2023, 5, 18, 9, 0),
    TimePoint.of(2023, 5, 25, 17, 0)
  ))
)

// 전체 프로젝트 기간 계산
val projectStart = events.minOf { it.interval.start }
val projectEnd = events.maxOf { it.interval.end }
val projectInterval = TimeInterval.of(projectStart, projectEnd)
val projectDuration = projectInterval.duration()

println("프로젝트 기간: ${projectStart.format("yyyy-MM-dd")} ~ ${projectEnd.format("yyyy-MM-dd")}")
println("총 소요 시간: ${TimeUtils.formatDuration(projectDuration)}")

// 단계 간 겹치는 부분 분석
for (i in 0 until events.size - 1) {
  for (j in i + 1 until events.size) {
    val event1 = events[i]
    val event2 = events[j]
    
    if (event1.interval.overlaps(event2.interval)) {
      val overlap = event1.interval.intersection(event2.interval)
      println("'${event1.name}'과 '${event2.name}'이 겹침: ${overlap?.start?.format("MM-dd")} ~ ${overlap?.end?.format("MM-dd")}")
    }
  }
}

// 근무 시간 기록
data class WorkSession(val start: TimePoint, val end: TimePoint) {
  val duration: Duration
    get() = start.until(end)
  
  val interval: TimeInterval
    get() = TimeInterval.of(start, end)
}

// 일주일간의 근무 기록
val workWeek = listOf(
  WorkSession(
    TimePoint.of(2023, 5, 8, 9, 0),
    TimePoint.of(2023, 5, 8, 18, 0)
  ),
  WorkSession(
    TimePoint.of(2023, 5, 9, 8, 30),
    TimePoint.of(2023, 5, 9, 17, 45)
  ),
  WorkSession(
    TimePoint.of(2023, 5, 10, 9, 15),
    TimePoint.of(2023, 5, 10, 19, 30)
  ),
  WorkSession(
    TimePoint.of(2023, 5, 11, 9, 0),
    TimePoint.of(2023, 5, 11, 18, 15)
  ),
  WorkSession(
    TimePoint.of(2023, 5, 12, 9, 30),
    TimePoint.of(2023, 5, 12, 16, 0)
  )
)

// 총 근무 시간 계산
val totalWorkDuration = workWeek.fold(Duration.ZERO) { acc, session ->
  acc.plus(session.duration)
}

println("총 근무 시간: ${TimeUtils.formatDuration(totalWorkDuration)}")

// 일별 근무 시간 분석
val workByDay = workWeek.groupBy { 
  it.start.format("yyyy-MM-dd") 
}.mapValues { (_, sessions) ->
  sessions.fold(Duration.ZERO) { acc, session -> acc.plus(session.duration) }
}

workByDay.forEach { (day, duration) ->
  println("$day: ${TimeUtils.formatDuration(duration)}")
}

// 초과 근무 시간 계산 (하루 8시간 기준)
val standardWorkDay = Duration.ofHours(8)
val overtime = workByDay.map { (day, duration) ->
  val daily = duration.to(TimeUnit.HOURS).value
  val over = Math.max(0, daily - 8)
  day to Duration.ofHours(over)
}.filter { (_, overtime) -> !overtime.isZero() }

overtime.forEach { (day, duration) ->
  println("$day 초과근무: ${TimeUtils.formatDuration(duration)}")
}