# Python script to demonstrate proactive file checks
import os

def safely_process_file(filepath):
    """
    Validates file existence and write permissions before attempting to write.
    Args:
        filepath (str): The path to the file.
    """
    print(f"\nAttempting to process: {filepath}")

    # 1. Check for directory existence and create if necessary
    directory = os.path.dirname(filepath)
    if directory and not os.path.exists(directory):
        try:
            os.makedirs(directory) # Create all necessary parent directories
            print(f"Directory '{directory}' created.")
        except OSError as e:
            print(f"Error creating directory '{directory}': {e}")
            return
    
    # 2. Check if the file already exists
    if os.path.exists(filepath):
        print(f"File '{filepath}' already exists. Validating permissions.")
        
        # 3. Check read/write permissions for existing files
        # os.R_OK for read, os.W_OK for write, os.X_OK for execute
        if not os.access(filepath, os.W_OK):
            print(f"PermissionError: No write access to '{filepath}'. Operation aborted.")
            return
        print(f"Write permission granted for existing file '{filepath}'.")

    else:
        print(f"File '{filepath}' does not exist. Attempting to create and write.")
        # For new files, the ability to write is implied if the directory is writable
        # However, a PermissionError might still occur during open() if directory is not writable
        if directory and not os.access(directory, os.W_OK):
             print(f"PermissionError: No write access to directory '{directory}'. Operation aborted.")
             return
        print(f"Directory '{directory}' is writable.")

    # Proceed with file operation if all checks pass
    try:
        with open(filepath, 'w') as f:
            f.write("This is a test line.\n")
            f.write("Another line for the file.\n")
        print(f"Successfully wrote to '{filepath}'.")
    except IOError as e:
        print(f"IOError during file write: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

# --- Test Cases ---
# Test 1: Valid path, new file
safely_process_file("data/output.txt")

# Test 2: Valid path, existing file (overwrite)
safely_process_file("data/output.txt")

# Test 3: Path with non-existent directories (should create them)
safely_process_file("logs/sub/application.log")

# Test 4: Simulate a permission denied scenario (manual test required by changing permissions)
# For example, create a file/directory and set permissions to read-only for others:
# touch no_write.txt && chmod 444 no_write.txt
# safely_process_file("no_write.txt")

# Test 5: Try to write to a protected system directory (will likely fail with PermissionError)
# safely_process_file("/root/protected.txt") # This will likely raise PermissionError on Linux

# Python script to demonstrate robust file handling with context managers and exceptions
import os

def process_data_file(filepath):
    """
    Processes a data file, ensuring safe opening, reading, and closing.
    Handles common file-related exceptions gracefully.
    Args:
        filepath (str): The path to the data file.
    """
    print(f"\nAttempting to process data from: {filepath}")
    data = []
    try:
        # Use 'with' statement for automatic resource management
        # Explicitly define encoding to prevent UnicodeDecodeError
        with open(filepath, 'r', encoding='utf-8') as f:
            print(f"Successfully opened '{filepath}'. Reading content...")
            for line_num, line in enumerate(f, 1):
                # Simulate a processing error on a specific line for demonstration
                if "error" in line.lower() and line_num == 3:
                    raise ValueError(f"Simulated processing error on line {line_num}: '{line.strip()}'")
                data.append(line.strip())
        print(f"Successfully read all data from '{filepath}'.")
        return data

    except FileNotFoundError:
        print(f"Error: The file '{filepath}' was not found. Please verify the path.")
    except PermissionError:
        print(f"Error: Insufficient permissions to access '{filepath}'. Check file/directory permissions.")
    except IsADirectoryError:
        print(f"Error: Expected a file, but '{filepath}' is a directory. Please provide a file path.")
    except UnicodeDecodeError as e:
        print(f"Error: Could not decode '{filepath}' with 'utf-8' encoding. Consider specifying a different encoding. Details: {e}")
    except ValueError as e:
        print(f"Processing Error in '{filepath}': {e}")
    except IOError as e:
        # Catch broader I/O errors not covered by more specific ones
        print(f"General I/O Error with '{filepath}': {e}")
    except Exception as e:
        # Catch any other unexpected errors
        print(f"An unexpected error occurred while processing '{filepath}': {e}")
    finally:
        # This block always executes, useful for cleanup if not using 'with'
        # but with 'with', file closure is guaranteed, so often not strictly needed for file handles
        print(f"Finished attempt to process '{filepath}'.")
    return None


def write_processed_data(filepath, data_to_write):
    """
    Writes processed data to a new file, ensuring safe writing and closing.
    Args:
        filepath (str): The path to the output file.
        data_to_write (list): List of strings to write.
    """
    print(f"\nAttempting to write data to: {filepath}")
    try:
        # Ensure the directory exists before writing
        os.makedirs(os.path.dirname(filepath), exist_ok=True)
        with open(filepath, 'w', encoding='utf-8') as f:
            for item in data_to_write:
                f.write(item + '\n')
        print(f"Successfully wrote data to '{filepath}'.")
    except PermissionError:
        print(f"Error: Insufficient permissions to write to '{filepath}'. Check directory permissions.")
    except IOError as e:
        print(f"I/O Error during write to '{filepath}': {e}")
    except Exception as e:
        print(f"An unexpected error occurred during write to '{filepath}': {e}")

# --- Test Cases ---
# Setup test files
if not os.path.exists('test_data'):
    os.makedirs('test_data')

# Create a valid test file
with open('test_data/sample.txt', 'w', encoding='utf-8') as f:
    f.write("Line 1\n")
    f.write("Line 2\n")
    f.write("Line with error here\n") # This line will trigger a simulated error
    f.write("Line 4\n")

# Create a file with incorrect encoding (e.g., Latin-1 masquerading as UTF-8)
with open('test_data/bad_encoding.txt', 'wb') as f:
    f.write("Déjà vu".encode('latin-1'))

# Run tests
processed_content = process_data_file('test_data/sample.txt')
if processed_content:
    print(f"Content processed: {processed_content}")
    write_processed_data('test_output/processed_sample.txt', processed_content)

process_data_file('non_existent_file.txt')
process_data_file('test_data/') # Test IsADirectoryError
process_data_file('test_data/bad_encoding.txt')

# Clean up (optional)
# import shutil
# if os.path.exists('test_data'):
#     shutil.rmtree('test_data')
# if os.path.exists('test_output'):
#     shutil.rmtree('test_output')

# Python script to handle encoding and demonstrate data integrity concepts
import hashlib
import os

def read_file_with_encoding(filepath, encoding='utf-8'):
    """
    Attempts to read a file with a specified encoding, handling UnicodeDecodeError.
    Args:
        filepath (str): The path to the file.
        encoding (str): The encoding to try.
    Returns:
        list or None: List of lines if successful, None otherwise.
    """
    print(f"\nAttempting to read '{filepath}' with encoding '{encoding}'.")
    try:
        with open(filepath, 'r', encoding=encoding) as f:
            content = [line.strip() for line in f]
        print(f"Successfully read '{filepath}' with '{encoding}'.")
        return content
    except UnicodeDecodeError as e:
        print(f"UnicodeDecodeError: Failed to decode '{filepath}' with '{encoding}'. Error: {e}")
        print("Consider trying another encoding (e.g., 'latin-1', 'cp1252').")
    except FileNotFoundError:
        print(f"FileNotFoundError: '{filepath}' does not exist.")
    except Exception as e:
        print(f"An unexpected error occurred while reading '{filepath}': {e}")
    return None

def calculate_file_checksum(filepath, hash_algo='sha256'):
    """
    Calculates the checksum (hash) of a file for data integrity verification.
    Args:
        filepath (str): The path to the file.
        hash_algo (str): The hashing algorithm to use (e.g., 'md5', 'sha256').
    Returns:
        str or None: The hexadecimal digest of the file, or None if an error occurs.
    """
    print(f"\nCalculating {hash_algo} checksum for '{filepath}'.")
    if not os.path.exists(filepath):
        print(f"File not found: '{filepath}'. Cannot calculate checksum.")
        return None

    try:
        hasher = hashlib.new(hash_algo)
        with open(filepath, 'rb') as f:
            # Read in chunks to handle large files efficiently
            for chunk in iter(lambda: f.read(4096), b''):
                hasher.update(chunk)
        checksum = hasher.hexdigest()
        print(f"Checksum for '{filepath}' ({hash_algo}): {checksum}")
        return checksum
    except FileNotFoundError:
        print(f"FileNotFoundError: '{filepath}' does not exist (race condition?).")
    except IOError as e:
        print(f"IOError during checksum calculation for '{filepath}': {e}")
    except ValueError:
        print(f"Error: Invalid hash algorithm '{hash_algo}'.")
    except Exception as e:
        print(f"An unexpected error occurred during checksum calculation for '{filepath}': {e}")
    return None

# --- Test Cases ---
# Setup test directory
if not os.path.exists('encoding_tests'):
    os.makedirs('encoding_tests')

# 1. Create a UTF-8 encoded file
utf8_filepath = 'encoding_tests/utf8_file.txt'
with open(utf8_filepath, 'w', encoding='utf-8') as f:
    f.write("Hello, world! © é à ñ\n")
    f.write("这是中文\n")

# 2. Create a Latin-1 encoded file
latin1_filepath = 'encoding_tests/latin1_file.txt'
with open(latin1_filepath, 'w', encoding='latin-1') as f:
    f.write("Français: déjà vu, garçon\n")

# 3. Create a binary file (simulating non-text data or corrupted text)
with open('encoding_tests/binary_data.bin', 'wb') as f:
    f.write(b'\x80\x81\x82\x83\x84') # Invalid UTF-8 sequence


# Test reading with correct encoding
read_file_with_encoding(utf8_filepath, 'utf-8')
read_file_with_encoding(latin1_filepath, 'latin-1')

# Test reading with incorrect encoding (should cause UnicodeDecodeError)
read_file_with_encoding(latin1_filepath, 'utf-8')
read_file_with_encoding(utf8_filepath, 'latin-1')
read_file_with_encoding('encoding_tests/binary_data.bin', 'utf-8')

# Test checksum calculation
calculate_file_checksum(utf8_filepath)
calculate_file_checksum(latin1_filepath, 'md5')
calculate_file_checksum('non_existent_checksum_file.txt')

# Clean up (optional)
# import shutil
# if os.path.exists('encoding_tests'):
#     shutil.rmtree('encoding_tests')

# Python script to illustrate atomic file writing using a temporary file and rename
import os
import time
import threading

# Define a shared counter file path
COUNTER_FILE = 'data/counter.txt'

def increment_counter_safely():
    """
    Increments a counter in a file using an atomic operation (write to temp, then rename).
    This avoids corruption in case of crashes during write, but doesn't handle concurrent *reads*.
    For true multi-process/thread concurrency, external locking or database is better.
    """
    # Ensure directory exists
    os.makedirs(os.path.dirname(COUNTER_FILE), exist_ok=True)

    current_value = 0
    # Read current value (non-atomic read, potential for race condition if another process writes)
    if os.path.exists(COUNTER_FILE):
        try:
            with open(COUNTER_FILE, 'r') as f:
                content = f.read().strip()
                if content.isdigit():
                    current_value = int(content)
                else:
                    print(f"Warning: '{COUNTER_FILE}' contains non-numeric data. Resetting to 0.")
        except (FileNotFoundError, IOError) as e:
            print(f"Error reading counter file: {e}. Starting from 0.")
        except Exception as e:
            print(f"An unexpected error occurred during read: {e}. Starting from 0.")

    new_value = current_value + 1
    temp_filepath = COUNTER_FILE + '.tmp'

    try:
        # 1. Write to a temporary file
        with open(temp_filepath, 'w') as f:
            f.write(str(new_value))
        
        # 2. Atomically replace the original file with the temporary file
        # os.replace() is atomic on POSIX systems for files on the same filesystem
        os.replace(temp_filepath, COUNTER_FILE)
        print(f"Thread {threading.get_ident()}: Incremented counter to {new_value}")

    except IOError as e:
        print(f"Error performing atomic write for '{COUNTER_FILE}': {e}")
        # Clean up temporary file if it failed before rename
        if os.path.exists(temp_filepath):
            os.remove(temp_filepath)
    except Exception as e:
        print(f"An unexpected error occurred during atomic write: {e}")
        if os.path.exists(temp_filepath):
            os.remove(temp_filepath)


def worker():
    """
    A simple worker function for threading to simulate concurrent access.
    """
    for _ in range(5):
        increment_counter_safely()
        time.sleep(0.01) # Simulate some work

# --- Test Cases ---
# Clean up previous counter file if exists for fresh run
if os.path.exists(COUNTER_FILE):
    os.remove(COUNTER_FILE)

# Create a directory for the counter file if it doesn't exist
os.makedirs(os.path.dirname(COUNTER_FILE), exist_ok=True)

# Run multiple threads to simulate concurrent updates
print("\nSimulating concurrent counter increments with atomic write...")
threads = []
for _ in range(3):
    thread = threading.Thread(target=worker)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(f"\nFinal counter value in '{COUNTER_FILE}':")
if os.path.exists(COUNTER_FILE):
    with open(COUNTER_FILE, 'r') as f:
        print(f.read().strip())
else:
    print("Counter file not found after operations.")

# Note: While os.replace provides atomic *replacement*, the read-modify-write cycle
# itself is not fully atomic across processes without external locking mechanisms.
# For true multi-process/thread concurrency, consider 'filelock' library, database locks,
# or queueing systems like Redis/RabbitMQ.