Duration and Period Builders

/**
 * Rich integer extensions for time unit creation
 * Available for both Int and Long types
 */
implicit class RichInt(n: Int) {
  // Duration builders (sub-day precision)
  def millis: DurationBuilder
  def milli: DurationBuilder  
  def seconds: DurationBuilder
  def second: DurationBuilder
  def minutes: DurationBuilder
  def minute: DurationBuilder
  def hours: DurationBuilder
  def hour: DurationBuilder
  
  // Periods (day and larger units)
  def days: Period
  def day: Period
  def weeks: Period
  def week: Period
  def months: Period
  def month: Period
  def years: Period
  def year: Period
  
  // Period arithmetic
  def *(period: Period): Period
}

implicit class RichLong(n: Long) {
  def toDateTime: DateTime
  def toDuration: Duration
  def +(duration: Duration): Duration
  def -(duration: Duration): Duration
  def *(duration: Duration): Duration
}

import com.github.nscala_time.time.Imports._

// Duration builders for sub-day precision  
val shortDuration = 2.hours + 30.minutes + 15.seconds
val millisPrecise = 1500.millis + 30.seconds

// Periods for day+ precision
val longPeriod = 2.years + 3.months + 1.week + 5.days
val multiplied = 3 * 2.days // 6 days

// Mixed operations
val mixed = 1.day + 12.hours + 30.minutes

/**
 * Duration builder providing fluent API for duration construction and manipulation
 * @param underlying The underlying Joda Time Period
 */
class DurationBuilder(underlying: Period) {
  // Arithmetic with other builders
  def +(that: DurationBuilder): DurationBuilder
  def -(that: DurationBuilder): DurationBuilder
  
  // Arithmetic with periods and durations
  def +(period: ReadablePeriod): Period
  def -(period: ReadablePeriod): Period
  def +(amount: Long): Duration
  def -(amount: Long): Duration
  def +(amount: ReadableDuration): Duration
  def -(amount: ReadableDuration): Duration
  
  // Temporal navigation from current time
  def ago: DateTime
  def later: DateTime
  
  // Temporal navigation from specific time
  def from(dt: DateTime): DateTime
  def before(dt: DateTime): DateTime
  
  // Conversions
  def standardDuration: Duration
  def toDuration: Duration
  def toPeriod: Period
  
  // Value extraction
  def millis: Long
  def seconds: Long
}

import com.github.nscala_time.time.Imports._

// Create duration builders
val builder1 = 2.hours + 30.minutes
val builder2 = 45.minutes + 15.seconds

// Arithmetic operations
val combined = builder1 + builder2  // 3 hours, 15 minutes, 15 seconds
val difference = builder1 - builder2  // 1 hour, 45 minutes, -15 seconds

// Temporal navigation
val pastTime = 2.hours.ago           // 2 hours before now
val futureTime = 30.minutes.later    // 30 minutes from now
val specificTime = 1.day.from(DateTime.parse("2024-01-01"))

// Convert to different types
val duration = (2.hours + 30.minutes).toDuration
val period = (1.day + 2.hours).toPeriod
val millis = 30.seconds.millis  // 30000L

/**
 * Enhanced Duration with arithmetic operations and conversions
 */
implicit class RichDuration(underlying: Duration) {
  // Unary operations
  def unary_- : Duration
  
  // Arithmetic with milliseconds
  def +(amount: Long): Duration
  def -(amount: Long): Duration
  def *(multiplicand: Long): Duration
  def /(divisor: Long): Duration
  
  // Arithmetic with other durations
  def +(amount: ReadableDuration): Duration
  def -(amount: ReadableDuration): Duration
  
  // Time unit accessors
  def days: Long
  def hours: Long
  def minutes: Long
  def seconds: Long
  def millis: Long
  
  // Conversions
  def toScalaDuration: scala.concurrent.duration.Duration
}

import com.github.nscala_time.time.Imports._

val duration1 = Duration.standardHours(2)
val duration2 = Duration.standardMinutes(30)

// Arithmetic operations
val sum = duration1 + duration2
val doubled = duration1 * 2
val half = duration1 / 2
val negated = -duration1

// Unit extraction
println(s"${sum.hours} hours, ${sum.minutes % 60} minutes")

// Conversion to Scala Duration
val scalaDuration = duration1.toScalaDuration

/**
 * Enhanced Period with arithmetic operations and temporal navigation
 */
implicit class RichPeriod(underlying: Period) {
  // Unary operations
  def unary_- : Period
  
  // Arithmetic operations
  def +(period: ReadablePeriod): Period
  def -(period: ReadablePeriod): Period
  def *(scalar: Int): Period
  
  // Time unit accessors
  def years: Int
  def months: Int
  def weeks: Int
  def days: Int
  def hours: Int
  def minutes: Int
  def seconds: Int
  def millis: Int
  
  // Temporal navigation
  def ago: DateTime
  def later: DateTime
  def from(dt: DateTime): DateTime
  def before(dt: DateTime): DateTime
  
  // Conversions
  def standardDuration: Duration
}

import com.github.nscala_time.time.Imports._

val period1 = Period.months(3).plusDays(15)
val period2 = Period.weeks(2).plusDays(3)

// Arithmetic operations
val combined = period1 + period2
val doubled = period1 * 2
val negated = -period1

// Temporal navigation
val pastDate = period1.ago           // 3 months 15 days ago
val futureDate = period1.later       // 3 months 15 days from now
val fromSpecific = period1.from(DateTime.parse("2024-01-01"))

// Unit extraction
println(s"${combined.months} months, ${combined.days} days")

// Convert to duration (approximate)
val approxDuration = period1.standardDuration

/**
 * Implicit conversions for seamless type transitions
 */
trait BuilderImplicits {
  implicit def forcePeriod(builder: DurationBuilder): Period
  implicit def forceDuration(builder: DurationBuilder): Duration
}

import com.github.nscala_time.time.Imports._

// Automatic conversion from builder to Period
val period: Period = 2.months + 3.days  // DurationBuilder -> Period

// Automatic conversion from builder to Duration  
val duration: Duration = 2.hours + 30.minutes  // DurationBuilder -> Duration

// Use in contexts expecting specific types
def takePeriod(p: Period): Unit = println(s"Period: $p")
def takeDuration(d: Duration): Unit = println(s"Duration: $d")

takePeriod(3.months + 2.weeks)    // implicit conversion
takeDuration(1.hour + 30.minutes)  // implicit conversion

import com.github.nscala_time.time.Imports._

// Mix periods and durations
val complexTime = 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds

// Chain operations
val chained = DateTime.now + 2.weeks - 3.days + 6.hours

// Build incrementally
var accumulator = 0.seconds
accumulator = accumulator + 1.minute
accumulator = accumulator + 30.seconds
accumulator = accumulator + 500.millis

import com.github.nscala_time.time.Imports._

// Calculate time ranges
val meetingStart = DateTime.now + 1.hour
val meetingDuration = 1.hour + 30.minutes
val meetingEnd = meetingStart + meetingDuration

// Time differences
val deadline = DateTime.parse("2024-12-31T23:59:59")
val timeRemaining = deadline - DateTime.now

// Periodic scheduling
val daily = 1.day
val weekly = 1.week  
val monthly = 1.month

val nextDaily = daily.from(DateTime.now)
val nextWeekly = weekly.from(DateTime.now)