"unicode-width",

 "windows_i686_gnullvm",

inquire = { version = "0.7.4", default-features = false, features = ["crossterm", "editor"] }

pub use success;

use std::mem::ManuallyDrop;

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

use std::{fmt, io, thread, time};

use crate::io::{ERROR_PREFIX, WARNING_PREFIX};

use crate::Paint;

const CLEAR_UNTIL_NEWLINE: crossterm::terminal::Clear =

    crossterm::terminal::Clear(crossterm::terminal::ClearType::UntilNewLine);

struct Progress {

    state: State,

    message: Paint<String>,

}

impl Progress {

    fn new(message: Paint<String>) -> Self {

        Self {

            state: State::Running { cursor: 0 },

            message,

enum State {

    Running { cursor: usize },

    Canceled,

    Done,

    Warn,

    Error,

}

    progress: Arc<Mutex<Progress>>,

    handle: ManuallyDrop<thread::JoinHandle<()>>,

}

impl Drop for Spinner {

    fn drop(&mut self) {

        if let Ok(mut progress) = self.progress.lock() {

            if let State::Running { .. } = progress.state {

                progress.state = State::Canceled;

            }

        }

        unsafe { ManuallyDrop::take(&mut self.handle) }

            .join()

            .unwrap();

    }

        if let Ok(mut progress) = self.progress.lock() {

            progress.state = State::Done;

        }

        if let Ok(mut progress) = self.progress.lock() {

            progress.state = State::Error;

        }

        if let Ok(mut progress) = self.progress.lock() {

            progress.state = State::Error;

            progress.message = Paint::new(format!(

                "{} {} {}",

                progress.message,

                Paint::red("error:"),

                msg

            ));

        }

        if let Ok(mut progress) = self.progress.lock() {

            progress.state = State::Warn;

        }

        if let Ok(mut progress) = self.progress.lock() {

            progress.message = Paint::new(msg);

        }

    let (stdout, stderr) = (io::stdout(), io::stderr());

    if stderr.is_terminal() {

        spinner_to(message, stdout, stderr)

        spinner_to(message, stdout, io::sink())

    mut completion: impl io::Write + Send + 'static,

    mut animation: impl io::Write + Send + 'static,

    let message = message.to_string();

    let progress = Arc::new(Mutex::new(Progress::new(Paint::new(message))));

    #[cfg(unix)]

    let (sig_tx, sig_rx) = crossbeam_channel::unbounded();

    #[cfg(unix)]

    let sig_result = radicle_signals::install(sig_tx);

    let handle = thread::Builder::new()

        .name(String::from("spinner"))

        .spawn({

            let progress = progress.clone();

            move || {

                write!(animation, "{}", crossterm::cursor::Hide).ok();

                loop {

                    let Ok(mut progress) = progress.lock() else {

                        break;

                    };

                    // If were unable to install handles, skip signal processing entirely.

                    #[cfg(unix)]

                    if sig_result.is_ok() {

                        match sig_rx.try_recv() {

                            Ok(sig)

                                if sig == radicle_signals::Signal::Interrupt

                                    || sig == radicle_signals::Signal::Terminate =>

                            {

                                write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();

                                writeln!(

                                    completion,

                                    "{ERROR_PREFIX} {} {}",

                                    &progress.message,

                                    Paint::red("<canceled>")

                                )

                                .ok();

                                drop(animation);

                                std::process::exit(-1);

                            }

                            Ok(_) => {}

                            Err(_) => {}

                        }

                    }

                    match &mut *progress {

                        Progress {

                            state: State::Running { cursor },

                            message,

                        } => {

                            let spinner = DEFAULT_STYLE[*cursor];

                            write!(animation, "\r{CLEAR_UNTIL_NEWLINE}{spinner} {message}",).ok();

                            *cursor += 1;

                            *cursor %= DEFAULT_STYLE.len();

                        }

                        Progress {

                            state: State::Done,

                            message,

                        } => {

                            write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();

                            writeln!(completion, "{} {message}", Paint::green("✓")).ok();

                            break;

                        }

                        Progress {

                            state: State::Canceled,

                            message,

                        } => {

                            write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();

                            writeln!(

                                completion,

                                "{ERROR_PREFIX} {message} {}",

                                Paint::red("<canceled>")

                            )

                            .ok();

                            break;

                        }

                        Progress {

                            state: State::Warn,

                            message,

                        } => {

                            write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();

                            writeln!(completion, "{WARNING_PREFIX} {message}").ok();

                            break;

                        }

                        Progress {

                            state: State::Error,

                            message,

                        } => {

                            write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();

                            writeln!(completion, "{ERROR_PREFIX} {message}").ok();

                            break;

                        }

                    }

                    drop(progress);

                    thread::sleep(DEFAULT_TICK);

                }

                write!(animation, "{}", crossterm::cursor::Show).ok();

                #[cfg(unix)]

                if sig_result.is_ok() {

                    let _ = radicle_signals::uninstall();

                }

            }

        })

        // SAFETY: Only panics if the thread name contains `null` bytes, which isn't the case here.

        .unwrap();

    Spinner {

        progress,

        handle: ManuallyDrop::new(handle),

    }