/*
 * We acknowledge the foundational challenge: raw I/O operations inherently incur significant overhead.
 * Each direct read or write call often translates into a costly system call,
 * involving context switches between user space and kernel space.
 * This demonstration illustrates a basic, non-buffered file write, primarily to establish a baseline
 * for understanding the problem buffering solves. In production, we *always* advocate for buffering
 * when dealing with disk or network I/O to mitigate these performance penalties.
 */

import java.io.FileWriter;
import java.io.IOException;

public class NonBufferedWriterExample {

    public static void main(String[] args) {
        String filePath = "output_non_buffered.txt";
        String data = "This is a small piece of data written without buffering.\n";

        // We wrap the resource in a try-with-resources statement for automatic closure.
        // This pattern is crucial for robust resource management.
        try (FileWriter writer = new FileWriter(filePath)) {
            for (int i = 0; i < 1000; i++) { // Simulate writing multiple small chunks
                writer.write(data);
            }
            System.out.println("Data successfully written to " + filePath + " without buffering.");
            System.out.println("Observe that each 'write' call likely triggers a system call.");
        } catch (IOException e) {
            // We meticulously handle potential I/O errors, preventing application failures.
            System.err.println("An I/O error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

/*
 * We utilize BufferedReader to dramatically enhance the efficiency of text file reading.
 * It wraps an underlying Reader (e.g., FileReader), providing a buffered input stream
 * that reads characters into an internal buffer.
 * This minimizes direct disk reads, especially for line-by-line processing, which is a common pattern.
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {

    public static void main(String[] args) {
        String filePath = "input_buffered.txt";

        // First, we ensure an input file exists for demonstration.
        // In a real scenario, this file would already be present.
        createSampleInputFile(filePath);

        // We meticulously use try-with-resources to ensure the BufferedReader is automatically closed,
        // preventing resource leaks and guaranteeing robust application behavior.
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            System.out.println("\nReading data using BufferedReader:");
            // We iterate, reading line by line until the end of the stream is reached.
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            System.out.println("Data successfully read from " + filePath + " using buffering.");
        } catch (IOException e) {
            // We rigorously capture and report I/O exceptions, ensuring application stability.
            System.err.println("An I/O error occurred during read: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // This helper method creates a simple text file for our demonstration.
    private static void createSampleInputFile(String filePath) {
        try (FileWriter writer = new FileWriter(filePath)) {
            writer.write("Line 1: Buffered reading optimizes performance.\n");
            writer.write("Line 2: It reduces the number of system calls.\n");
            writer.write("Line 3: Essential for high-speed data processing.\n");
            System.out.println("Sample input file created: " + filePath);
        } catch (IOException e) {
            System.err.println("Error creating sample file: " + e.getMessage());
        }
    }
}

/*
 * We deploy BufferedWriter to optimize writing text data to various destinations.
 * Similar to BufferedReader, it uses an internal buffer to accumulate character data
 * before writing it in larger, more efficient chunks to the underlying Writer (e.g., FileWriter).
 * This dramatically reduces the number of costly system calls for write operations.
 */

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {

    public static void main(String[] args) {
        String filePath = "output_buffered.txt";
        String[] lines = {
                "First line engineered for efficiency.",
                "Second line demonstrates buffered writing benefits.",
                "Third line reinforces the importance of flushing."
        };

        // We employ try-with-resources to guarantee the BufferedWriter and its underlying FileWriter
        // are closed automatically, preventing resource leaks.
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            System.out.println("\nWriting data using BufferedWriter:");
            for (String line : lines) {
                writer.write(line); // We write the string to the buffer.
                writer.newLine();   // We insert a platform-independent new line character.
                System.out.println("Wrote to buffer: " + line);
            }
            // Crucially, we activate flush() to ensure all buffered data is written to the destination.
            // Without this, data might remain in the buffer if the stream is not explicitly closed.
            writer.flush();
            System.out.println("All buffered data flushed to " + filePath + ".");
            System.out.println("Data successfully written using buffering.");
        } catch (IOException e) {
            // We systematically handle any I/O exceptions, fortifying the application's resilience.
            System.err.println("An I/O error occurred during write: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

/*
 * We elevate our buffering strategy by customizing buffer sizes and demonstrating robust resource management.
 * The default buffer size (typically 8192 characters for BufferedReader/Writer)
 * might not always be optimal for all use cases. We can engineer specific sizes
 * to align with our application's data processing patterns and underlying hardware characteristics.
 * This example also reinforces the use of try-with-resources for guaranteed resource closure.
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class AdvancedBufferingExample {

    public static void main(String[] args) {
        // We define a custom buffer size that might be more suitable for large files.
        // A common strategy is to align with typical disk block sizes (e.g., 4KB, 8KB, 16KB).
        int customBufferSize = 16384; // 16 KB buffer for characters

        String inputFile = "input_large.txt";
        String outputFile = "output_processed.txt";

        // First, we ensure a large input file exists for demonstration.
        createLargeSampleInputFile(inputFile, 10000); // 10,000 lines for a larger file

        System.out.println("\nDemonstrating custom buffer size and advanced handling:\n");

        // We implement a chain of buffered streams with a custom buffer size
        // and ensure proper resource management with try-with-resources.
        try (
            BufferedReader reader = new BufferedReader(new FileReader(inputFile), customBufferSize);
            BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile), customBufferSize)
        ) {
            String line;
            int lineCount = 0;
            // We iterate through the input, processing each line.
            while ((line = reader.readLine()) != null) {
                // We apply a simple transformation: convert to uppercase and append line number.
                writer.write(++lineCount + ": " + line.toUpperCase());
                writer.newLine();
            }
            System.out.println("Processed " + lineCount + " lines from " + inputFile + ".");
            System.out.println("Transformed data written to " + outputFile + " with custom buffer size.");
        } catch (IOException e) {
            // We intercept and report I/O errors decisively.
            System.err.println("An I/O error occurred during processing: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // This helper method creates a larger sample text file for our demonstration.
    private static void createLargeSampleInputFile(String filePath, int numLines) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            for (int i = 1; i <= numLines; i++) {
                writer.write("Sample line " + i + ": This is some data for performance testing.");
                writer.newLine();
            }
            System.out.println("Created large sample input file: " + filePath + " with " + numLines + " lines.");
        } catch (IOException e) {
            System.err.println("Error creating large sample file: " + e.getMessage());
        }
    }
}