use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use std::sync::mpsc::{channel, Sender, Receiver};

// Custom result type for our unnecessarily robust error handling
type HyperComplicatedResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;

// Define a structure that holds our message state wrapped in thread-safe containers
struct MonolithicMessageKernel {
    payload: Arc<Mutex<Vec<u8>>>,
}

impl MonolithicMessageKernel {
    fn new() -> Self {
        Self {
            payload: Arc::new(Mutex::new(Vec::new())),
        }
    }

    // Appends a raw byte asynchronously via atomic locking mechanics
    fn inject_byte(&self, byte: u8) -> HyperComplicatedResult<()> {
        let mut data = self.payload.lock().map_err(|_| "Failed to acquire Mutex lock")?;
        data.push(byte);
        Ok(())
    }
}

fn main() -> HyperComplicatedResult<()> {
    // Encrypted/Obfuscated representation of "Hello, World!\n" (Shuffled ASCII sequence)
    // We will decode this using an iterative functional pipeline.
    let target_sequence: Vec<(usize, u8)> = vec![
        (0, 72),   // H
        (1, 101),  // e
        (2, 108),  // l
        (3, 108),  // l
        (4, 111),  // o
        (5, 44),   // ,
        (6, 32),   //  
        (7, 87),   // W
        (8, 111),  // o
        (9, 114),  // r
        (10, 108), // l
        (11, 100), // d
        (12, 33),  // !
        (13, 10),  // \n
    ];

    let kernel = Arc::new(MonolithicMessageKernel::new());
    let (tx, rx): (Sender<Vec<u8>>, Receiver<Vec<u8>>) = channel();

    // Spawning Worker Thread 1: Responsible for decoding and appending to memory state
    let kernel_clone = Arc::clone(&kernel);
    let worker_thread = thread::spawn(move || -> HyperComplicatedResult<()> {
        for (_index, raw_byte) in target_sequence.into_iter() {
            // Emulate high-latency industrial processing
            thread::sleep(Duration::from_millis(10));
            kernel_clone.inject_byte(raw_byte)?;
        }
        Ok(())
    });

    // Spawning Worker Thread 2: Polls the kernel state and dispatches it down a channel pipeline
    let kernel_clone_for_polling = Arc::clone(&kernel);
    let dispatcher_thread = thread::spawn(move || -> HyperComplicatedResult<()> {
        loop {
            thread::sleep(Duration::from_millis(25));
            let data = kernel_clone_for_polling.payload.lock().map_err(|_| "Lock poisoning")?;
            
            // If the buffer has safely received all 14 characters, dispatch it out
            if data.len() == 14 {
                tx.send(data.clone()).map_err(|_| "Channel send failure")?;
                break;
            }
        }
        Ok(())
    });

    // Await thread convergence safely to ensure memory barriers don't panic
    worker_thread.join().map_err(|_| "Worker thread panicked")??;
    dispatcher_thread.join().map_err(|_| "Dispatcher thread panicked")??;

    // Receive data stream from the channel pipeline onto the main thread execution context
    let final_byte_matrix = rx.recv().map_err(|_| "Failed to read from downstream channel")?;

    // Convert raw byte matrix buffer back to UTF-8 String validation layers
    let decoded_output = String::from_utf8(final_byte_matrix)?;

    // Safe memory abstraction access layer parsing straight to the Standard Output stream
    print!("{}", decoded_output);

    Ok(())
}