use tempfile::tempdir;
use std::fs::File;
use std::io::Write;
 
fn basic_tempdir() -> std::io::Result<()> {
    // Creates a directory in the system's default temp location
    // Unix: /tmp
    // Windows: %TEMP% (usually in AppData\Local\Temp)
    let dir = tempdir()?;
    
    println!("Created at: {:?}", dir.path());
    // Path will be something like: /tmp/.tmpABCDE123
    
    // Create files inside the temp directory
    let file_path = dir.path().join("my_file.txt");
    let mut file = File::create(&file_path)?;
    file.write_all(b"Hello, temp!")?;
    
    // When `dir` goes out of scope, the directory and contents are deleted
    Ok(())
}

use tempfile::tempdir_in;
use std::path::Path;
 
fn basic_tempdir_in() -> std::io::Result<()> {
    // Creates a temp directory in the specified parent directory
    let custom_parent = Path::new("/var/myapp/tmp");
    let dir = tempdir_in(custom_parent)?;
    
    println!("Created at: {:?}", dir.path());
    // Path will be: /var/myapp/tmp/.tmpABCDE123
    
    // The parent directory must exist, or this will fail
    Ok(())
}
 
fn tempdir_in_current_dir() -> std::io::Result<()> {
    // Use current directory as parent
    let dir = tempdir_in(".")?;
    
    println!("Created at: {:?}", dir.path());
    // Path will be like: ./.tmpABCDE123
    
    Ok(())
}

use std::path::Path;
use tempfile::{TempDir, tempdir, tempdir_in};
 
// tempdir signature:
// pub fn tempdir() -> io::Result<TempDir>
// 
// Creates in system default temp directory
// Uses std::env::temp_dir() internally
 
// tempdir_in signature:
// pub fn tempdir_in<P: AsRef<Path>>(dir: P) -> io::Result<TempDir>
//
// Creates in specified parent directory
// Parent must exist and be writable
 
fn signature_comparison() -> std::io::Result<()> {
    // tempdir: no arguments, uses system default
    let default_temp = tempdir()?;
    
    // tempdir_in: requires parent path argument
    let custom_temp = tempdir_in("/custom/path")?;
    
    // Both return TempDir, which auto-deletes on drop
    
    Ok(())
}

use std::env;
 
fn system_temp_location() {
    // tempdir uses this internally:
    let default_temp = env::temp_dir();
    println!("System temp dir: {:?}", default_temp);
    
    // Unix: typically /tmp
    // Windows: typically %TEMP% (e.g., C:\Users\xxx\AppData\Local\Temp)
    // macOS: typically /var/folders/... (from TMPDIR)
    
    // The location is determined by:
    // Unix: TMPDIR environment variable, or /tmp
    // Windows: TEMP, TMP, or USERPROFILE environment variables
    
    // tempdir creates directories here
    // tempdir_in lets you override this
}

use tempfile::tempdir_in;
use std::path::Path;
 
fn use_cases() -> std::io::Result<()> {
    // 1. Need files on a specific filesystem
    let fast_storage = tempdir_in("/mnt/ssd/tmp")?;
    // When you have a fast SSD mounted separately
    
    // 2. Security requirements
    let secure_location = tempdir_in("/secure/app-tmp")?;
    // When temp files must be in an encrypted location
    
    // 3. Disk space concerns
    let large_storage = tempdir_in("/mnt/large-volume/tmp")?;
    // When /tmp might not have enough space
    
    // 4. Containerized applications
    let container_tmp = tempdir_in("/app/tmp")?;
    // When /tmp isn't the right location in a container
    
    // 5. Testing isolation
    let test_tmp = tempdir_in("./test-tmp")?;
    // When tests need isolated temp directories
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
use std::path::Path;
 
fn error_handling() {
    // tempdir errors are usually permission-related on system temp
    match tempdir() {
        Ok(dir) => println!("Created: {:?}", dir.path()),
        Err(e) => eprintln!("Failed to create temp dir: {}", e),
    }
    
    // tempdir_in can fail for more reasons:
    // 1. Parent directory doesn't exist
    // 2. Parent directory not writable
    // 3. Permission denied
    // 4. Path is not a directory
    
    match tempdir_in("/nonexistent/path") {
        Ok(dir) => println!("Created: {:?}", dir.path()),
        Err(e) => {
            // Error: parent directory doesn't exist
            eprintln!("Failed: {}", e);
        }
    }
    
    // tempdir_in requires the parent to exist
    // Unlike tempdir which uses a known-good system location
}

use tempfile::tempdir_in;
use std::fs;
use std::os::unix::fs::PermissionsExt;
 
fn security_considerations() -> std::io::Result<()> {
    // Default tempdir uses system temp, which typically has:
    // - Restricted permissions (sticky bit on Unix)
    // - System-managed cleanup
    // - Expected security posture
    
    // tempdir_in requires you to consider:
    
    // 1. Parent directory permissions
    let custom_parent = Path::new("/var/myapp");
    // Ensure parent exists and has proper permissions
    fs::create_dir_all(custom_parent)?;
    fs::set_permissions(custom_parent, fs::Permissions::from_mode(0o700))?;
    
    let tmp = tempdir_in(custom_parent)?;
    
    // 2. The temp directory itself has restricted permissions
    // tempfile creates with 0o700 on Unix by default
    
    // 3. Consider who else can access the parent directory
    // In /tmp, other users can't access your temp dir (usually)
    // In custom locations, verify the security model
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in, TempDir};
 
fn cleanup_behavior() -> std::io::Result<()> {
    // Both tempdir and tempdir_in return TempDir
    // TempDir implements Drop to delete the directory
    
    let dir1 = tempdir()?;
    let dir2 = tempdir_in(".")?;
    
    // Both:
    // - Delete directory contents
    // - Delete the directory itself
    // - Ignore errors during cleanup (best effort)
    // - Support cleanup on panic
    
    // Explicit cleanup:
    dir1.close()?;  // Cleanup and return any error
    dir2.close()?;  // Same for tempdir_in
    
    // Or let Drop handle it (ignores errors)
    Ok(())
}
 
fn cleanup_on_panic() {
    let result = std::panic::catch_unwind(|| {
        let _dir = tempdir().expect("failed to create temp");
        // Even if panic occurs, _dir is dropped
        // and the temp directory is cleaned up
        panic!("oops");
    });
    
    assert!(result.is_err());
    // Temp directory was still cleaned up
}

use tempfile::{tempdir, tempdir_in};
 
fn cleanup_guarantees() -> std::io::Result<()> {
    // Both provide the same cleanup guarantees
    
    let dir = tempdir()?;
    let dir2 = tempdir_in(".")?;
    
    // Cleanup happens on Drop
    // Best effort - errors are ignored in Drop
    
    // To catch cleanup errors, use close():
    dir.close()?;  // Returns Err if cleanup fails
    dir2.close()?;
    
    // Edge cases:
    // 1. Files still open in temp dir:
    //    - Unix: Directory deleted, file descriptors still valid
    //    - Windows: May fail if files are open
    
    // 2. Nested temp directories:
    //    - Inner cleaned first (Drop order)
    //    - Works correctly with both tempdir and tempdir_in
    
    // 3. Persistence after close:
    //    - close() consumes TempDir
    //    - Cannot access path after close
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
use std::path::Path;
 
fn performance() -> std::io::Result<()> {
    // Performance differences depend on:
    
    // 1. Filesystem speed
    // - System /tmp might be tmpfs (in-memory, fast)
    // - Custom location might be on slower disk
    // - Or vice versa (SSD vs HDD)
    
    // 2. Directory creation
    // Both use the same mechanism:
    // - Create random directory name
    // - Retry on collision
    // - Both are O(1) for directory creation
    
    // 3. File operations inside temp dir
    // - Depends on underlying filesystem
    // - tmpfs: very fast, but limited RAM
    // - Regular disk: slower, more space
    
    // Benchmarks:
    let start = std::time::Instant::now();
    for _ in 0..1000 {
        let _dir = tempdir()?;
    }
    println!("tempdir: {:?}", start.elapsed());
    
    let start = std::time::Instant::now();
    for _ in 0..1000 {
        let _dir = tempdir_in("/tmp")?;
    }
    println!("tempdir_in: {:?}", start.elapsed());
    // Should be similar when pointing to same location
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
use std::env;
 
fn containerized() -> std::io::Result<()> {
    // In containers, /tmp might have issues:
    // - Limited size (tmpfs)
    // - Not shared across containers
    // - Cleared on container restart
    
    // Check if running in container:
    let in_container = Path::new("/.dockerenv").exists();
    
    let tmp_dir = if in_container {
        // Might want to use a volume mount
        tempdir_in("/app-tmp")?
    } else {
        tempdir()?
    };
    
    // Or use environment variable for flexibility:
    let custom_tmp = env::var("APP_TMP_DIR")
        .map(|p| tempdir_in(&p))
        .unwrap_or_else(|_| tempdir())?;
    
    // This allows configuration without code changes
    Ok(())
}

use tempfile::{tempdir, tempdir_in, TempDir, Builder};
 
fn alternative_apis() -> std::io::Result<()> {
    // tempdir() is shorthand for:
    let dir1: TempDir = Builder::new().tempdir()?;
    
    // tempdir_in(path) is shorthand for:
    let dir2: TempDir = Builder::new().tempdir_in("/tmp")?;
    
    // Builder provides more control:
    let dir3: TempDir = Builder::new()
        .prefix("myapp_")      // Custom prefix
        .suffix("_tmp")         // Custom suffix
        .tempdir()?;            // In default location
    
    let dir4: TempDir = Builder::new()
        .prefix("myapp_")
        .tempdir_in("/custom")?;  // In custom location
    
    // The Builder pattern works with both locations
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
 
fn cross_platform() -> std::io::Result<()> {
    // Both functions work on all platforms
    
    // Unix:
    // - Default temp: /tmp (or TMPDIR)
    // - Permissions: 0o700
    // - Uses mkdtemp equivalent
    
    // Windows:
    // - Default temp: %TEMP% (e.g., C:\Users\xxx\AppData\Local\Temp)
    // - ACLs inherited from parent
    // - Uses GetTempFileName equivalent
    
    // macOS:
    // - Default temp: $TMPDIR (usually /var/folders/...)
    // - Same Unix semantics
    
    // tempdir_in works identically on all platforms:
    let custom_unix = tempdir_in("/var/tmp")?;
    let custom_windows = tempdir_in("C:\\Temp")?;  // Windows-specific path
    
    // Use platform-appropriate paths
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
use std::path::PathBuf;
use std::env;
 
fn recommendations() -> std::io::Result<()> {
    // Use tempdir when:
    // - Default location is sufficient
    // - No special requirements
    // - Simple use case
    let _simple = tempdir()?;
    
    // Use tempdir_in when:
    
    // 1. Need more disk space than /tmp provides
    let _large_tmp = tempdir_in("/mnt/data/tmp")?;
    
    // 2. Security requirements (encrypted volume)
    let _secure_tmp = tempdir_in("/encrypted/tmp")?;
    
    // 3. Containerized with specific volume mounts
    let _container_tmp = tempdir_in("/app-tmp")?;
    
    // 4. Testing isolation
    let _test_tmp = tempdir_in("./test-tmp")?;
    
    // 5. Configuration-driven location
    let tmp_path = env::var("MYAPP_TMP_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|_| env::temp_dir());
    let _configured_tmp = tempdir_in(&tmp_path)?;
    
    // Pattern: Configuration with fallback
    let custom_tmp = env::var("CUSTOM_TMP_DIR")
        .map(|p| tempdir_in(&p))
        .transpose()?  // Handle errors from tempdir_in
        .unwrap_or_else(|| tempdir().unwrap());
    
    Ok(())
}

use tempfile::{tempdir, tempdir_in};
 
// tempdir: default is sufficient
fn general_use() -> std::io::Result<()> {
    let _tmp = tempdir()?;
    Ok(())
}
 
// tempdir_in: special requirements
fn specific_location() -> std::io::Result<()> {
    // Encryption required
    let _tmp = tempdir_in("/encrypted/tmp")?;
    
    // More space needed
    let _tmp = tempdir_in("/mnt/large-volume/tmp")?;
    
    // Container volume
    let _tmp = tempdir_in("/app/tmp")?;
    
    Ok(())
}