# Python Code: Activating Foundational Text File Operations

import os

# --- 1. Writing to a Text File (Simple Overwrite) ---
# Using 'w' mode: opens for writing, overwrites if file exists, creates if not.
# Ensure to close the file or use a context manager (recommended).
print("\n--- Writing to a new file (overwrite) ---")
try:
    with open('first_draft.txt', 'w', encoding='utf-8') as file_object:
        file_object.write('The first line of our Python journey.\n')
        file_object.write('A second line follows, capturing insight.\n')
    print("Content successfully written to 'first_draft.txt'.")
except IOError as e:
    print(f"Error writing file: {e}")

# --- 2. Reading from a Text File (Entire Content) ---
# Using 'r' mode: opens for reading (default).
print("\n--- Reading entire file content ---")
try:
    with open('first_draft.txt', 'r', encoding='utf-8') as file_object:
        content = file_object.read() # Reads the entire file into a single string
        print("File Content:\n---\n" + content + "---")
except FileNotFoundError:
    print("Error: 'first_draft.txt' not found.")
except IOError as e:
    print(f"Error reading file: {e}")

# --- 3. Reading Line by Line ---
print("\n--- Reading file line by line ---")
try:
    with open('first_draft.txt', 'r', encoding='utf-8') as file_object:
        print("File Content (Line by Line):\n---")
        for line in file_object: # Iterating over the file object reads lines efficiently
            print(line.strip()) # .strip() removes trailing newlines
        print("---")
except FileNotFoundError:
    print("Error: 'first_draft.txt' not found.")
except IOError as e:
    print(f"Error reading file: {e}")

# --- 4. Appending to a Text File ---
# Using 'a' mode: opens for appending, adds content to the end of the file.
print("\n--- Appending to an existing file ---")
try:
    with open('first_draft.txt', 'a', encoding='utf-8') as file_object:
        file_object.write('Adding a new line at the end.\n')
        file_object.write('The saga continues.\n')
    print("Content successfully appended to 'first_draft.txt'.")
except IOError as e:
    print(f"Error appending file: {e}")

# Verify appended content
print("\n--- Verifying appended content ---")
try:
    with open('first_draft.txt', 'r', encoding='utf-8') as file_object:
        final_content = file_object.read()
        print("Updated File Content:\n---\n" + final_content + "---")
except FileNotFoundError:
    print("Error: 'first_draft.txt' not found.")
except IOError as e:
    print(f"Error reading file: {e}")

# --- Cleanup (Optional) ---
# os.remove('first_draft.txt')
# print("\n'first_draft.txt' removed for cleanup.")

# Python Code: Engineering Advanced Text File Manipulation

import csv
import json
import os

# --- 1. Processing and Transforming Line by Line ---
# Example: Convert a simple comma-separated list to a list of numbers, then sum them.
print("\n--- Processing data line by line ---")
data_to_write = "10,20,30\n40,50,60\n"
try:
    with open('numeric_data.txt', 'w', encoding='utf-8') as f:
        f.write(data_to_write)

    total_sum = 0
    processed_lines = []
    with open('numeric_data.txt', 'r', encoding='utf-8') as f:
        for line in f:
            numbers_str = line.strip().split(',') # Strip newline, split by comma
            try:
                numbers = [int(n) for n in numbers_str if n.strip()]
                current_line_sum = sum(numbers)
                total_sum += current_line_sum
                processed_lines.append(f"Line sum: {current_line_sum}")
            except ValueError as e:
                print(f"Warning: Could not process line '{line.strip()}' due to {e}")
    print("Processed lines:\n" + "\n".join(processed_lines))
    print(f"Total sum of all numbers: {total_sum}")
except IOError as e:
    print(f"Error during line-by-line processing: {e}")

# --- 2. Using csv module for structured text data ---
print("\n--- Working with CSV files ---")
csv_data = [
    {'name': 'Alice', 'age': 30, 'city': 'New York'},
    {'name': 'Bob', 'age': 24, 'city': 'London'}
]
csv_file_name = 'users.csv'

try:
    with open(csv_file_name, 'w', newline='', encoding='utf-8') as csvfile:
        fieldnames = ['name', 'age', 'city']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(csv_data)
    print(f"Data written to '{csv_file_name}'.")

    # Reading CSV
    with open(csv_file_name, 'r', encoding='utf-8') as csvfile:
        reader = csv.DictReader(csvfile)
        print("Read from CSV:")
        for row in reader:
            print(row)
except IOError as e:
    print(f"Error processing CSV file: {e}")

# --- 3. Using json module for structured text data ---
print("\n--- Working with JSON files ---")
json_data = {
    "products": [
        {"id": "P001", "name": "Laptop", "price": 1200},
        {"id": "P002", "name": "Mouse", "price": 25}
    ]
}
json_file_name = 'products.json'

try:
    with open(json_file_name, 'w', encoding='utf-8') as jsonfile:
        json.dump(json_data, jsonfile, indent=4) # indent for pretty printing
    print(f"Data written to '{json_file_name}'.")

    # Reading JSON
    with open(json_file_name, 'r', encoding='utf-8') as jsonfile:
        loaded_data = json.load(jsonfile)
        print("Read from JSON:")
        print(loaded_data)
        print(f"Product count: {len(loaded_data['products'])}")
except IOError as e:
    print(f"Error processing JSON file: {e}")

# --- Cleanup (Optional) ---
# os.remove('numeric_data.txt')
# os.remove(csv_file_name)
# os.remove(json_file_name)

# Python Code: Decoding Binary File Mastery

import struct # For packing/unpacking binary data
import os

# --- 1. Writing Binary Data (bytes objects) ---
# Using 'wb' mode: opens for writing in binary mode.
print("\n--- Writing binary data ---")
binary_file_name = 'data.bin'

# Example: Store a header (4 bytes) and two float values (8 bytes each)
# 'I' for unsigned int, 'f' for float. '!': network byte order (big-endian)
# This packs data into a bytes object
header = struct.pack('!I', 0xDEADBEEF) # A magic number header
value1 = struct.pack('!f', 3.14159)
value2 = struct.pack('!f', 2.71828)

combined_data = header + value1 + value2

try:
    with open(binary_file_name, 'wb') as f:
        f.write(combined_data)
    print(f"Binary data ({len(combined_data)} bytes) successfully written to '{binary_file_name}'.")
except IOError as e:
    print(f"Error writing binary file: {e}")

# --- 2. Reading Binary Data (bytes objects) ---
# Using 'rb' mode: opens for reading in binary mode.
print("\n--- Reading binary data ---")
try:
    with open(binary_file_name, 'rb') as f:
        read_header = f.read(4) # Read 4 bytes for the header
        read_value1 = f.read(4) # Read 4 bytes for the first float
        read_value2 = f.read(4) # Read 4 bytes for the second float

        # Unpack the binary data back into Python types
        unpacked_header = struct.unpack('!I', read_header)[0]
        unpacked_value1 = struct.unpack('!f', read_value1)[0]
        unpacked_value2 = struct.unpack('!f', read_value2)[0]

        print(f"Read Header (hex): {hex(unpacked_header)}")
        print(f"Read Value 1: {unpacked_value1:.5f}")
        print(f"Read Value 2: {unpacked_value2:.5f}")

        # Demonstrate reading remaining data if any (will be empty here)
        remaining_data = f.read()
        if remaining_data:
            print(f"Warning: Remaining data found: {remaining_data}")

except FileNotFoundError:
    print(f"Error: '{binary_file_name}' not found.")
except IOError as e:
    print(f"Error reading binary file: {e}")
except struct.error as e:
    print(f"Error unpacking binary data: {e}. Data might be corrupt or malformed.")

# --- 3. Working with bytearrays for mutable binary data ---
print("\n--- Working with mutable bytearrays ---")
# Create a bytearray from a list of integers (0-255)
byte_array_data = bytearray([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]) # "Hello World"
print(f"Original bytearray: {byte_array_data}")

# Modify an element
byte_array_data[6] = 87 # Change 'W' to 'w'
print(f"Modified bytearray: {byte_array_data}")

# Write the bytearray to a binary file
bytearray_file_name = 'mutable_bytes.bin'
try:
    with open(bytearray_file_name, 'wb') as f:
        f.write(byte_array_data)
    print(f"Bytearray written to '{bytearray_file_name}'.")

    # Read back and verify
    with open(bytearray_file_name, 'rb') as f:
        read_bytearray = bytearray(f.read())
        print(f"Read bytearray: {read_bytearray}")
        print(f"Decoded: {read_bytearray.decode('utf-8')}")
except IOError as e:
    print(f"Error with bytearray file operations: {e}")

# --- Cleanup (Optional) ---
# os.remove(binary_file_name)
# os.remove(bytearray_file_name)

# Python Code: Engineering Robust File Handling - Error Management & Path Strategy

import os
from pathlib import Path
import shutil # For high-level file operations like copying

# --- 1. Robust Error Handling for File Operations ---
print("\n--- Demonstrating Robust Error Handling ---")
non_existent_file = 'no_such_file.txt'
read_only_file = 'read_only_test.txt'

# Attempt to read a non-existent file
try:
    with open(non_existent_file, 'r') as f:
        content = f.read()
    print(f"Content of '{non_existent_file}': {content}")
except FileNotFoundError:
    print(f"Caught expected error: '{non_existent_file}' does not exist.")
except IOError as e: # Catch other potential IO errors
    print(f"Caught general IO error: {e}")

# Create a dummy read-only file (Unix-like systems: chmod 444, Windows: manual config or specific libraries)
# For simplicity, we'll simulate an error by trying to write to a directory or a system protected file.
# Actual permission errors might require OS-specific commands or admin privileges.

# Attempt to write to a path that is a directory (will raise IsADirectoryError, subclass of OSError)
output_dir = 'output_data_directory'
os.makedirs(output_dir, exist_ok=True)

try:
    # This will fail because 'output_data_directory' is a directory, not a file.
    with open(output_dir, 'w') as f:
        f.write("This should not be written.")
except IsADirectoryError:
    print(f"Caught expected error: Cannot open a directory '{output_dir}' as a file for writing.")
except PermissionError:
    print(f"Caught PermissionError: Insufficient rights to write to '{output_dir}'.")
except IOError as e:
    print(f"Caught general IO error during directory write attempt: {e}")
finally:
    # Clean up the created directory
    if os.path.exists(output_dir):
        shutil.rmtree(output_dir)
        print(f"Cleaned up directory: '{output_dir}'.")

# --- 2. Path Manipulation with pathlib ---
print("\n--- Path Manipulation with pathlib ---")
# Create a Path object for a file in a subdirectory
current_dir = Path.cwd()
sub_dir = current_dir / 'reports'
output_file = sub_dir / 'monthly_report.txt'

print(f"Current directory: {current_dir}")
print(f"Subdirectory path: {sub_dir}")
print(f"Output file path: {output_file}")

# Ensure the directory exists before writing
os.makedirs(sub_dir, exist_ok=True)

# Write to the file using pathlib path
try:
    output_file.write_text("Monthly sales data for Q1.\n")
    print(f"Content written to '{output_file}'.")

    # Read from the file using pathlib path
    read_content = output_file.read_text()
    print(f"Content read from '{output_file}': {read_content.strip()}")

except Exception as e:
    print(f"Error with pathlib operations: {e}")
finally:
    # Clean up the created subdirectory and file
    if sub_dir.exists():
        shutil.rmtree(sub_dir) # Removes directory and all its contents
        print(f"Cleaned up directory: '{sub_dir}'.")

# --- 3. Efficiency and Resource Management ---
print("\n--- Efficiency and Resource Management ---")
large_file_path = 'large_data.log'

# Generate a large dummy file
print("Generating a dummy large file...")
num_lines = 100000
with open(large_file_path, 'w') as f:
    for i in range(num_lines):
        f.write(f"Log entry {i}: This is a sample log line for testing performance.\n")
print(f"'{large_file_path}' created with {num_lines} lines.")

# Efficiently processing a large file line-by-line (without loading fully into memory)
print("Efficiently counting lines in a large file...")
line_count = 0
try:
    with open(large_file_path, 'r') as f:
        for _ in f: # Iterate directly over file object
            line_count += 1
    print(f"Total lines counted: {line_count} (efficiently).")
except IOError as e:
    print(f"Error reading large file: {e}")

# Cleanup
if os.path.exists(large_file_path):
    os.remove(large_file_path)
    print(f"Cleaned up: '{large_file_path}'.")