Ordering and Comparisons

/**
 * Ordering instances for date/time types
 */
trait OrderingImplicits extends LowPriorityOrderingImplicits {
  implicit val DateTimeOrdering: Ordering[DateTime]
  implicit val LocalDateOrdering: Ordering[LocalDate]
  implicit val LocalTimeOrdering: Ordering[LocalTime]
  implicit val LocalDateTimeOrdering: Ordering[LocalDateTime]
  implicit val DurationOrdering: Ordering[Duration]
}

/**
 * Generic ordering support for Joda Time types
 */
trait LowPriorityOrderingImplicits {
  implicit def ReadableInstantOrdering[A <: ReadableInstant]: Ordering[A]
  implicit def ReadablePartialOrdering[A <: ReadablePartial]: Ordering[A]
  implicit def BaseSingleFieldPeriodOrdering[A <: BaseSingleFieldPeriod]: Ordering[A]
  implicit def ReadableDurationOrdering[A <: ReadableDuration]: Ordering[A]
}

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

// DateTime ordering
val dt1 = DateTime.parse("2023-01-01T10:00:00")
val dt2 = DateTime.parse("2023-01-01T11:00:00")
val dt3 = DateTime.parse("2023-01-02T10:00:00")

// Direct comparisons
val isBefore = dt1 < dt2  // true
val isAfter = dt2 > dt1   // true
val isEqual = dt1 == dt1  // true

// Sorting collections
val dateTimes = List(dt3, dt1, dt2)
val sorted = dateTimes.sorted  // List(dt1, dt2, dt3) - chronological order
val reverse = dateTimes.sorted(Ordering[DateTime].reverse)

// LocalDate ordering
val ld1 = LocalDate.parse("2023-01-01")
val ld2 = LocalDate.parse("2023-01-15")
val ld3 = LocalDate.parse("2023-02-01")

val localDates = List(ld3, ld1, ld2)
val sortedDates = localDates.sorted  // Chronological order

// Duration ordering
val dur1 = Duration.standardHours(1)
val dur2 = Duration.standardHours(2)
val dur3 = Duration.standardMinutes(30)

val durations = List(dur2, dur3, dur1)  
val sortedDurations = durations.sorted  // List(dur3, dur1, dur2) - by length

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

// Finding min/max in collections
val times = List(
  DateTime.parse("2023-01-15T10:00:00"),
  DateTime.parse("2023-01-01T10:00:00"),
  DateTime.parse("2023-02-01T10:00:00")
)

val earliest = times.min  // 2023-01-01T10:00:00
val latest = times.max    // 2023-02-01T10:00:00

// Filtering with comparisons
val cutoffDate = DateTime.parse("2023-01-15T00:00:00")
val afterCutoff = times.filter(_ > cutoffDate)
val beforeCutoff = times.filter(_ < cutoffDate)

// Grouping by comparison
val grouped = times.groupBy(_ > cutoffDate)
// Map(false -> List(early dates), true -> List(late dates))

// Working with ranges
val startDate = LocalDate.parse("2023-01-01")
val endDate = LocalDate.parse("2023-01-31")

// Custom range operations
def isInRange(date: LocalDate, start: LocalDate, end: LocalDate): Boolean = {
  date >= start && date <= end
}

val testDate = LocalDate.parse("2023-01-15")
val inRange = isInRange(testDate, startDate, endDate)  // true

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

val now = DateTime.now()
val later = now + 1.hour
val earlier = now - 1.hour

// All comparison operators work
val isLess = earlier < now        // true
val isLessOrEqual = now <= later  // true
val isGreater = later > now       // true
val isGreaterOrEqual = now >= earlier  // true
val isEqual = now == now          // true
val isNotEqual = now != later     // true

// Works with all date/time types
val date1 = LocalDate.now()
val date2 = date1 + 1.day

val dateComparison = date1 < date2  // true

val time1 = LocalTime.now()
val time2 = time1 + 1.hour

val timeComparison = time1 < time2  // true

import com.github.nscala_time.time.Imports._
import scala.collection.mutable.PriorityQueue

// Priority queue with DateTime (earliest first)
implicit val earliestFirst: Ordering[DateTime] = Ordering[DateTime].reverse
val scheduledTasks = PriorityQueue[DateTime]()

scheduledTasks.enqueue(DateTime.now() + 1.hour)
scheduledTasks.enqueue(DateTime.now() + 30.minutes)
scheduledTasks.enqueue(DateTime.now() + 2.hours)

val nextTask = scheduledTasks.dequeue()  // Returns earliest (30 minutes from now)

// Sorting with custom criteria
case class Event(name: String, time: DateTime)

val events = List(
  Event("Meeting", DateTime.now() + 1.hour),
  Event("Lunch", DateTime.now() + 30.minutes),
  Event("Call", DateTime.now() + 2.hours)
)

// Sort by time
val sortedByTime = events.sortBy(_.time)

// Custom ordering for events
implicit val eventOrdering: Ordering[Event] = Ordering.by(_.time)
val sortedEvents = events.sorted

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

val now = DateTime.now()
val interval1 = now to (now + 1.hour)
val interval2 = (now + 30.minutes) to (now + 90.minutes)
val interval3 = (now + 2.hours) to (now + 3.hours)

// Interval relationships
val overlaps = interval1.overlaps(interval2)      // true
val contains = interval1.contains(now + 15.minutes)  // true
val isBefore = interval1.isBefore(interval3)      // true
val isAfter = interval3.isAfter(interval1)        // true

// Sorting intervals by start time
val intervals = List(interval3, interval1, interval2)
val sortedByStart = intervals.sortBy(_.getStart)

// Sorting by duration
val sortedByDuration = intervals.sortBy(_.toDurationMillis)

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

// Custom ordering: sort by time of day, ignoring date
implicit val timeOfDayOrdering: Ordering[DateTime] = 
  Ordering.by(dt => dt.getMillisOfDay)

val dateTimes = List(
  DateTime.parse("2023-01-01T14:30:00"),
  DateTime.parse("2023-02-15T09:15:00"),
  DateTime.parse("2023-12-25T16:45:00")
)

val sortedByTimeOfDay = dateTimes.sorted(timeOfDayOrdering)
// Results in: 09:15, 14:30, 16:45 regardless of date

// Custom ordering: sort LocalDate by day of year
implicit val dayOfYearOrdering: Ordering[LocalDate] = 
  Ordering.by(ld => ld.getDayOfYear)

// Custom ordering: reverse chronological order
implicit val reverseChronological: Ordering[DateTime] = 
  Ordering[DateTime].reverse

// Multiple criteria ordering
case class Appointment(date: LocalDate, time: LocalTime, priority: Int)

implicit val appointmentOrdering: Ordering[Appointment] = 
  Ordering.by(a => (a.date, a.time, -a.priority))  // Date, then time, then priority (high first)

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

val dateTime = DateTime.now()
val localDate = LocalDate.now()
val duration = Duration.standardHours(1)

// These work - same types
val dateTimeComparison = dateTime < (dateTime + 1.hour)  // OK
val localDateComparison = localDate < (localDate + 1.day)  // OK
val durationComparison = duration < Duration.standardHours(2)  // OK

// These would be compile errors - different types
// val mixedComparison1 = dateTime < localDate  // Compile error
// val mixedComparison2 = dateTime < duration   // Compile error

// Conversions needed for cross-type comparisons
val dateTimeFromLocal = localDate.toDateTimeAtCurrentTime()
val validComparison = dateTime < dateTimeFromLocal  // OK after conversion