use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

use anyhow::{Result, anyhow};
use clap::{CommandFactory, Parser};
use gitoxide_core as core;

use crate::{
    porcelain::options::{Args, Subcommands},
    shared::pretty::prepare_and_run,
};

pub fn main() -> Result<()> {
    let args: Args = Args::parse_from(gix::env::args_os());
    let should_interrupt = Arc::new(AtomicBool::new(false));
    #[expect(unsafe_code)]
    unsafe {
        // SAFETY: The closure doesn't use mutexes or memory allocation, so it should be safe to call from a signal handler.
        gix::interrupt::init_handler(1, {
            let should_interrupt = Arc::clone(&should_interrupt);
            move || should_interrupt.store(true, Ordering::SeqCst)
        })?;
    }
    let trace = false;
    let verbose = !args.quiet;
    let progress = args.progress;
    #[cfg(feature = "gitoxide-core-tools")]
    let threads = args.threads;
    let progress_keep_open = args.progress_keep_open;

    match args.cmd {
        #[cfg(debug_assertions)]
        Subcommands::Panic => prepare_and_run(
            "panic-behaviour",
            trace,
            verbose,
            progress,
            progress_keep_open,
            crate::shared::STANDARD_RANGE,
            move |_progress, _out, _err| panic!("something went very wrong"),
        ),
        Subcommands::Init { directory } => core::repository::init(directory).map(|_| ()),
        #[cfg(feature = "gitoxide-core-tools")]
        Subcommands::Tool(tool) => match tool {
            #[cfg(feature = "gitoxide-core-tools-query")]
            crate::porcelain::options::ToolCommands::Query(crate::porcelain::options::tools::Query {
                object_cache_size_mb,
                find_copies_harder,
                repo_dir,
                cmd,
            }) => {
                use gitoxide_core::query;
                prepare_and_run(
                    "query",
                    trace,
                    verbose,
                    progress,
                    progress_keep_open,
                    crate::shared::STANDARD_RANGE,
                    move |mut progress, out, err| {
                        let engine = query::prepare(
                            &repo_dir,
                            &mut progress,
                            &mut *err,
                            query::Options {
                                object_cache_size_mb,
                                find_copies_harder,
                                threads,
                            },
                        )?;
                        match cmd {
                            None => writeln!(err, "Choose a command for the query engine")?,
                            Some(crate::porcelain::options::tools::query::Command::TracePath { path }) => {
                                engine.run(
                                    query::Command::TracePath {
                                        spec: crate::shared::parse_pathspec_argument(path),
                                    },
                                    out,
                                    progress,
                                )?;
                            }
                        }
                        Ok(())
                    },
                )
            }
            crate::porcelain::options::ToolCommands::EstimateHours(
                crate::porcelain::options::tools::EstimateHours {
                    working_dir,
                    rev_spec,
                    no_bots,
                    file_stats,
                    line_stats,
                    show_pii,
                    omit_unify_identities,
                },
            ) => {
                use gitoxide_core::hours;
                prepare_and_run(
                    "estimate-hours",
                    trace,
                    verbose,
                    progress,
                    progress_keep_open,
                    crate::shared::STANDARD_RANGE,
                    move |progress, out, _err| {
                        hours::estimate(
                            &working_dir,
                            rev_spec.as_ref(),
                            progress,
                            hours::Context {
                                show_pii,
                                ignore_bots: no_bots,
                                threads,
                                file_stats,
                                line_stats,
                                omit_unify_identities,
                                out,
                            },
                        )
                    },
                )
            }
            crate::porcelain::options::ToolCommands::Find { root, debug } => {
                use gitoxide_core::organize;
                prepare_and_run(
                    "find",
                    trace,
                    verbose,
                    progress,
                    progress_keep_open,
                    crate::shared::STANDARD_RANGE,
                    move |progress, out, _err| {
                        organize::discover(
                            root.unwrap_or_else(|| [std::path::Component::CurDir].iter().collect()),
                            out,
                            progress,
                            debug,
                            threads,
                        )
                    },
                )
            }
            crate::porcelain::options::ToolCommands::Organize {
                destination_directory,
                execute,
                repository_source,
            } => {
                use gitoxide_core::organize;
                prepare_and_run(
                    "organize",
                    trace,
                    verbose,
                    progress,
                    progress_keep_open,
                    crate::shared::STANDARD_RANGE,
                    move |progress, _out, _err| {
                        organize::run(
                            if execute {
                                organize::Mode::Execute
                            } else {
                                organize::Mode::Simulate
                            },
                            repository_source.unwrap_or_else(|| [std::path::Component::CurDir].iter().collect()),
                            destination_directory.unwrap_or_else(|| [std::path::Component::CurDir].iter().collect()),
                            progress,
                            threads,
                        )
                    },
                )
            }
        },
        Subcommands::Completions { shell, out_dir } => {
            let mut app = Args::command();

            let shell = shell
                .or_else(clap_complete::Shell::from_env)
                .ok_or_else(|| anyhow!("The shell could not be derived from the environment"))?;

            let bin_name = app.get_name().to_owned();
            if let Some(out_dir) = out_dir {
                clap_complete::generate_to(shell, &mut app, bin_name, &out_dir)?;
            } else {
                clap_complete::generate(shell, &mut app, bin_name, &mut std::io::stdout());
            }
            Ok(())
        }
    }?;
    Ok(())
}