Static Factory Methods

/**
 * Static DateTime factory methods and convenience utilities
 */
object DateTime extends StaticDateTime {
  // Core factory methods
  def now: DateTime
  def now(zone: DateTimeZone): DateTime
  def now(chronology: Chronology): DateTime
  def parse(str: String): DateTime
  def parse(str: String, formatter: DateTimeFormatter): DateTime
  
  // Future convenience methods
  def nextSecond: DateTime
  def nextMinute: DateTime
  def nextHour: DateTime
  def nextDay: DateTime
  def tomorrow: DateTime
  def nextWeek: DateTime
  def nextMonth: DateTime
  def nextYear: DateTime
  
  // Past convenience methods
  def lastSecond: DateTime
  def lastMinute: DateTime
  def lastHour: DateTime
  def lastDay: DateTime
  def yesterday: DateTime
  def lastWeek: DateTime
  def lastMonth: DateTime
  def lastYear: DateTime
}

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

// Basic factory methods
val now = DateTime.now
val utcNow = DateTime.now(DateTimeZone.UTC)
val parsed = DateTime.parse("2024-12-25T14:30:00")

// Future convenience methods
val tomorrow = DateTime.tomorrow
val nextWeek = DateTime.nextWeek
val nextMonth = DateTime.nextMonth
val nextYear = DateTime.nextYear

// Past convenience methods  
val yesterday = DateTime.yesterday
val lastWeek = DateTime.lastWeek
val lastMonth = DateTime.lastMonth
val lastYear = DateTime.lastYear

// Temporal navigation patterns
val timeranges = List(
  DateTime.lastWeek to DateTime.now,
  DateTime.now to DateTime.nextWeek,
  DateTime.lastMonth to DateTime.nextMonth
)

// Scheduling examples
val dailySchedule = (0 until 7).map(d => DateTime.tomorrow + d.days)
val weeklyMeetings = (0 until 12).map(w => DateTime.nextWeek + w.weeks)

/**
 * Static LocalDate factory methods and utilities
 */
object LocalDate extends StaticLocalDate {
  // Core factory methods
  def fromCalendarFields(calendar: java.util.Calendar): LocalDate
  def fromDateFields(date: java.util.Date): LocalDate
  def now: LocalDate
  def now(zone: DateTimeZone): LocalDate
  def now(chronology: Chronology): LocalDate
  def today: LocalDate
  def parse(str: String): LocalDate
  def parse(str: String, formatter: DateTimeFormatter): LocalDate
  
  // Future convenience methods
  def nextDay: LocalDate
  def tomorrow: LocalDate
  def nextWeek: LocalDate
  def nextMonth: LocalDate
  def nextYear: LocalDate
  
  // Past convenience methods
  def lastDay: LocalDate
  def yesterday: LocalDate
  def lastWeek: LocalDate
  def lastMonth: LocalDate
  def lastYear: LocalDate
}

import com.github.nscala_time.time.Imports._
import java.util.{Date, Calendar}

// Factory methods
val today = LocalDate.today
val parsed = LocalDate.parse("2024-12-25")
val fromJavaDate = LocalDate.fromDateFields(new Date())
val fromCalendar = LocalDate.fromCalendarFields(Calendar.getInstance())

// Convenience navigation
val tomorrow = LocalDate.tomorrow
val yesterday = LocalDate.yesterday
val nextWeek = LocalDate.nextWeek
val lastMonth = LocalDate.lastMonth

// Date range generation
val thisWeek = (0 until 7).map(d => LocalDate.today + d.days)
val nextMonthDays = (1 to 31).map(d => LocalDate.nextMonth.withDayOfMonth(d))
  .filter(date => date.getMonthOfYear == LocalDate.nextMonth.getMonthOfYear)

// Business logic examples
def isWeekend(date: LocalDate): Boolean = {
  val dayOfWeek = date.getDayOfWeek
  dayOfWeek == 6 || dayOfWeek == 7  // Saturday or Sunday
}

val nextBusinessDay = if (isWeekend(LocalDate.tomorrow)) {
  LocalDate.nextWeek.withDayOfWeek(1)  // Next Monday
} else {
  LocalDate.tomorrow
}

/**
 * Static LocalTime factory methods and utilities
 */
object LocalTime extends StaticLocalTime {
  // Constants
  val MIDNIGHT: LocalTime
  val Midnight: LocalTime  // Scala-style alias
  val NOON: LocalTime
  
  // Core factory methods
  def fromCalendarFields(calendar: java.util.Calendar): LocalTime
  def fromDateFields(date: java.util.Date): LocalTime
  def fromMillisOfDay(millis: Long): LocalTime
  def now: LocalTime
  def now(zone: DateTimeZone): LocalTime
  def now(chronology: Chronology): LocalTime
  def parse(str: String): LocalTime
  def parse(str: String, formatter: DateTimeFormatter): LocalTime
  
  // Future convenience methods
  def nextSecond: LocalTime
  def nextMinute: LocalTime
  def nextHour: LocalTime
  
  // Past convenience methods
  def lastSecond: LocalTime
  def lastMinute: LocalTime
  def lastHour: LocalTime
}

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

// Constants and basic creation
val midnight = LocalTime.MIDNIGHT
val noon = LocalTime.NOON
val now = LocalTime.now
val parsed = LocalTime.parse("14:30:00")

// Time calculations
val businessStart = LocalTime.parse("09:00")
val businessEnd = LocalTime.parse("17:00")
val lunchTime = LocalTime.parse("12:00")

// Time navigation
val nextHour = LocalTime.nextHour
val lastMinute = LocalTime.lastMinute

// Millisecond-based creation
val fromMillis = LocalTime.fromMillisOfDay(3600000L)  // 01:00:00

// Time range generation
val businessHours = {
  val start = LocalTime.parse("09:00")
  val end = LocalTime.parse("17:00")
  val hours = for (h <- 9 to 16) yield LocalTime.parse(f"$h%02d:00")
  hours.toList
}

// Meeting scheduler example
def generateMeetingSlots(start: LocalTime, end: LocalTime, slotDuration: Int): List[LocalTime] = {
  val startMillis = start.getMillisOfDay
  val endMillis = end.getMillisOfDay
  val slotMillis = slotDuration * 60 * 1000  // Convert minutes to milliseconds
  
  (startMillis until endMillis by slotMillis)
    .map(LocalTime.fromMillisOfDay)
    .toList
}

/**
 * Static LocalDateTime factory methods and utilities
 */
object LocalDateTime extends StaticLocalDateTime {
  // Core factory methods
  def fromCalendarFields(calendar: java.util.Calendar): LocalDateTime
  def fromDateFields(date: java.util.Date): LocalDateTime
  def now: LocalDateTime
  def now(zone: DateTimeZone): LocalDateTime
  def now(chronology: Chronology): LocalDateTime
  def parse(str: String): LocalDateTime
  def parse(str: String, formatter: DateTimeFormatter): LocalDateTime
  
  // Future convenience methods
  def nextSecond: LocalDateTime
  def nextMinute: LocalDateTime
  def nextHour: LocalDateTime
  def nextDay: LocalDateTime
  def tomorrow: LocalDateTime
  def nextWeek: LocalDateTime
  def nextMonth: LocalDateTime
  def nextYear: LocalDateTime
  
  // Past convenience methods
  def lastSecond: LocalDateTime
  def lastMinute: LocalDateTime
  def lastHour: LocalDateTime
  def lastDay: LocalDateTime
  def yesterday: LocalDateTime
  def lastWeek: LocalDateTime
  def lastMonth: LocalDateTime
  def lastYear: LocalDateTime
}

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

// Basic creation
val now = LocalDateTime.now
val parsed = LocalDateTime.parse("2024-12-25T14:30:00")
val tomorrow = LocalDateTime.tomorrow

// Specific time creation
val meetingTime = LocalDateTime.now
  .withHour(14)
  .withMinute(30)
  .withSecond(0)
  .withMillisOfSecond(0)

// Scheduling patterns
val dailyReports = (1 to 7).map(d => 
  LocalDateTime.now.plusDays(d).withHour(9).withMinute(0).withSecond(0)
)

val weeklyMeetings = (1 to 12).map(w =>
  LocalDateTime.nextWeek.plusWeeks(w-1).withDayOfWeek(1).withHour(10).withMinute(0)
)

/**
 * Static Period factory methods and utilities
 */
object Period extends StaticPeriod {
  // Core factory methods
  def parse(str: String): Period
  def parse(str: String, formatter: PeriodFormatter): Period
  def fieldDifference(start: ReadablePartial, end: ReadablePartial): Period
  
  // Time unit factories
  def days(days: Int): Period
  def hours(hours: Int): Period
  def millis(millis: Int): Period
  def minutes(minutes: Int): Period
  def months(months: Int): Period
  def seconds(seconds: Int): Period
  def weeks(weeks: Int): Period
  def years(years: Int): Period
}

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

// Basic period creation
val oneWeek = Period.weeks(1)
val twoMonths = Period.months(2)
val thirtyDays = Period.days(30)
val sixHours = Period.hours(6)

// Parsing periods
val parsedPeriod = Period.parse("P1Y2M3DT4H5M6S")  // ISO 8601 format
val customPeriod = Period.parse("1 year 2 months", customFormatter)

// Field difference calculations
val start = LocalDate.parse("2024-01-01")
val end = LocalDate.parse("2024-12-31")
val difference = Period.fieldDifference(start, end)

// Complex period combinations
val projectDuration = Period.months(6).plusWeeks(2).plusDays(3)
val sprintLength = Period.weeks(2)
val releaseSchedule = (1 to 6).map(sprint => sprintLength.multipliedBy(sprint))

/**
 * Static Duration factory methods and utilities
 */
object Duration extends StaticDuration {
  // Core factory methods
  def parse(str: String): Duration
  def millis(millis: Long): Duration
  
  // Standard duration factories
  def standardDays(days: Long): Duration
  def standardHours(hours: Long): Duration
  def standardMinutes(minutes: Long): Duration
  def standardSeconds(seconds: Long): Duration
}

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

// Standard duration creation
val oneHour = Duration.standardHours(1)
val thirtyMinutes = Duration.standardMinutes(30)
val fiveSeconds = Duration.standardSeconds(5)
val twoMillis = Duration.millis(2)

// Parsing durations
val parsedDuration = Duration.parse("PT1H30M")  // ISO 8601 format

// Duration calculations
val totalDuration = Duration.standardHours(2) + Duration.standardMinutes(30)
val halfDuration = Duration.standardHours(1).dividedBy(2)

// Performance timing
def timeOperation[T](operation: => T): (T, Duration) = {
  val start = System.currentTimeMillis()
  val result = operation
  val end = System.currentTimeMillis()
  val duration = Duration.millis(end - start)
  (result, duration)
}

/**
 * Static Interval factory methods and utilities
 */
object Interval extends StaticInterval {
  // Core factory methods
  def parse(str: String): Interval
  
  // Current time intervals
  def thisSecond: Interval
  def thisMinute: Interval
  def thisHour: Interval
  def thisDay: Interval
  def today: Interval
  def thisWeek: Interval
  def thisMonth: Interval
  def thisYear: Interval
  
  // Future intervals
  def nextSecond: Interval
  def nextMinute: Interval
  def nextHour: Interval
  def nextDay: Interval
  def tomorrow: Interval
  def nextWeek: Interval
  def nextMonth: Interval
  def nextYear: Interval
  
  // Past intervals
  def lastSecond: Interval
  def lastMinute: Interval
  def lastHour: Interval
  def lastDay: Interval
  def yesterday: Interval
  def lastWeek: Interval
  def lastMonth: Interval
  def lastYear: Interval
}

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

// Current time intervals
val today = Interval.today
val thisWeek = Interval.thisWeek
val thisMonth = Interval.thisMonth
val thisYear = Interval.thisYear

// Past and future intervals
val yesterday = Interval.yesterday
val tomorrow = Interval.tomorrow
val lastMonth = Interval.lastMonth
val nextYear = Interval.nextYear

// Interval operations
val isNowInThisWeek = thisWeek.contains(DateTime.now)
val weekDuration = thisWeek.toDuration
val daysInMonth = thisMonth.toPeriod.getDays

// Custom interval creation
val workingHours = new Interval(
  DateTime.now.withHour(9).withMinute(0),
  DateTime.now.withHour(17).withMinute(0)
)

val projectTimeline = new Interval(
  DateTime.parse("2024-01-01T00:00:00"),
  DateTime.parse("2024-12-31T23:59:59")
)

// Interval analysis
def analyzeInterval(interval: Interval): Map[String, Any] = {
  Map(
    "start" -> interval.getStart,
    "end" -> interval.getEnd,
    "duration" -> interval.toDuration,
    "durationHours" -> interval.toDuration.getStandardHours,
    "durationDays" -> interval.toDuration.getStandardDays
  )
}

/**
 * Static DateTimeZone utilities and factory methods
 */
object DateTimeZone extends StaticDateTimeZone {
  // Constants
  lazy val UTC: DateTimeZone
  
  // Factory methods
  def forID(id: String): DateTimeZone
  def forOffsetHours(hours: Int): DateTimeZone
  def forOffsetHoursMinutes(hours: Int, minutes: Int): DateTimeZone
  def forOffsetMillis(millis: Int): DateTimeZone
  def forTimeZone(zone: java.util.TimeZone): DateTimeZone
  
  // Utility methods
  def getAvailableIDs(): java.util.Set[String]
  def getDefault(): DateTimeZone
  def setDefault(zone: DateTimeZone): Unit
}

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

// Common timezone creation
val utc = DateTimeZone.UTC
val newYork = DateTimeZone.forID("America/New_York")
val tokyo = DateTimeZone.forID("Asia/Tokyo")
val london = DateTimeZone.forID("Europe/London")

// Offset-based timezones
val plus5 = DateTimeZone.forOffsetHours(5)
val minus8_30 = DateTimeZone.forOffsetHoursMinutes(-8, -30)

// Working with different timezones
val utcNow = DateTime.now(DateTimeZone.UTC)
val tokyoTime = utcNow.withZone(DateTimeZone.forID("Asia/Tokyo"))
val newYorkTime = utcNow.withZone(DateTimeZone.forID("America/New_York"))

// Timezone conversion utilities
def convertTimeZone(dt: DateTime, fromZone: String, toZone: String): DateTime = {
  dt.withZone(DateTimeZone.forID(fromZone))
    .withZone(DateTimeZone.forID(toZone))
}

// Available timezone listing
val availableZones = DateTimeZone.getAvailableIDs().asScala.toList.sorted
val usZones = availableZones.filter(_.startsWith("America/"))

/**
 * Static DateTimeFormat utilities and factory methods
 */
object DateTimeFormat extends StaticDateTimeFormat {
  // Pattern-based formatters
  def forPattern(pattern: String): DateTimeFormatter
  def forStyle(style: String): DateTimeFormatter
  
  // Predefined formatters
  def fullDate(): DateTimeFormatter
  def fullDateTime(): DateTimeFormatter
  def fullTime(): DateTimeFormatter
  def longDate(): DateTimeFormatter
  def longDateTime(): DateTimeFormatter
  def longTime(): DateTimeFormatter
  def mediumDate(): DateTimeFormatter
  def mediumDateTime(): DateTimeFormatter
  def mediumTime(): DateTimeFormatter
  def shortDate(): DateTimeFormatter
  def shortDateTime(): DateTimeFormatter
  def shortTime(): DateTimeFormatter
  
  // Utility methods
  def patternForStyle(style: String, locale: java.util.Locale): String
}

import com.github.nscala_time.time.Imports._
import java.util.Locale

// Custom pattern formatters
val isoFormatter = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss")
val displayFormatter = DateTimeFormat.forPattern("MMMM dd, yyyy 'at' HH:mm")
val fileNameFormatter = DateTimeFormat.forPattern("yyyyMMdd_HHmmss")

// Predefined formatters
val fullDateFormatter = DateTimeFormat.fullDate()
val shortTimeFormatter = DateTimeFormat.shortTime()
val mediumDateTimeFormatter = DateTimeFormat.mediumDateTime()

// Formatting examples
val now = DateTime.now
val isoString = isoFormatter.print(now)
val displayString = displayFormatter.print(now)
val fileNameString = fileNameFormatter.print(now)

// Locale-specific formatting
val usFormatter = DateTimeFormat.shortDate().withLocale(Locale.US)
val ukFormatter = DateTimeFormat.shortDate().withLocale(Locale.UK)
val usDate = usFormatter.print(now)  // MM/dd/yyyy
val ukDate = ukFormatter.print(now)  // dd/MM/yyyy

// Pattern utilities
val pattern = DateTimeFormat.patternForStyle("MS", Locale.getDefault)
val styleFormatter = DateTimeFormat.forPattern(pattern)

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

// Application startup configuration
object TimeConfig {
  val applicationTimeZone: DateTimeZone = DateTimeZone.forID("UTC")
  val defaultFormatter: DateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss")
  
  def setApplicationDefaults(): Unit = {
    DateTimeZone.setDefault(applicationTimeZone)
  }
}

// Standard time boundaries
object TimeBoundaries {
  def startOfDay(date: LocalDate): DateTime = date.toDateTimeAtStartOfDay
  def endOfDay(date: LocalDate): DateTime = date.toDateTimeAtStartOfDay.plusDays(1).minusMillis(1)
  def startOfWeek(date: LocalDate): LocalDate = date.withDayOfWeek(1)
  def endOfWeek(date: LocalDate): LocalDate = date.withDayOfWeek(7)
  def startOfMonth(date: LocalDate): LocalDate = date.withDayOfMonth(1)
  def endOfMonth(date: LocalDate): LocalDate = date.dayOfMonth.withMaximumValue()
}

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

// Generate time series
def generateDailyTimes(start: LocalDate, days: Int): List[LocalDate] = {
  (0 until days).map(d => start.plusDays(d)).toList
}

def generateBusinessDays(start: LocalDate, weeks: Int): List[LocalDate] = {
  (0 until weeks).flatMap { w =>
    val weekStart = start.plusWeeks(w)
    (1 to 5).map(d => weekStart.withDayOfWeek(d))
  }.toList
}

// Batch parsing with error handling
def parseMultipleDates(dateStrings: List[String]): (List[DateTime], List[String]) = {
  val (successful, failed) = dateStrings.partition(s => s.toDateTimeOption.isDefined)
  val dates = successful.flatMap(_.toDateTimeOption)
  (dates, failed)
}