use chrono::{NaiveDateTime, DateTime, Utc, TimeZone, NaiveDate, NaiveTime};
 
fn type_comparison() {
    // NaiveDateTime - no timezone, just a date and time
    let naive = NaiveDate::from_ymd_opt(2024, 3, 15).unwrap()
        .and_hms_opt(14, 30, 0).unwrap();
    
    println!("NaiveDateTime: {}", naive); // 2024-03-15 14:30:00
    
    // DateTime<Utc> - has timezone context
    let utc: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    
    println!("DateTime<Utc>: {}", utc); // 2024-03-15 14:30:00 UTC
    
    // The naive datetime is interpreted as if it were already UTC
    // This is correct ONLY if the original timestamp was recorded in UTC
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone, NaiveDate};
 
fn assumption_problem() {
    // User records "2024-03-15 14:30:00" in their local timezone (EST = UTC-5)
    let local_time = NaiveDate::from_ymd_opt(2024, 3, 15).unwrap()
        .and_hms_opt(14, 30, 0).unwrap();
    
    // WRONG: Treating local time as UTC
    let wrong_utc: DateTime<Utc> = Utc.from_utc_datetime(&local_time);
    println!("Wrong UTC: {}", wrong_utc); // 2024-03-15 14:30:00 UTC
    
    // CORRECT: Convert with proper timezone
    let eastern = chrono_tz::US::Eastern;
    let correct_utc: DateTime<Utc> = eastern
        .from_local_datetime(&local_time)
        .single()
        .unwrap()
        .with_timezone(&Utc);
    
    println!("Correct UTC: {}", correct_utc); // 2024-03-15 19:30:00 UTC
    
    // 5 hour difference! The wrong conversion is off by 5 hours
}

use chrono::{NaiveDateTime, NaiveDate, TimeZone};
use chrono_tz::US::Eastern;
 
fn dst_spring_forward() {
    // March 10, 2024: DST begins at 2:00 AM in US Eastern
    // Clocks spring forward from 1:59:59 AM to 3:00:00 AM
    
    // 2:30 AM does not exist on this day!
    let nonexistent = NaiveDate::from_ymd_opt(2024, 3, 10).unwrap()
        .and_hms_opt(2, 30, 0).unwrap();
    
    // What happens when we try to convert?
    let result = Eastern.from_local_datetime(&nonexistent);
    
    match result {
        chrono::LocalResult::None => {
            println!("This time doesn't exist! (DST spring forward)");
        }
        chrono::LocalResult::Single(dt) => {
            println!("Unique time: {}", dt);
        }
        chrono::LocalResult::Ambiguous(_, _) => {
            println!("Ambiguous time!");
        }
    }
    
    // If you blindly convert to UTC:
    let naive_utc = Utc.from_utc_datetime(&nonexistent);
    println!("Naive UTC conversion: {}", naive_utc);
    // This creates a UTC timestamp for a time that never existed locally!
}
 
fn dst_fall_back() {
    // November 3, 2024: DST ends at 2:00 AM in US Eastern
    // Clocks fall back from 1:59:59 AM to 1:00:00 AM
    
    // 1:30 AM exists TWICE on this day!
    let ambiguous = NaiveDate::from_ymd_opt(2024, 11, 3).unwrap()
        .and_hms_opt(1, 30, 0).unwrap();
    
    let result = Eastern.from_local_datetime(&ambiguous);
    
    match result {
        chrono::LocalResult::Ambiguous(earliest, latest) => {
            println!("Ambiguous time!");
            println!("  Earliest (EDT): {}", earliest);
            println!("  Latest (EST): {}", latest);
            
            // One hour difference!
            let diff = latest - earliest;
            println!("  Difference: {}", diff);
        }
        _ => unreachable!(),
    }
    
    // Naive conversion picks one arbitrarily - which one?
    let naive_utc = Utc.from_utc_datetime(&ambiguous);
    println!("Naive conversion: {}", naive_utc);
    // Did the user mean the first or second occurrence?
}

use chrono::{NaiveDateTime, TimeZone, LocalResult};
use chrono_tz::Tz;
 
fn handle_local_result(dt: NaiveDateTime, tz: Tz) {
    match tz.from_local_datetime(&dt) {
        LocalResult::None => {
            // Time doesn't exist (spring forward gap)
            // Options:
            // 1. Reject the input
            // 2. Adjust forward to next valid time
            // 3. Adjust backward to previous valid time
            
            let next_valid = dt + chrono::Duration::hours(1);
            println!("Time {} doesn't exist in {}", dt, tz);
            println!("Next valid time might be: {}", next_valid);
        }
        LocalResult::Single(datetime) => {
            // Normal case: unique interpretation
            println!("Unique UTC time: {}", datetime.with_timezone(&Utc));
        }
        LocalResult::Ambiguous(earliest, latest) => {
            // Time exists twice (fall back)
            // Need additional context to choose
            println!("Ambiguous time:");
            println!("  Earlier: {} (DST)", earliest);
            println!("  Later: {} (standard)", latest);
            
            // Default strategies:
            // 1. Always choose earliest
            // 2. Always choose latest
            // 3. Ask user for clarification
            // 4. Store both possibilities
        }
    }
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone, NaiveDate};
 
fn offset_errors() {
    // Example: Server in US Pacific (UTC-8/-7) receives naive datetime
    // from user in US Eastern (UTC-5/-4)
    
    let user_time = NaiveDate::from_ymd_opt(2024, 6, 15).unwrap()
        .and_hms_opt(14, 0, 0).unwrap();
    
    // WRONG: Server treats it as Pacific time
    let pacific = chrono_tz::US::Pacific;
    let wrong: DateTime<Utc> = pacific
        .from_local_datetime(&user_time)
        .single()
        .unwrap()
        .with_timezone(&Utc);
    println!("If Pacific: {}", wrong); // 2024-06-15 21:00:00 UTC
    
    // CORRECT: User meant Eastern time
    let eastern = chrono_tz::US::Eastern;
    let correct: DateTime<Utc> = eastern
        .from_local_datetime(&user_time)
        .single()
        .unwrap()
        .with_timezone(&Utc);
    println!("If Eastern: {}", correct); // 2024-06-15 18:00:00 UTC
    
    // 3 hour difference due to wrong timezone assumption!
    // The event appears 3 hours earlier/later than intended
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone};
 
// Scenario: Database stores naive datetimes without timezone info
struct Event {
    id: u64,
    name: String,
    // Stored as "2024-03-15 14:30:00" without timezone
    event_time: NaiveDateTime,
}
 
fn database_risks() {
    // What timezone was this recorded in?
    let event = Event {
        id: 1,
        name: "Meeting".to_string(),
        event_time: NaiveDateTime::parse_from_str("2024-03-15 14:30:00", "%Y-%m-%d %H:%M:%S").unwrap(),
    };
    
    // Risk 1: Assuming UTC when it was local
    let assumed_utc: DateTime<Utc> = Utc.from_utc_datetime(&event.event_time);
    
    // Risk 2: Different developers assume different timezones
    // Developer A (NYC) assumes Eastern
    // Developer B (London) assumes UTC
    // Developer C (Tokyo) assumes JST
    
    // Risk 3: Server timezone changes
    // If server moves from one timezone to another, all historical
    // naive datetimes are now interpreted differently
    
    // Risk 4: Application timezone setting changes
    // If config is changed, all existing records shift
}
 
// Better approach: Store timezone explicitly
struct SafeEvent {
    id: u64,
    name: String,
    event_time_utc: DateTime<Utc>,  // Always UTC
    // Or store original timezone:
    // event_time: NaiveDateTime,
    // timezone: String,
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone, NaiveDate};
use serde::{Deserialize, Serialize};
 
#[derive(Deserialize)]
struct CreateEventRequest {
    name: String,
    // Client sends "2024-03-15T14:30:00" without timezone
    event_time: NaiveDateTime,
}
 
fn api_input_risks() {
    // Client in different timezone than server
    let request = CreateEventRequest {
        name: "Important Meeting".to_string(),
        event_time: NaiveDate::from_ymd_opt(2024, 3, 15).unwrap()
            .and_hms_opt(14, 30, 0).unwrap(),
    };
    
    // WRONG: Server assumes its own timezone
    let server_tz = chrono_tz::US::Pacific;
    let server_assumed: DateTime<Utc> = server_tz
        .from_local_datetime(&request.event_time)
        .single()
        .unwrap()
        .with_timezone(&Utc);
    
    // Client meant their local time, not server's timezone!
    // If client is in Tokyo (UTC+9) and server is in LA (UTC-7):
    // 16 hour difference!
    
    // BETTER: Require timezone from client
    #[derive(Deserialize)]
    struct SafeCreateEventRequest {
        name: String,
        event_time: DateTime<Utc>,  // Client must send UTC
        // Or:
        // event_time: NaiveDateTime,
        // timezone: String,
    }
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone};
use chrono_tz::US::Eastern;
 
fn conversion_methods() {
    let naive = NaiveDateTime::parse_from_str("2024-03-15 14:30:00", "%Y-%m-%d %H:%M:%S").unwrap();
    
    // from_utc_datetime: Treats naive as UTC, then displays in timezone
    // "The datetime is in UTC, show me what it looks like in Eastern"
    let from_utc: DateTime<Utc> = Utc.from_utc_datetime(&naive);
    let in_eastern = from_utc.with_timezone(&Eastern);
    println!("from_utc result: {}", in_eastern);
    // 2024-03-15 14:30:00 UTC = 2024-03-15 10:30:00 EDT
    
    // from_local_datetime: Treats naive as local time, converts to UTC
    // "The datetime is in Eastern, convert to UTC"
    let from_local: DateTime<Utc> = Eastern
        .from_local_datetime(&naive)
        .single()
        .unwrap()
        .with_timezone(&Utc);
    println!("from_local result: {}", from_local);
    // 2024-03-15 14:30:00 EST = 2024-03-15 19:30:00 UTC
    
    // 9 hour difference between the two interpretations!
}

use chrono::{NaiveDateTime, DateTime, Utc, TimeZone, LocalResult};
use chrono_tz::Tz;
 
// Pattern 1: Store UTC, convert for display
fn store_as_utc() {
    // Always convert to UTC before storage
    let user_time = NaiveDateTime::parse_from_str("2024-03-15 14:30:00", "%Y-%m-%d %H:%M:%S").unwrap();
    let user_tz: Tz = "America/New_York".parse().unwrap();
    
    let utc_time: DateTime<Utc> = user_tz
        .from_local_datetime(&user_time)
        .single()
        .expect("Invalid or ambiguous time")
        .with_timezone(&Utc);
    
    // Store utc_time in database
    // When displaying, convert back to user's timezone
    let display_time = utc_time.with_timezone(&user_tz);
}
 
// Pattern 2: Store with explicit timezone
struct TimestampWithTimezone {
    naive: NaiveDateTime,
    tz: String,
}
 
fn store_with_timezone() {
    let event = TimestampWithTimezone {
        naive: NaiveDateTime::parse_from_str("2024-03-15 14:30:00", "%Y-%m-%d %H:%M:%S").unwrap(),
        tz: "America/New_York".to_string(),
    };
    
    // Convert to UTC when needed
    let tz: Tz = event.tz.parse().unwrap();
    let utc: DateTime<Utc> = tz
        .from_local_datetime(&event.naive)
        .single()
        .expect("Invalid time")
        .with_timezone(&Utc);
}
 
// Pattern 3: Require timezone in API
use serde::{Deserialize, Serialize};
 
#[derive(Deserialize)]
struct EventWithTimezone {
    event_time: NaiveDateTime,
    timezone: String,
}
 
fn api_with_timezone(event: EventWithTimezone) -> Result<DateTime<Utc>, String> {
    let tz: Tz = event.timezone.parse()
        .map_err(|e| format!("Invalid timezone: {}", e))?;
    
    match tz.from_local_datetime(&event.event_time) {
        LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
        LocalResult::None => Err("Time doesn't exist (DST gap)".to_string()),
        LocalResult::Ambiguous(_, _) => Err("Ambiguous time (DST overlap)".to_string()),
    }
}

use chrono::{NaiveDateTime, TimeZone, LocalResult};
use chrono_tz::US::Eastern;
 
fn handle_ambiguous() {
    // 1:30 AM on November 3, 2024 exists twice
    let ambiguous = NaiveDateTime::parse_from_str("2024-11-03 01:30:00", "%Y-%m-%d %H:%M:%S").unwrap();
    
    match Eastern.from_local_datetime(&ambiguous) {
        LocalResult::Ambiguous(earliest, latest) => {
            println!("This time is ambiguous:");
            println!("  First occurrence: {} (EDT, UTC-4)", earliest);
            println!("  Second occurrence: {} (EST, UTC-5)", latest);
            
            // Strategy 1: Choose earliest (before fall back)
            let chosen_earliest = earliest;
            
            // Strategy 2: Choose latest (after fall back)
            let chosen_latest = latest;
            
            // Strategy 3: Use additional context
            // For example, if event is "after midnight party ends",
            // likely the later occurrence
            // If event is "bar closing time", likely the earlier
            
            // Strategy 4: Reject and ask for clarification
            panic!("Please specify: before or after DST change?");
        }
        _ => unreachable!(),
    }
}
 
// Helper function with disambiguation strategy
enum Disambiguation {
    Earliest,
    Latest,
    Reject,
}
 
fn convert_with_disambiguation(
    dt: NaiveDateTime,
    tz: chrono_tz::Tz,
    strategy: Disambiguation,
) -> Result<DateTime<Utc>, String> {
    match tz.from_local_datetime(&dt) {
        LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
        LocalResult::None => Err("Time doesn't exist due to DST".to_string()),
        LocalResult::Ambiguous(earliest, latest) => match strategy {
            Disambiguation::Earliest => Ok(earliest.with_timezone(&Utc)),
            Disambiguation::Latest => Ok(latest.with_timezone(&Utc)),
            Disambiguation::Reject => Err("Ambiguous time due to DST".to_string()),
        },
    }
}

use chrono::{NaiveDateTime, TimeZone, LocalResult, Duration};
use chrono_tz::US::Eastern;
 
fn handle_nonexistent() {
    // 2:30 AM on March 10, 2024 doesn't exist (spring forward)
    let nonexistent = NaiveDateTime::parse_from_str("2024-03-10 02:30:00", "%Y-%m-%d %H:%M:%S").unwrap();
    
    match Eastern.from_local_datetime(&nonexistent) {
        LocalResult::None => {
            println!("This time doesn't exist: {}", nonexistent);
            println!("Clocks jumped from 1:59:59 AM to 3:00:00 AM");
            
            // Strategy 1: Reject
            // Return error to user
            
            // Strategy 2: Adjust forward
            let forward = nonexistent + Duration::hours(1);
            let adjusted_forward = Eastern
                .from_local_datetime(&forward)
                .single()
                .unwrap();
            println!("Adjusted forward: {}", adjusted_forward);
            
            // Strategy 3: Adjust backward
            let backward = nonexistent - Duration::hours(1);
            let adjusted_backward = Eastern
                .from_local_datetime(&backward)
                .single()
                .unwrap();
            println!("Adjusted backward: {}", adjusted_backward);
            
            // Strategy 4: Use next valid time (in this case, 3:00 AM)
            // This is what many systems do automatically
        }
        _ => unreachable!(),
    }
}
 
// Helper with adjustment strategy
enum NonexistentStrategy {
    Reject,
    Forward,
    Backward,
    NextValid,
}
 
fn convert_with_adjustment(
    dt: NaiveDateTime,
    tz: chrono_tz::Tz,
    strategy: NonexistentStrategy,
) -> Result<DateTime<Utc>, String> {
    match tz.from_local_datetime(&dt) {
        LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
        LocalResult::Ambiguous(_, _) => Err("Ambiguous time".to_string()),
        LocalResult::None => match strategy {
            NonexistentStrategy::Reject => Err("Time doesn't exist due to DST".to_string()),
            NonexistentStrategy::Forward => {
                let adjusted = dt + Duration::hours(1);
                convert_with_adjustment(adjusted, tz, NonexistentStrategy::Reject)
            }
            NonexistentStrategy::Backward => {
                let adjusted = dt - Duration::hours(1);
                convert_with_adjustment(adjusted, tz, NonexistentStrategy::Reject)
            }
            NonexistentStrategy::NextValid => {
                // Find next valid time (implementation depends on tz)
                let adjusted = dt + Duration::hours(1);
                convert_with_adjustment(adjusted, tz, NonexistentStrategy::Reject)
            }
        },
    }
}