use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
 
fn main() {
    // Create from components
    let date = NaiveDate::from_ymd_opt(2024, 3, 15).unwrap();
    let time = NaiveTime::from_hms_opt(14, 30, 0).unwrap();
    let naive = NaiveDateTime::new(date, time);
    
    println!("{}", naive);  // 2024-03-15 14:30:00
    
    // Parse from string
    let parsed: NaiveDateTime = "2024-03-15 14:30:00".parse().unwrap();
    
    // No timezone information - just a date and time
}

use chrono::{DateTime, Utc, FixedOffset, TimeZone};
 
fn main() {
    // DateTime<Utc> - UTC timezone
    let utc_now: DateTime<Utc> = Utc::now();
    println!("{}", utc_now);  // 2024-03-15 14:30:00 UTC
    
    // DateTime<FixedOffset> - fixed offset from UTC
    let offset = FixedOffset::east_opt(5 * 3600).unwrap();  // +05:00
    let dt = offset.with_ymd_and_hms(2024, 3, 15, 14, 30, 0).unwrap();
    println!("{}", dt);  // 2024-03-15 14:30:00 +05:00
    
    // DateTime carries timezone information
}

use chrono::{NaiveDateTime, Utc, FixedOffset, TimeZone};
 
fn main() {
    let naive = NaiveDate::from_ymd_opt(2024, 3, 15).unwrap()
        .and_hms_opt(14, 30, 0).unwrap();
    
    // Same naive datetime could mean different moments:
    let utc_dt = Utc.from_utc_datetime(&naive);
    let est_dt = FixedOffset::west_opt(5 * 3600).unwrap()
        .from_utc_datetime(&naive);
    
    // These represent different actual moments
    println!("UTC: {}", utc_dt);  // 2024-03-15 14:30:00 UTC
    println!("EST: {}", est_dt);  // 2024-03-15 14:30:00 -05:00
    
    // The naive datetime alone can't tell us which moment
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone};
 
fn main() {
    // NaiveDateTime -> DateTime (add timezone)
    let naive = "2024-03-15 14:30:00".parse::<NaiveDateTime>().unwrap();
    
    // Interpret as UTC
    let utc: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    // Interpret as local time
    let local: DateTime<chrono::Local> = chrono::Local.from_local_datetime(&naive).single().unwrap();
    
    // DateTime -> NaiveDateTime (strip timezone)
    let naive_again: NaiveDateTime = utc.naive_utc();
    
    // The conversion loses timezone information
}

use chrono::{DateTime, Utc, TimeZone};
 
fn main() {
    // DateTime<Utc> is the most common timezone-aware type
    let now: DateTime<Utc> = Utc::now();
    
    // Can be unambiguously stored and compared
    let later: DateTime<Utc> = Utc::now();
    
    if later > now {
        println!("Time passed");
    }
    
    // UTC has no daylight saving time, no ambiguous times
    // Every UTC timestamp represents exactly one moment
}

use chrono::{DateTime, FixedOffset, Utc, TimeZone};
 
fn main() {
    // FixedOffset: constant offset from UTC
    let fixed = FixedOffset::east_opt(2 * 3600).unwrap();  // +02:00
    let dt_fixed: DateTime<FixedOffset> = fixed.with_ymd_and_hms(2024, 3, 15, 14, 30, 0).unwrap();
    
    // Fixed offset never changes - no daylight saving time
    // "Europe/Berlin" might be +01:00 or +02:00 depending on date
    
    // For full timezone support with DST, use chrono-tz crate:
    // let dt_tz: DateTime<chrono_tz::Tz> = ...
}

use chrono::{NaiveDateTime, TimeZone};
use chrono_tz::Europe::London;
 
fn main() {
    // DST transition in London (clocks go forward)
    // 2024-03-31 01:00:00 -> 2024-03-31 03:00:00 (spring forward)
    
    let naive = "2024-03-31 01:30:00".parse::<NaiveDateTime>().unwrap();
    
    // This time doesn't exist in London timezone!
    let result = London.from_local_datetime(&naive);
    match result {
        chrono::LocalResult::Single(dt) => println!("Unique: {}", dt),
        chrono::LocalResult::Ambiguous(earliest, latest) => {
            println!("Ambiguous: {} or {}", earliest, latest);
        }
        chrono::LocalResult::None => println!("No valid time (during DST transition)"),
    }
    
    // NaiveDateTime can represent non-existent local times
    // DateTime<Tz> cannot - it must represent a real moment
}

use chrono::{NaiveDateTime, TimeZone};
use chrono_tz::America::New_York;
 
fn main() {
    // DST transition (fall back) - 2024-11-03 at 2 AM in New York
    // Times from 1:00 AM to 2:00 AM occur twice
    
    let naive = "2024-11-03 01:30:00".parse::<NaiveDateTime>().unwrap();
    
    // This time is ambiguous - it could be EDT or EST
    let result = New_York.from_local_datetime(&naive);
    
    match result {
        chrono::LocalResult::Ambiguous(early, late) => {
            println!("Early (EDT): {}", early);  // 01:30 EDT
            println!("Late (EST): {}", late);    // 01:30 EST (same clock time, different UTC)
        }
        _ => {}
    }
}

use chrono::{NaiveDateTime, TimeZone, Utc};
use chrono_tz::Europe::Paris;
 
fn main() {
    let naive = "2024-03-15 14:30:00".parse::<NaiveDateTime>().unwrap();
    
    // from_utc_datetime: treat naive datetime as UTC, convert to timezone
    let from_utc = Paris.from_utc_datetime(&naive);
    // "2024-03-15 14:30:00 UTC" displayed in Paris timezone
    println!("From UTC: {}", from_utc);
    
    // from_local_datetime: treat naive datetime as local time in timezone
    let from_local = Paris.from_local_datetime(&naive).single().unwrap();
    // "2024-03-15 14:30:00 in Paris" - a specific moment
    println!("From local: {}", from_local);
    
    // These produce different UTC timestamps!
}

use chrono::{NaiveDateTime, DateTime, Utc};
 
fn main() {
    // NaiveDateTime serialization
    let naive = "2024-03-15 14:30:00".parse::<NaiveDateTime>().unwrap();
    println!("Naive: {}", naive);  // 2024-03-15 14:30:00
    // No timezone in output
    
    // DateTime<Utc> serialization
    let utc: DateTime<Utc> = "2024-03-15T14:30:00Z".parse().unwrap();
    println!("UTC: {}", utc);  // 2024-03-15 14:30:00 UTC
    
    // ISO 8601 with timezone
    let utc_string = utc.to_rfc3339();
    println!("RFC 3339: {}", utc_string);  // 2024-03-15T14:30:00+00:00
}

use chrono::{NaiveDateTime, DateTime, Utc};
 
fn main() {
    // NaiveDateTime: parse datetime without timezone
    let naive: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    
    // DateTime: parse datetime with timezone
    let utc: DateTime<Utc> = "2024-03-15T14:30:00Z".parse().unwrap();
    
    // Parsing with offset
    let with_offset: DateTime<chrono::FixedOffset> = 
        "2024-03-15T14:30:00+05:00".parse().unwrap();
    
    // NaiveDateTime cannot parse strings with timezone info
    // let fails: NaiveDateTime = "2024-03-15T14:30:00Z".parse().unwrap();
}

use chrono::{DateTime, Utc, FixedOffset, TimeZone};
 
fn main() {
    let utc: DateTime<Utc> = Utc::now();
    
    // Convert to different timezone
    let tokyo_offset = FixedOffset::east_opt(9 * 3600).unwrap();
    let tokyo_time: DateTime<FixedOffset> = utc.with_timezone(&tokyo_offset);
    
    println!("UTC: {}", utc);
    println!("Tokyo: {}", tokyo_time);
    
    // Both represent the SAME moment in time
    // Just displayed differently
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone};
 
fn main() {
    // Common pattern: parse naive, assume UTC, convert
    let naive: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    
    // Assume the input was UTC
    let utc: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    // Now we have an unambiguous timestamp
    println!("UTC: {}", utc);
    
    // This is the pattern for parsing timestamps from logs, APIs, etc.
    // that are documented as being in UTC
}

use chrono::{DateTime, Utc, FixedOffset, TimeZone};
 
fn main() {
    let utc1: DateTime<Utc> = "2024-03-15T14:30:00Z".parse().unwrap();
    let offset = FixedOffset::east_opt(5 * 3600).unwrap();
    let dt2: DateTime<FixedOffset> = offset.with_ymd_and_hms(2024, 3, 15, 19, 30, 0).unwrap();
    
    // These represent the same moment!
    // 14:30 UTC == 19:30 +05:00
    
    println!("UTC time: {}", utc1);
    println!("Offset time: {}", dt2);
    println!("UTC of offset: {}", dt2.with_timezone(&Utc));
    
    // Comparison works across timezones
    assert_eq!(utc1, dt2.with_timezone(&Utc));
}

use chrono::NaiveDateTime;
 
fn main() {
    let naive1: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    let naive2: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    
    // Comparison works - same date/time
    assert_eq!(naive1, naive2);
    
    // But we can't say if these represent the same moment
    // One could be UTC, one could be EST, etc.
}

use chrono::{NaiveDate, NaiveDateTime, Datelike};
 
fn main() {
    let naive = "2024-03-15T14:30:00".parse::<NaiveDateTime>().unwrap();
    
    // Date-only operations don't need timezone
    let date = naive.date();
    println!("Year: {}", date.year());
    println!("Month: {}", date.month());
    println!("Day: {}", date.day());
    
    // Day of week doesn't depend on timezone
    println!("Weekday: {}", date.weekday());
}

use chrono::{DateTime, Utc, FixedOffset, TimeZone};
 
fn main() {
    // Scheduling a meeting across timezones
    let meeting_utc: DateTime<Utc> = "2024-03-15T14:00:00Z".parse().unwrap();
    
    // Convert to each participant's timezone
    let ny_offset = FixedOffset::west_opt(5 * 3600).unwrap();
    let tokyo_offset = FixedOffset::east_opt(9 * 3600).unwrap();
    
    let ny_time = meeting_utc.with_timezone(&ny_offset);
    let tokyo_time = meeting_utc.with_timezone(&tokyo_offset);
    
    println!("Meeting time:");
    println!("  UTC: {}", meeting_utc);
    println!("  New York: {}", ny_time);    // 09:00 -05:00
    println!("  Tokyo: {}", tokyo_time);    // 23:00 +09:00
    
    // All represent the same moment
}

use chrono::{DateTime, Utc, NaiveDateTime};
 
// Best practice for database timestamps:
 
// Store as UTC (unambiguous)
// DateTime<Utc> maps to TIMESTAMP WITH TIME ZONE in many databases
// Or store as epoch milliseconds/nanoseconds
 
// For display, convert to local timezone
// For queries that compare times, use UTC
 
// Don't store NaiveDateTime for timestamps that need to be compared
// across timezones or used for chronological ordering
 
// Use NaiveDateTime for:
// - Birthdates (no timezone)
// - Event times where timezone is stored separately
// - Intermediate parsing before timezone assignment

use chrono::{DateTime, Utc, NaiveDateTime, Duration};
 
fn main() {
    // Duration between DateTime values
    let dt1: DateTime<Utc> = "2024-03-15T14:00:00Z".parse().unwrap();
    let dt2: DateTime<Utc> = "2024-03-15T16:30:00Z".parse().unwrap();
    
    let duration = dt2.signed_duration_since(dt1);
    println!("Duration: {} seconds", duration.num_seconds());  // 9000
    
    // Duration between NaiveDateTime values
    let n1: NaiveDateTime = "2024-03-15T14:00:00".parse().unwrap();
    let n2: NaiveDateTime = "2024-03-15T16:30:00".parse().unwrap();
    
    let naive_duration = n2.signed_duration_since(n1);
    println!("Duration: {} seconds", naive_duration.num_seconds());  // 9000
    
    // Both work, but DateTime durations are unambiguous about actual time
}

use chrono::{NaiveDateTime, DateTime, Utc};
 
// Use NaiveDateTime when:
// 1. Parsing datetime from external source before timezone is known
// 2. Storing dates without time component (birthdays, holidays)
// 3. Working with local conventions that don't need global coordination
// 4. Intermediate representation before timezone assignment
 
// Use DateTime<Tz> when:
// 1. Storing unambiguous timestamps (created_at, updated_at)
// 2. Comparing times across timezones
// 3. Converting between timezones for display
// 4. Handling DST transitions correctly
// 5. Serializing/deserializing with timezone context
 
fn main() {
    // Example: Parse naive, convert to aware
    let naive: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    
    // Document that input is UTC
    let aware: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    // Now safe for storage and comparison
}

// Cargo.toml: chrono-tz = "0.8"
 
use chrono::{NaiveDateTime, TimeZone};
use chrono_tz::{Europe::London, America::New_York, Asia::Tokyo};
 
fn main() {
    let naive: NaiveDateTime = "2024-03-15T14:30:00".parse().unwrap();
    
    // Named timezones with DST handling
    let london: DateTime<_> = London.from_local_datetime(&naive).single().unwrap();
    let ny: DateTime<_> = New_York.from_local_datetime(&naive).single().unwrap();
    let tokyo: DateTime<_> = Tokyo.from_local_datetime(&naive).single().unwrap();
    
    println!("London: {}", london);
    println!("New York: {}", ny);
    println!("Tokyo: {}", tokyo);
    
    // All represent the same local clock time, different moments
}