use tempfile::NamedTempFile;
use std::io::Write;
 
fn basic_usage() -> std::io::Result<()> {
    // Create a named temporary file
    let mut temp_file = NamedTempFile::new()?;
    
    // Write to it
    temp_file.write_all(b"Hello, temp file!")?;
    
    // Get the path
    println!("Temp file: {:?}", temp_file.path());
    
    // File is automatically deleted when temp_file goes out of scope
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn platform_difference() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    // On Unix: the file is unlinked immediately after creation
    // The directory entry is removed, but the file data exists
    // until the file handle is closed
    
    // On Windows: the file is deleted when the handle is closed
    // Windows doesn't support "delete on close" the same way
    
    let path = temp.path().to_path_buf();
    println!("Path: {:?}", path);
    
    // On Unix: path exists in filesystem but is "deleted"
    // On Windows: path exists and is accessible
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
use std::path::Path;
 
#[cfg(unix)]
fn unix_behavior() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"unix temp data")?;
    
    let path = temp.path().to_path_buf();
    
    // On Unix, the file is already unlinked (deleted from directory)
    // But we can still access it through the handle
    println!("Can access through handle: {}", temp.path().exists());
    
    // Other processes cannot open this file by path
    // (unless they already had it open, which isn't possible here)
    
    // The directory entry doesn't exist
    println!("Path exists in dir: {}", Path::new(temp.path()).exists());
    
    // When dropped, the inode and data are freed
    drop(temp);
    
    // Now even the handle is gone
    // The file data is completely removed
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
#[cfg(windows)]
fn windows_behavior() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"windows temp data")?;
    
    let path = temp.path().to_path_buf();
    
    // On Windows, the file still exists in the directory
    // FILE_FLAG_DELETE_ON_CLOSE is set
    println!("Path exists: {}", path.exists());
    
    // Other processes might be able to open it
    // depending on sharing mode
    
    // The file is deleted when all handles are closed
    drop(temp);
    
    // Now the file is deleted
    println!("After drop, path exists: {}", path.exists());
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn persist_file() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"persistent data")?;
    
    // Convert to a regular file - persists after drop
    let persistent_path = temp.into_temp_path();
    
    // The file is no longer temporary
    // It will NOT be deleted when persistent_path is dropped
    
    // Convert to owned path
    let final_path = persistent_path.into_path();
    println!("Persisted at: {:?}", final_path);
    
    // The file now exists permanently
    assert!(final_path.exists());
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
use std::path::PathBuf;
 
fn persist_to_location() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data to keep")?;
    
    // Persist to a specific location
    let dest_path = PathBuf::from("important_data.txt");
    
    // persist() moves the temp file to the destination
    // On both platforms, this creates a permanent file
    let mut persisted_file = temp.persist(&dest_path)?;
    
    println!("Saved to: {:?}", dest_path);
    
    // persisted_file is a regular File, not NamedTempFile
    // It won't be deleted when dropped
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn close_handling() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    // On Windows, deletion happens on close, which can fail
    // Use close() to handle potential errors
    
    // Option 1: Let drop handle it (errors are ignored)
    drop(temp);
    
    // Option 2: Explicitly close with error handling
    let mut temp2 = NamedTempFile::new()?;
    temp2.write_all(b"more data")?;
    
    // close() returns Result and handles cleanup
    temp2.close()?;
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn temp_path_type() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    // into_temp_path() gives you just the path management
    let temp_path = temp.into_temp_path();
    
    // TempPath handles deletion but not the file handle
    // Useful when you're done writing but want to control deletion
    
    println!("Temp path: {:?}", temp_path);
    
    // Can convert to permanent path
    let permanent = temp_path.into_path();
    assert!(permanent.exists());
    
    // Or let it delete
    // drop(temp_path);  // Would delete on both platforms
    
    Ok(())
}

use tempfile::NamedTempFile;
 
fn crash_behavior() {
    // If the program crashes or is killed:
    
    // Unix: File is already unlinked, so:
    // - Directory entry doesn't exist
    // - File data is freed when handle closes
    // - No cleanup needed
    
    // Windows: FILE_FLAG_DELETE_ON_CLOSE is set, so:
    // - OS should delete when handle closes
    // - But if process is killed forcefully, file might remain
    // - Could leave orphaned temp files
    
    // Always prefer NamedTempFile over manual temp file creation
    // because it handles these edge cases better
}

use tempfile::NamedTempFile;
use std::path::Path;
 
fn in_specific_directory() -> std::io::Result<()> {
    // Create temp file in a specific directory
    let temp_dir = Path::new("/tmp/myapp");
    std::fs::create_dir_all(temp_dir)?;
    
    let temp = NamedTempFile::new_in(temp_dir)?;
    
    // On Unix: file is unlinked from /tmp/myapp
    // On Windows: file is in /tmp/myapp until closed
    
    println!("Created in: {:?}", temp.path());
    
    Ok(())
}
 
fn using_temp_dir() -> std::io::Result<()> {
    // Or use a TempDir
    use tempfile::TempDir;
    
    let dir = TempDir::new()?;
    let temp = NamedTempFile::new_in(dir.path())?;
    
    // Both dir and temp are cleaned up automatically
    // Order matters: temp should drop before dir
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
#[cfg(unix)]
fn unix_permissions() -> std::io::Result<()> {
    use std::os::unix::fs::PermissionsExt;
    
    let mut temp = NamedTempFile::new()?;
    
    // Set permissions on the temp file
    let mut perms = temp.as_file().metadata()?.permissions();
    perms.set_mode(0o600);  // Owner read/write only
    temp.as_file().set_permissions(perms)?;
    
    // On Unix, immediate unlinking prevents race conditions
    // where another process could open the file
    
    temp.write_all(b"secret data")?;
    
    Ok(())
}
 
#[cfg(windows)]
fn windows_permissions() -> std::io::Result<()> {
    // Windows handles security differently
    // NamedTempFile uses appropriate sharing modes
    
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"secret data")?;
    
    // On Windows, the file might be visible in the directory
    // until closed, but access is controlled by sharing mode
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn keep_file() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    // keep() prevents deletion and returns the path
    // Works on both platforms
    let (file, path) = temp.keep()?;
    
    // file is a regular File handle
    // path is the PathBuf where the file is stored
    // Neither will cause deletion when dropped
    
    println!("File kept at: {:?}", path);
    assert!(path.exists());
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
use std::path::PathBuf;
 
fn compare_drop_behavior() {
    // Scenario: temp file created, program crashes
    
    // Unix timeline:
    // 1. NamedTempFile::new() creates file
    // 2. Immediately unlinks (removes directory entry)
    // 3. File exists only as inode with open handle
    // 4. On crash: kernel closes handle, frees inode
    // Result: No orphaned file
    
    // Windows timeline:
    // 1. NamedTempFile::new() creates file with DELETE_ON_CLOSE
    // 2. File exists in directory
    // 3. On crash: OS may or may not clean up
    // Result: Possible orphaned file
    
    // Best practice: Use close() for important cleanup
}
 
fn proper_cleanup() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"important temp data")?;
    
    // Do work with the temp file
    process_temp_file(&temp)?;
    
    // Explicitly close with error handling
    temp.close()?;
    
    Ok(())
}
 
fn process_temp_file(_temp: &NamedTempFile) -> std::io::Result<()> {
    // Process the temp file
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn platform_specific_handling() -> std::io::Result<()> {
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    #[cfg(unix)]
    {
        // On Unix, file is already unlinked
        // Safe from race conditions
        // Other processes can't open by path
        
        println!("Unix: file is unlinked, safe from races");
    }
    
    #[cfg(windows)]
    {
        // On Windows, file exists until closed
        // Might be visible to other processes
        // Use appropriate sharing mode
        
        println!("Windows: file visible until closed");
    }
    
    // Cross-platform: persist if needed
    let path = temp.path().to_path_buf();
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_temp_file_cleanup() -> std::io::Result<()> {
        let path;
        {
            let mut temp = NamedTempFile::new()?;
            temp.write_all(b"test data")?;
            path = temp.path().to_path_buf();
            
            // File exists while temp is in scope
            #[cfg(windows)]
            assert!(path.exists());
            
            #[cfg(unix)]
            {
                // On Unix, the directory entry is gone
                // but we can still use the handle
            }
        }
        
        // After drop, file should be gone
        // On both platforms
        assert!(!path.exists());
        
        Ok(())
    }
}

use tempfile::{NamedTempFile, TempDir};
use std::io::Write;
 
fn tempdir_vs_tempfile() -> std::io::Result<()> {
    // NamedTempFile: single file
    let mut temp_file = NamedTempFile::new()?;
    temp_file.write_all(b"data")?;
    
    // TempDir: directory for multiple files
    let temp_dir = TempDir::new()?;
    
    // Create files inside
    let file1 = std::fs::File::create(temp_dir.path().join("file1.txt"))?;
    let file2 = std::fs::File::create(temp_dir.path().join("file2.txt"))?;
    
    // TempDir cleanup:
    // Unix: Removes directory contents, then directory
    // Windows: Removes directory and all contents
    
    // Both clean up recursively
    drop(temp_dir);
    
    Ok(())
}

use tempfile::NamedTempFile;
use std::io::Write;
 
fn robust_temp_file() -> std::io::Result<()> {
    // Pattern 1: Let RAII handle it
    {
        let mut temp = NamedTempFile::new()?;
        temp.write_all(b"data")?;
        process(&temp)?;
        // Auto-cleanup on scope exit
    }
    
    // Pattern 2: Keep on success, delete on failure
    let mut temp = NamedTempFile::new()?;
    temp.write_all(b"data")?;
    
    match process(&temp) {
        Ok(_) => {
            // Success - persist the file
            let path = temp.into_path();
            println!("Persisted at: {:?}", path);
        }
        Err(e) => {
            // Failure - let temp drop and delete
            return Err(e);
        }
    }
    
    Ok(())
}
 
fn process(_temp: &NamedTempFile) -> std::io::Result<()> {
    Ok(())
}