/*

 * Hurl (https://hurl.dev)

 * Copyright (C) 2025 Orange

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *          http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 */

use std::sync::mpsc::{Receiver, Sender};

use std::sync::{mpsc, Arc, Mutex};

use super::error::JobError;

use super::job::{Job, JobQueue, JobResult};

use super::message::WorkerMessage;

use super::progress::{Mode, ParProgress};

use super::worker::{Worker, WorkerId};

use crate::output;

use crate::pretty::PrettyMode;

use crate::util::term::{Stderr, Stdout, WriteMode};

use hurl_core::error::{DisplaySourceError, OutputFormat};

use hurl_core::types::{Count, Index};

/// A parallel runner manages a list of `Worker`. Each worker is either idle or is running a

/// [`Job`]. To run jobs, the [`ParallelRunner::run`] method much be executed on the main thread.

/// Each worker has its own thread that it uses to run a Hurl file, and communicates with the main

/// thread. Standard multi-producer single-producer channels are used between the main runner and

/// the workers to send job request and receive job result.

///

/// The parallel runner is responsible to manage the state of the workers, and to display standard

/// output and standard error, in the main thread. Each worker reports its progression to the

/// parallel runner, which updates the workers states and displays a progress bar.

/// Inside each worker, logs (messages on standard error) and HTTP response (output on

/// standard output) are buffered and send to the runner to be eventually displayed.

///

/// By design, the workers state is read and modified on the main thread.

pub struct ParallelRunner {

    /// The list of workers, running Hurl file in their inner thread.

    workers: Vec<(Worker, WorkerState)>,

    /// The transmit end of the channel used to send messages to workers.

    tx: Option<Sender<Job>>,

    /// The receiving end of the channel used to communicate to workers.

    rx: Receiver<WorkerMessage>,

    /// Progress reporter to display the advancement of the parallel runs.

    progress: ParProgress,

    /// Output type for each completed job on standard output.

    output_type: OutputType,

    /// Repeat mode for the runner: infinite or finite.

    repeat: Count,

}

/// Represents a worker's state.

#[allow(clippy::large_enum_variant)]

pub enum WorkerState {

    /// Worker has no job to run.

    Idle,

    /// Worker is currently running a `job`, the entry index being executed is `current_entry`,

    /// the last entry index to be run is `last_entry` and `retry_count` is the number of retries.

    Running {

        job: Job,

        current_entry: Index,

        last_entry: Index,

        retry_count: usize,

    },

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum OutputType {

    /// The last HTTP response body of a Hurl file is outputted on standard output.

    ResponseBody {

        include_headers: bool,

        color: bool,

        pretty: PrettyMode,

    },

    /// The whole Hurl file run is exported in a structured JSON export on standard output.

    Json,

    /// Nothing is outputted on standard output when a Hurl file run is completed.

    NoOutput,

}

const MAX_RUNNING_DISPLAYED: usize = 8;

impl ParallelRunner {

    /// Creates a new parallel runner, with `worker_count` worker thread.

    ///

    /// The runner runs a list of [`Job`] in parallel. It creates two channels to communicate

    /// with the workers:

    ///

    /// - `runner -> worker`: is used to send [`Job`] processing request to a worker,

    /// - `worker -> runner`: is used to send [`WorkerMessage`] to update job progression, from a

    ///   worker to the runner.

    ///

    /// When a job is completed, depending on `output_type`, it can be outputted to standard output:

    /// whether as a raw response body bytes, or in a structured JSON output.

    ///

    /// The runner can repeat running a list of jobs. For instance, when repeating two times the job

    /// sequence (`a`, `b`, `c`), runner will act as if it runs (`a`, `b`, `c`, `a`, `b`, `c`).

    ///

    /// If `test` mode is `true` the runner is run in "test" mode, reporting the success or failure

    /// of each file on standard error. In addition to the test mode, a `progress_bar` designed for

    /// parallel run progression can be used. When the progress bar is displayed, it's wrapped with

    /// new lines at width `max_width`.

    ///

    /// `color` determines if color if used in standard error.

        // Worker are running on theirs own thread, while parallel runner is running in the main

        // thread.

        // We create the channel to communicate from workers to the parallel runner.

        // We create the channel to communicate from the parallel runner to the workers.

        // Create the workers:

        }

    }

    /// Runs a list of [`Job`] in parallel and returns the results.

    ///

    /// Results are returned ordered by the sequence number, and not their execution order. So, the

    /// order of the `jobs` is the same as the order of the `jobs` results, independently of the

    /// worker's count.

        // The parallel runner runs on the main thread. It's responsible for displaying standard

        // output and standard error. Workers are buffering their output and error in memory, and

        // delegate the display to the runners.

        // Create the jobs queue:

        // Initiate the runner, fill our workers:

            }

        // When dumped HTTP responses, we truncate existing output file on first save, then append

        // it on subsequent write.

        // Start the message pump:

                // If we have any error (either a [`WorkerMessage::IOError`] or a [`WorkerMessage::ParsingError`]

                // we don't take any more jobs and exit from the methods in error. This is the same

                // behaviour as when we run sequentially a list of Hurl files.

                }

                    // Like [`hurl::runner::run`] method, the display of parsing error is done here

                    // instead of being done in [`hurl::run_par`] method.

                }

                // Everything is OK, we report the progress. As we can receive a lot of running

                // messages, we don't want to update the progress bar too often to avoid flickering.

                    }

                }

                // A new job has been completed, we take a new job if the queue is not empty.

                // Contrary to when we receive a running message, we clear the progress bar no

                // matter what the frequency is, to get a "correct" and up-to-date display on any

                // test completion.

                    // The worker is becoming idle.

                    // First, we display the job standard error, then the job standard output

                    // (similar to the sequential runner).

                    }

                        }

                    }

                    // Then, we print job output on standard output (the first response truncates

                    // exiting file, subsequent response appends bytes).

                    // Report the completion of this job and update the progress.

                    );

                    // We want to force the next refresh of the progress bar (when we receive a

                    // running message) to be sure that the new next jobs will be printed. This

                    // is needed because we've a throttle on the progress bar refresh and not every

                    // running messages received leads to a progress bar refresh.

                    // We run the next job to process:

                        }

                        None => {

                            // If we have received all the job results, we can stop the run.

                                }

                            }

                        }

                    }

                }

            }

        }

        // We gracefully shut down workers, by dropping the sender and wait for each thread workers

        // to join.

            }

        }

        // All jobs have been executed, we sort results by sequence number to get the same order

        // as the input jobs list.

    }

    /// Prints a job `result` to standard output `stdout`, either as a raw HTTP response (last

    /// body of the run), or in a structured JSON way.

    /// If `append` is true, any existing file will be appended instead of being truncated.

            OutputType::ResponseBody {

            } => {

                    );

                        );

                    }

                }

            }

            OutputType::Json => {

                );

                }

            }

        }

    }

}