/*
 * C++20 std::jthread Revolution: Automating Concurrency Lifecycles
 * This example demonstrates the basic creation and automatic joining behavior of std::jthread.
 */

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>

// A simple worker function that does some work and prints a message.
void worker_function(int id) {
    std::cout << "Worker " << id << ": Starting task..." << std::endl;
    // Simulate some work being done
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "Worker " << id << ": Task completed." << std::endl;
}

int main() {
    std::cout << "Main thread: Launching jthread..." << std::endl;

    // Create a std::jthread. It will automatically join when it goes out of scope.
    // No explicit .join() or .detach() is needed.
    std::jthread my_jthread(worker_function, 1);

    std::cout << "Main thread: jthread launched. Continuing main thread work..." << std::endl;

    // Simulate other work in the main thread
    std::this_thread::sleep_for(std::chrono::milliseconds(200));

    std::cout << "Main thread: jthread scope ending. Automatic join will occur." << std::endl;
    // When 'my_jthread' goes out of scope here, it will automatically join.
    // The program will wait for 'worker_function' to complete before exiting 'main'.

    std::cout << "Main thread: Program exiting." << std::endl;

    return 0;
}

/*
 * C++20 std::jthread Core Mechanism: Automatic Joining
 * This example highlights the automatic joining behavior and contrasts with std::thread's explicit requirement.
 */

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <numeric>

// A simple task that sums numbers from a range
void sum_task(int start, int end, std::vector<int>& results) {
    long long current_sum = 0;
    for (int i = start; i <= end; ++i) {
        current_sum += i;
        // Simulate work
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    results.push_back(current_sum);
    std::cout << "  Worker thread [" << start << "-" << end << "]: Calculated sum = " << current_sum << std::endl;
}

int main() {
    std::cout << "Main thread: Demonstrating std::jthread's automatic joining." << std::endl;

    std::vector<int> partial_sums;

    {
        // A new scope. std::jthread objects within this scope will join automatically when the scope ends.
        std::cout << "  Entering jthread scope..." << std::endl;
        std::jthread thread1(sum_task, 1, 100, std::ref(partial_sums));
        std::jthread thread2(sum_task, 101, 200, std::ref(partial_sums));
        std::jthread thread3(sum_task, 201, 300, std::ref(partial_sums));

        std::cout << "  jthreads launched. Main thread continues..." << std::endl;
        // Simulate some main thread work while jthreads run
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "  Main thread reached end of jthread scope. Waiting for jthreads to join automatically..." << std::endl;
    } // All std::jthread objects (thread1, thread2, thread3) automatically call .join() here.
      // The program waits for them to complete before continuing.

    std::cout << "Main thread: All jthreads have joined. Collecting results." << std::endl;

    long long total_sum = 0;
    for (int sum : partial_sums) {
        total_sum += sum;
    }

    std::cout << "Main thread: Final aggregated sum = " << total_sum << std::endl;
    std::cout << "Main thread: Program exiting." << std::endl;

    return 0;
}

/*
 * C++20 std::jthread Cooperative Cancellation with std::stop_token
 * This example shows how to use std::stop_token for graceful thread shutdown.
 */

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <numeric>
#include <stop_token>

// A worker function that performs a long-running task and checks for a stop request.
// It accepts a std::stop_token automatically provided by std::jthread.
void cancellable_worker(std::stop_token stoken, int id) {
    std::cout << "Worker " << id << ": Starting cancellable task." << std::endl;
    for (int i = 0; i < 10; ++i) {
        // Check if a stop has been requested at regular intervals
        if (stoken.stop_requested()) {
            std::cout << "Worker " << id << ": Stop requested. Exiting gracefully." << std::endl;
            return; // Gracefully exit the thread function
        }

        std::cout << "Worker " << id << ": Working... step " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
    std::cout << "Worker " << id << ": Task completed naturally." << std::endl;
}

int main() {
    std::cout << "Main thread: Launching cancellable jthread." << std::endl;

    // Create a std::jthread. It automatically creates a std::stop_source 
    // and passes a std::stop_token to the worker function.
    std::jthread worker_thread(cancellable_worker, 42);

    std::cout << "Main thread: Worker jthread running. Will request stop in 1 second." << std::endl;

    // Simulate some main thread activity
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // Request the worker_thread to stop. This sets the stop state on the std::stop_source
    // associated with 'worker_thread', which in turn makes its std::stop_token indicate
    // that a stop has been requested.
    worker_thread.request_stop(); 
    std::cout << "Main thread: Stop requested for worker jthread." << std::endl;

    // No explicit join() call is needed. The jthread will automatically join here
    // as worker_thread goes out of scope at the end of main.
    std::cout << "Main thread: Waiting for jthread to join automatically and exit." << std::endl;

    return 0;
}

/*
 * C++20 std::jthread Advanced Patterns & Best Practices
 * This example demonstrates passing arguments, move semantics, and an improved cancellation loop.
 */

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <numeric>
#include <stop_token>
#include <string>
#include <mutex>

std::mutex g_cout_mutex; // Global mutex for safe console output

// A more sophisticated worker function, demonstrating argument passing and structured cancellation.
void advanced_worker(std::stop_token stoken, int id, std::string name_prefix, std::vector<long long>& shared_data) {
    // Use a lock guard for safe console output from multiple threads
    std::lock_guard<std::mutex> lock(g_cout_mutex);
    std::cout << name_prefix << " Worker " << id << ": Starting advanced task." << std::endl;

    long long local_sum = 0;
    for (int i = 0; i < 20; ++i) {
        // Check for stop request more frequently or at logical points
        if (stoken.stop_requested()) {
            std::lock_guard<std::mutex> lock_exit(g_cout_mutex);
            std::cout << name_prefix << " Worker " << id << ": Stop requested. Exiting gracefully after processing " << i << " steps." << std::endl;
            return; // Exit point 1: Cooperative cancellation
        }

        // Simulate intensive computation and shared data modification
        local_sum += (id * i);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        std::lock_guard<std::mutex> lock_progress(g_cout_mutex);
        std::cout << name_prefix << " Worker " << id << ": Progress step " << i << std::endl;
    }

    // Upon successful completion, update shared data (needs protection)
    { // Critical section for shared_data modification
        std::lock_guard<std::mutex> lock_data(g_cout_mutex);
        shared_data.push_back(local_sum); 
        std::cout << name_prefix << " Worker " << id << ": Task completed naturally. Added " << local_sum << " to shared data." << std::endl;
    }
}

int main() {
    std::cout << "Main thread: Launching advanced jthreads." << std::endl;

    std::vector<long long> results_from_workers;
    // Protect access to results_from_workers if multiple threads could write to it simultaneously.
    // For this example, we pass it by reference to workers, but for real shared access, 
    // a mutex would be needed around push_back in advanced_worker.
    // Here, we simulate that protection with the g_cout_mutex for output, 
    // but for actual data it needs a dedicated mutex or atomic ops.

    // std::string is copyable/movable. std::ref for vector to avoid copy.
    std::jthread worker1(advanced_worker, 1, std::string("Alpha"), std::ref(results_from_workers));
    std::jthread worker2(advanced_worker, 2, std::string("Beta"), std::ref(results_from_workers));

    std::cout << "Main thread: Jthreads running. Will request stop for worker1 in 1.2 seconds." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(1200));
    worker1.request_stop(); // Request worker1 to stop early
    std::cout << "Main thread: Stop requested for Alpha Worker 1." << std::endl;

    std::cout << "Main thread: Allowing worker2 to complete, then all jthreads join automatically." << std::endl;
    // worker2 will likely complete naturally, worker1 will stop early.
    // Both will join automatically at the end of main.

    // Simulate more work, ensuring worker2 has time to finish
    std::this_thread::sleep_for(std::chrono::seconds(3));

    std::cout << "Main thread: All jthreads joined. Final results count: " << results_from_workers.size() << std::endl;
    std::cout << "Main thread: Program exiting." << std::endl;

    return 0;
}