use std::io::IsTerminal;

use clap::Parser;

use clap_complete::ArgValueCompleter;

use dialoguer::Confirm;

use futures_util::SinkExt;

use tokio_stream::StreamExt;

use crate::{

    client::commands::{

        erroneous_server_response, print_authorization_owner_hint,

        read_password_from_stdin_with_double_check,

    },

    core::{

        completion::prefix_completer,

        protocol::{

            ClientToServerMessageStream, CreateUserError, Request, Response,

            print_create_users_output_status, print_create_users_output_status_json,

            print_set_password_output_status, request_validation::ValidationError,

        },

        types::MySQLUser,

    },

};

#[derive(Parser, Debug, Clone)]

pub struct CreateUserArgs {

    /// The `MySQL` user(s) to create

    #[arg(num_args = 1.., value_name = "USER_NAME")]

    #[cfg_attr(not(feature = "suid-sgid-mode"), arg(add = ArgValueCompleter::new(prefix_completer)))]

    username: Vec<MySQLUser>,

    /// Do not ask for a password, leave it unset

    #[clap(long)]

    no_password: bool,

    /// Print the information as JSON

    ///

    /// Note that this implies `--no-password`, since the command will become non-interactive.

    #[arg(short, long)]

    json: bool,

}

    if args.username.is_empty() {

        anyhow::bail!("No usernames provided");

    }

    let message = Request::CreateUsers(args.username.clone());

    if let Err(err) = server_connection.send(message).await {

        server_connection.close().await.ok();

        anyhow::bail!(anyhow::Error::from(err).context("Failed to communicate with server"));

    }

    let result = match server_connection.next().await {

        Some(Ok(Response::CreateUsers(result))) => result,

        response => return erroneous_server_response(response),

    };

    if args.json {

        print_create_users_output_status_json(&result);

    } else {

        print_create_users_output_status(&result);

        if result.iter().any(|(_, res)| {

            matches!(

                res,

                Err(CreateUserError::ValidationError(

                    ValidationError::AuthorizationError(_)

                ))

            )

        }) {

            print_authorization_owner_hint(&mut server_connection).await?;

        }

        let successfully_created_users = result

            .iter()

            .collect::<Vec<_>>();

        if !std::io::stdin().is_terminal()

            && !args.no_password

            && !successfully_created_users.is_empty()

        {

            anyhow::bail!(

                "Cannot prompt for passwords in non-interactive mode. Use --no-password to skip setting passwords."

            );

        }

        for username in successfully_created_users {

            if !args.no_password

                && Confirm::new()

                    .with_prompt(format!(

                        "Do you want to set a password for user '{username}'?"

                    ))

                    .default(false)

                    .interact()?

            {

                let password = read_password_from_stdin_with_double_check(username)?;

                let message = Request::PasswdUser((username.to_owned(), password));

                if let Err(err) = server_connection.send(message).await {

                    server_connection.close().await.ok();

                    anyhow::bail!(err);

                }

                match server_connection.next().await {

                    Some(Ok(Response::SetUserPassword(result))) => {

                        print_set_password_output_status(&result, username);

                    }

                    response => return erroneous_server_response(response),

                }

                println!();

            }

        }

    }

    server_connection.send(Request::Exit).await?;

    if result.values().any(std::result::Result::is_err) {

        std::process::exit(1);

    }

    Ok(())

}