use chrono::{NaiveDateTime, TimeZone, Utc, FixedOffset, DateTime};
 
fn main() {
    // NaiveDateTime: datetime without timezone information
    let naive: NaiveDateTime = "2024-01-15 10:30:00".parse().unwrap();
    println!("Naive: {}", naive);
    // NaiveDateTime has no concept of UTC offset
    
    // DateTime<Tz>: datetime with timezone context
    let utc_datetime: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("UTC: {}", utc_datetime);
    
    // The timezone carries offset information
    println!("UTC offset: {:?}", utc_datetime.offset());
    
    // Naive datetime can be interpreted as UTC directly
    // because UTC has no daylight saving or offset changes
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime};
 
fn main() {
    // Create a naive datetime (no timezone)
    let naive = NaiveDateTime::from_timestamp_opt(1705315800, 0).unwrap();
    println!("Naive datetime: {}", naive);
    
    // Convert to timezone-aware using from_utc_datetime
    // This interprets the naive datetime as being in UTC
    let utc_datetime: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("UTC datetime: {}", utc_datetime);
    
    // The method signature:
    // fn from_utc_datetime(&self, dt: &NaiveDateTime) -> DateTime<Tz>
    
    // Key insight: from_utc_datetime assumes the NaiveDateTime is in UTC
    // and creates a DateTime in the target timezone
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime};
 
fn main() {
    let naive = "2024-06-15 12:00:00".parse::<NaiveDateTime>().unwrap();
    
    // UTC is the simplest timezone - offset is always +00:00
    let utc_datetime: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    println!("Naive as UTC: {}", utc_datetime);
    println!("RFC 2822: {}", utc_datetime.to_rfc2822());
    println!("RFC 3339: {}", utc_datetime.to_rfc3339());
    
    // UTC is special because:
    // 1. No offset changes (always +00:00)
    // 2. No daylight saving time
    // 3. The naive datetime IS the UTC time
    
    // For UTC, from_utc_datetime is straightforward:
    // The naive time is directly used as the UTC time
}

use chrono::{NaiveDateTime, TimeZone, FixedOffset, DateTime};
 
fn main() {
    let naive = "2024-06-15 12:00:00".parse::<NaiveDateTime>().unwrap();
    
    // FixedOffset: timezone with constant offset
    // Create offset of +2 hours (Europe/Berlin-like, but without DST)
    let plus_two = FixedOffset::east_opt(2 * 3600).unwrap();
    
    // from_utc_datetime interprets naive as UTC, then applies offset
    let datetime: DateTime<FixedOffset> = plus_two.from_utc_datetime(&naive);
    
    println!("Naive UTC: {}", naive);
    println!("As +02:00: {}", datetime);
    println!("With offset: {}", datetime.format("%Y-%m-%d %H:%M:%S %:z"));
    
    // Result: 2024-06-15 14:00:00 +02:00
    // The UTC time 12:00 becomes 14:00 in +02:00 timezone
    
    // Negative offset
    let minus_five = FixedOffset::west_opt(5 * 3600).unwrap();
    let datetime_minus: DateTime<FixedOffset> = minus_five.from_utc_datetime(&naive);
    println!("As -05:00: {}", datetime_minus);
    // Result: 2024-06-15 07:00:00 -05:00
}

use chrono::{NaiveDateTime, TimeZone, Utc, FixedOffset};
// In production, use chrono-tz crate for full timezone support:
// use chrono_tz::{Tz, America, Europe};
 
fn main() {
    let naive = "2024-06-15 12:00:00".parse::<NaiveDateTime>().unwrap();
    
    // Chrono provides:
    // 1. Utc - simple UTC timezone
    // 2. FixedOffset - fixed UTC offset
    // 3. chrono-tz crate - full IANA timezone database
    
    // FixedOffset is useful for:
    // - Simple offset conversions
    // - When DST is not relevant
    // - Static offset requirements
    
    // Example offsets:
    let est = FixedOffset::west_opt(5 * 3600).unwrap(); // -05:00
    let pst = FixedOffset::west_opt(8 * 3600).unwrap(); // -08:00
    let cet = FixedOffset::east_opt(1 * 3600).unwrap(); // +01:00
    
    let est_dt = est.from_utc_datetime(&naive);
    let pst_dt = pst.from_utc_datetime(&naive);
    let cet_dt = cet.from_utc_datetime(&naive);
    
    println!("EST: {}", est_dt);
    println!("PST: {}", pst_dt);
    println!("CET: {}", cet_dt);
}

use chrono::{NaiveDateTime, TimeZone, Utc, FixedOffset, DateTime};
 
fn main() {
    let naive = "2024-06-15 12:00:00".parse::<NaiveDateTime>().unwrap();
    
    // from_utc_datetime: interprets naive as being in UTC
    // "This naive datetime IS a UTC time, give me the local representation"
    let plus_two = FixedOffset::east_opt(2 * 3600).unwrap();
    let from_utc: DateTime<FixedOffset> = plus_two.from_utc_datetime(&naive);
    println!("from_utc_datetime: {}", from_utc);
    // Result: 2024-06-15 14:00:00 +02:00
    // (UTC 12:00 displayed as local time 14:00)
    
    // from_local_datetime: interprets naive as being in the local timezone
    // "This naive datetime IS a local time, give me the proper DateTime"
    // This is more complex due to DST and offset transitions
    let from_local = plus_two.from_local_datetime(&naive).single();
    println!("from_local_datetime: {:?}", from_local);
    // Result: 2024-06-15 12:00:00 +02:00
    // (Local 12:00 interpreted with +02:00 offset)
    
    // Key difference:
    // from_utc_datetime: UTC -> local (unambiguous)
    // from_local_datetime: local -> DateTime (may be ambiguous)
}

use chrono::{NaiveDateTime, TimeZone, FixedOffset, DateTime, LocalResult};
 
fn main() {
    // from_local_datetime can return:
    // - None (no valid local time)
    // - Single (unique valid time)
    // - Ambiguous (two possible times, e.g., during DST fallback)
    
    // from_utc_datetime is always unambiguous:
    // A UTC time always maps to exactly one local time
    
    // This is why from_utc_datetime returns DateTime directly,
    // while from_local_datetime returns LocalResult<DateTime>
    
    let naive = "2024-06-15 12:00:00".parse::<NaiveDateTime>().unwrap();
    let offset = FixedOffset::east_opt(2 * 3600).unwrap();
    
    // from_utc_datetime: always succeeds, returns DateTime
    let from_utc: DateTime<FixedOffset> = offset.from_utc_datetime(&naive);
    
    // from_local_datetime: may fail or be ambiguous, returns LocalResult
    let from_local: LocalResult<DateTime<FixedOffset>> = 
        offset.from_local_datetime(&naive);
    
    match from_local {
        LocalResult::None => println!("No valid local time"),
        LocalResult::Single(dt) => println!("Single: {}", dt),
        LocalResult::Ambiguous(dt1, dt2) => {
            println!("Ambiguous: {} or {}", dt1, dt2);
        }
    }
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime, FixedOffset};
 
fn main() {
    // Database stores timestamps as naive datetime (UTC)
    let db_timestamp: &str = "2024-06-15 10:30:00";
    let naive: NaiveDateTime = db_timestamp.parse().unwrap();
    
    // Application needs to display in user's timezone
    fn display_in_timezone(naive: NaiveDateTime, offset_seconds: i32) -> String {
        let tz = FixedOffset::east_opt(offset_seconds).unwrap();
        let datetime: DateTime<FixedOffset> = tz.from_utc_datetime(&naive);
        datetime.format("%Y-%m-%d %H:%M:%S %:z").to_string()
    }
    
    println!("UTC: {}", Utc.from_utc_datetime(&naive).format("%Y-%m-%d %H:%M:%S UTC"));
    println!("New York (EST): {}", display_in_timezone(naive, -5 * 3600));
    println!("Los Angeles (PST): {}", display_in_timezone(naive, -8 * 3600));
    println!("Berlin (CET): {}", display_in_timezone(naive, 1 * 3600));
    println!("Tokyo (JST): {}", display_in_timezone(naive, 9 * 3600));
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime, FixedOffset};
 
fn main() {
    // Parse a datetime string without timezone
    let input = "2024-12-25T18:30:00";
    let naive: NaiveDateTime = input.parse().unwrap();
    
    // Assume it's a UTC timestamp (common for APIs)
    let utc_datetime: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("As UTC: {}", utc_datetime);
    
    // Convert to various timezones for display
    let ny_offset = FixedOffset::west_opt(5 * 3600).unwrap();
    let tokyo_offset = FixedOffset::east_opt(9 * 3600).unwrap();
    
    let ny_time: DateTime<FixedOffset> = ny_offset.from_utc_datetime(&naive);
    let tokyo_time: DateTime<FixedOffset> = tokyo_offset.from_utc_datetime(&naive);
    
    println!("New York: {}", ny_time.format("%Y-%m-%d %H:%M:%S %:z"));
    println!("Tokyo: {}", tokyo_time.format("%Y-%m-%d %H:%M:%S %:z"));
    
    // Note: These are UTC offsets, not full timezone names
    // For full timezone support (including DST), use chrono-tz
}

use chrono::{NaiveDate, NaiveTime, NaiveDateTime, TimeZone, Utc, DateTime};
 
fn main() {
    // Build NaiveDateTime from components
    let date = NaiveDate::from_ymd_opt(2024, 6, 15).unwrap();
    let time = NaiveTime::from_hms_opt(14, 30, 45).unwrap();
    let naive = NaiveDateTime::new(date, time);
    
    println!("Built naive: {}", naive);
    
    // Convert to timezone-aware
    let datetime: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("As DateTime<Utc>: {}", datetime);
    
    // This is useful when you have date/time from different sources
    // and need to create a complete datetime
    
    // Alternative: use chrono::naive! macro (if available)
    // or NaiveDateTime::parse_from_str
    
    let from_str: NaiveDateTime = "2024-06-15 14:30:45".parse().unwrap();
    assert_eq!(naive, from_str);
}

use chrono::{TimeZone, Utc, DateTime, NaiveDateTime};
 
fn main() {
    // Unix timestamp (seconds since 1970-01-01 00:00:00 UTC)
    let timestamp: i64 = 1718463600;
    
    // Method 1: DateTime::from_timestamp (direct to DateTime<Utc>)
    let datetime1: DateTime<Utc> = DateTime::from_timestamp(timestamp, 0).unwrap();
    println!("From timestamp: {}", datetime1);
    
    // Method 2: via NaiveDateTime and from_utc_datetime
    let naive = NaiveDateTime::from_timestamp_opt(timestamp, 0).unwrap();
    let datetime2: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("Via from_utc_datetime: {}", datetime2);
    
    // Both produce the same result
    assert_eq!(datetime1, datetime2);
    
    // from_utc_datetime is more general: works with any TimeZone
    // from_timestamp is specific to Unix timestamps
    
    // Reverse: DateTime to Unix timestamp
    let ts = datetime1.timestamp();
    assert_eq!(ts, timestamp);
}

// Note: This example requires chrono-tz crate
// use chrono::{NaiveDateTime, TimeZone, DateTime};
// use chrono_tz::Tz;
// use chrono_tz::America::New_York;
// use chrono_tz::Europe::London;
// use chrono_tz::Asia::Tokyo;
 
fn main() {
    // Full timezone support with DST handling
    // chrono-tz provides IANA timezone database
    
    // let naive: NaiveDateTime = "2024-06-15 12:00:00".parse().unwrap();
    
    // Using chrono-tz for real timezone handling:
    // let ny_time: DateTime<Tz> = New_York.from_utc_datetime(&naive);
    // let london_time: DateTime<Tz> = London.from_utc_datetime(&naive);
    // let tokyo_time: DateTime<Tz> = Tokyo.from_utc_datetime(&naive);
    
    // println!("New York: {}", ny_time);
    // println!("London: {}", london_time);
    // println!("Tokyo: {}", tokyo_time);
    
    // These handle DST automatically:
    // - Summer: New York is EDT (-04:00)
    // - Winter: New York is EST (-05:00)
    
    // With FixedOffset, you'd have to handle DST manually
    
    println!("Use chrono-tz crate for full IANA timezone support");
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime, FixedOffset, serde::ts_seconds};
 
fn main() {
    // NaiveDateTime serializes without timezone
    let naive: NaiveDateTime = "2024-06-15T12:00:00".parse().unwrap();
    let naive_json = serde_json::to_string(&naive).unwrap();
    println!("Naive JSON: {}", naive_json);
    // Output: "2024-06-15T12:00:00"
    
    // DateTime<Utc> serializes with timezone
    let utc_dt: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    let utc_json = serde_json::to_string(&utc_dt).unwrap();
    println!("UTC JSON: {}", utc_json);
    // Output: "2024-06-15T12:00:00+00:00"
    
    // DateTime<FixedOffset> serializes with offset
    let plus_two = FixedOffset::east_opt(2 * 3600).unwrap();
    let offset_dt: DateTime<FixedOffset> = plus_two.from_utc_datetime(&naive);
    let offset_json = serde_json::to_string(&offset_dt).unwrap();
    println!("Offset JSON: {}", offset_json);
    // Output: "2024-06-15T14:00:00+02:00"
    
    // Deserialization
    let de_naive: NaiveDateTime = serde_json::from_str(&naive_json).unwrap();
    let de_utc: DateTime<Utc> = serde_json::from_str(&utc_json).unwrap();
    
    assert_eq!(naive, de_naive);
    assert_eq!(utc_dt, de_utc);
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime, FixedOffset};
 
fn main() {
    let naive: NaiveDateTime = "2024-06-15 12:00:00".parse().unwrap();
    
    // Method 1: from_utc_datetime
    let dt1: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    println!("from_utc_datetime: {}", dt1);
    
    // Method 2: NaiveDateTime::and_utc() (chrono 0.4.20+)
    // Assumes the naive datetime is UTC
    let dt2: DateTime<Utc> = naive.and_utc();
    println!("and_utc: {}", dt2);
    
    // Method 3: DateTime::from_naive_utc (if available)
    // Same as from_utc_datetime
    
    // Method 4: NaiveDateTime::into for Utc
    // Using From/Into trait
    let dt3: DateTime<Utc> = DateTime::<Utc>::from_naive_utc_and_offset(naive, Utc);
    println!("from_naive_utc_and_offset: {}", dt3);
    
    // All produce the same result for UTC
    // from_utc_datetime is the most general (works with any TimeZone)
    
    assert_eq!(dt1, dt2);
    // assert_eq!(dt1, dt3);
}

use chrono::{NaiveDateTime, TimeZone, Utc, DateTime, Duration, FixedOffset};
 
fn main() {
    let naive: NaiveDateTime = "2024-06-15 12:00:00".parse().unwrap();
    let utc_dt: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    // Arithmetic on DateTime<Utc> is straightforward
    let later = utc_dt + Duration::hours(3);
    println!("+3 hours: {}", later);
    
    // With timezone-aware datetime, arithmetic respects timezone semantics
    // For example, +1 day is always +24 hours in UTC
    // In local time with DST, +1 day might cross a DST boundary
    
    let plus_two = FixedOffset::east_opt(2 * 3600).unwrap();
    let local_dt: DateTime<FixedOffset> = plus_two.from_utc_datetime(&naive);
    
    // Arithmetic on FixedOffset datetime
    let later_local = local_dt + Duration::hours(3);
    println!("Local +3 hours: {}", later_local);
    
    // The offset is preserved in arithmetic
    assert_eq!(local_dt.timezone(), later_local.timezone());
}