/*
 * Illustration of basic std::condition_variable usage.
 * This minimal example demonstrates how one thread can signal another to proceed.
 * It is not a complete producer-consumer but sets the stage for understanding.
 */
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;

// Consumer-like thread waits for a signal
void consumer_thread_func() {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Consumer: Waiting for data...\n";
    // Wait until data_ready is true. The predicate protects against spurious wakeups.
    cv.wait(lock, []{ return data_ready; }); 
    std::cout << "Consumer: Data received! Proceeding.\n";
    // Simulate processing
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "Consumer: Done processing.\n";
}

// Producer-like thread prepares data and signals
void producer_thread_func() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // Simulate work
    {
        std::lock_guard<std::mutex> lock(mtx);
        data_ready = true; // Modify the shared state under lock
        std::cout << "Producer: Data prepared, notifying consumer.\n";
    }
    cv.notify_one(); // Signal the waiting consumer
    std::cout << "Producer: Notification sent.\n";
}

int main() {
    std::thread producer(producer_thread_func);
    std::thread consumer(consumer_thread_func);

    producer.join();
    consumer.join();

    std::cout << "Main: All threads finished.\n";
    return 0;
}

/*
 * Blueprint for a Producer-Consumer setup, demonstrating shared queue and basic synchronization.
 * This version shows the structure with mutex protection but without condition variables,
 * highlighting the need for efficient waiting.
 */
#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <vector>

std::queue<int> shared_buffer;
std::mutex buffer_mtx;
const int MAX_BUFFER_SIZE = 10;

// Producer function: generates items and puts them into the buffer
void producer_func(int id, int num_items) {
    for (int i = 0; i < num_items; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Simulate work
        {
            std::lock_guard<std::mutex> lock(buffer_mtx);
            // In a real scenario, producer would wait if buffer is full
            // For now, we just add, assuming consumer will keep up or buffer is large.
            shared_buffer.push(i);
            std::cout << "Producer " << id << ": Produced item " << i << ". Buffer size: " << shared_buffer.size() << "\n";
        }
    }
    std::cout << "Producer " << id << ": Finished producing.\n";
}

// Consumer function: takes items from the buffer and processes them
void consumer_func(int id) {
    while (true) {
        int item = -1; // Default invalid item
        {
            std::lock_guard<std::mutex> lock(buffer_mtx);
            if (!shared_buffer.empty()) {
                item = shared_buffer.front();
                shared_buffer.pop();
                std::cout << "Consumer " << id << ": Consumed item " << item << ". Buffer size: " << shared_buffer.size() << "\n";
            }
        }
        if (item != -1) {
            std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Simulate processing
        } else {
            // Without condition variable, consumer would busy-wait or sleep briefly
            std::this_thread::sleep_for(std::chrono::milliseconds(10)); // Prevent busy-waiting
        }

        // A real termination condition would be needed here
        if (item == -1 && shared_buffer.empty() /* and producer signals completion */) {
            // For this blueprint, we don't have a robust termination signal yet.
            // We'll add this with condition variables.
            break; // Temporary break for a simple demo
        }
    }
    std::cout << "Consumer " << id << ": Finished consuming.\n";
}

/*
int main() {
    // Note: This main will not run effectively without a robust termination for consumer.
    // It's a conceptual blueprint to show basic queue + mutex.
    // The full solution requires condition variables.

    std::thread producer1(producer_func, 1, 5);
    std::thread consumer1(consumer_func, 1);

    producer1.join();
    consumer1.join();

    return 0;
}
*/

/*
 * Complete Producer-Consumer implementation using std::condition_variable.
 * This example demonstrates a bounded buffer, where producers wait if the buffer is full,
 * and consumers wait if the buffer is empty. It also includes a robust termination mechanism.
 */
#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <chrono>

std::queue<int> shared_buffer;
std::mutex buffer_mtx;
std::condition_variable cv_producer, cv_consumer;
const int MAX_BUFFER_SIZE = 5;
bool producers_done = false;

// Producer function
void producer_func(int id, int num_items) {
    for (int i = 0; i < num_items; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Simulate work
        std::unique_lock<std::mutex> lock(buffer_mtx);
        // Producer waits if the buffer is full
        cv_producer.wait(lock, [] { return shared_buffer.size() < MAX_BUFFER_SIZE; });

        shared_buffer.push(i);
        std::cout << "Producer " << id << ": Produced item " << i << ". Buffer size: " << shared_buffer.size() << "\n";

        cv_consumer.notify_one(); // Notify consumer that new data is available
    }
    std::cout << "Producer " << id << " (ID:" << id << "): Finished producing.\n";
}

// Consumer function
void consumer_func(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(buffer_mtx);
        // Consumer waits if the buffer is empty AND producers are not done
        cv_consumer.wait(lock, [] {
            return !shared_buffer.empty() || producers_done; // Predicate for robust waiting and termination
        });

        // If buffer is empty AND all producers are done, then it's time to terminate
        if (shared_buffer.empty() && producers_done) {
            std::cout << "Consumer " << id << ": Detected all producers done and buffer empty. Terminating.\n";
            // Important: notify other consumers to also terminate, if they are waiting.
            cv_consumer.notify_all(); 
            break; 
        }

        int item = shared_buffer.front();
        shared_buffer.pop();
        std::cout << "Consumer " << id << ": Consumed item " << item << ". Buffer size: " << shared_buffer.size() << "\n";

        cv_producer.notify_one(); // Notify producer that space is available
        lock.unlock(); // Release lock as soon as possible, especially before simulated work
        std::this_thread::sleep_for(std::chrono::milliseconds(150)); // Simulate processing
    }
    std::cout << "Consumer " << id << ": Finished consuming.\n";
}

int main() {
    const int num_producers = 2;
    const int num_consumers = 2;
    const int items_per_producer = 5;

    std::vector<std::thread> producers;
    for (int i = 0; i < num_producers; ++i) {
        producers.emplace_back(producer_func, i + 1, items_per_producer);
    }

    std::vector<std::thread> consumers;
    for (int i = 0; i < num_consumers; ++i) {
        consumers.emplace_back(consumer_func, i + 1);
    }

    // Join producers first to ensure all items are added (or attempted to be added)
    for (auto& p_thread : producers) {
        p_thread.join();
    }

    // After all producers are done, signal this state
    {
        std::lock_guard<std::mutex> lock(buffer_mtx);
        producers_done = true; // Set shared state under lock
        std::cout << "Main: All producers have finished their work.\n";
    }
    cv_consumer.notify_all(); // Wake up all waiting consumers to check for termination condition

    // Join consumers
    for (auto& c_thread : consumers) {
        c_thread.join();
    }

    std::cout << "Main: All threads have terminated cleanly.\n";
    return 0;
}

/*
 * Advanced considerations for Producer-Consumer with std::condition_variable.
 * This section focuses on best practices, performance, and avoiding pitfalls like lost wakeups.
 * No new complete runnable code block, but principles apply to the previous example.
 */
// Example of considering notify_one vs notify_all implications.
// In the consumer, when notifying producers:
// cv_producer.notify_one(); // Often sufficient if only one producer needs to proceed.
// cv_producer.notify_all(); // Use if multiple producers could potentially proceed (e.g., buffer has many free slots)

// Example of considering std::this_thread::yield() or std::this_thread::sleep_for() outside locks
// when polling is considered, but emphasizing condition variables are superior.
// void consumer_alternative_bad() {
//     while(true) {
//         std::unique_lock<std::mutex> lock(buffer_mtx);
//         if (!shared_buffer.empty()) {
//             // ... process item ...
//             lock.unlock(); // Release lock before extensive work
//             // Simulate work
//         } else {
//             lock.unlock(); // Release lock before sleeping
//             std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Poor man's wait
//         }
//     }
// }

// Key takeaway: Always use predicates with wait() to prevent spurious wakeups and ensure correctness.
// `cv.wait(lock, []{ return condition; });` is the canonical pattern.

// For termination, ensure all waiting threads are notified.
// cv_consumer.notify_all(); // When signaling producers_done = true; to all consumers