use hzbridge::config::Config;
use hzbridge::sink::PlaneSink;
use std::path::PathBuf;

fn main() {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("hzbridge=info"))
        .format_timestamp_micros()
        .init();

    let arguments = match parse_arguments() {
        Ok(a) => a,
        Err(detail) => {
            eprintln!("hzbridged: {detail}");
            std::process::exit(1);
        }
    };

    let config = match Config::from_path(&arguments.config_path) {
        Ok(c) => c,
        Err(error) => {
            eprintln!("hzbridged: {error}");
            std::process::exit(1);
        }
    };

    let sink: Box<dyn PlaneSink> = build_sink(&config, arguments.allow_null_sink);

    log::info!("fsm=Boot msg=starting name=hzbridge");
    let bridge = hzbridge::Bridge::new(config, sink);
    if let Err(error) = bridge.run() {
        hzbridge::blackbox::abort(&error.to_string());
    }
}

#[cfg(feature = "iceoryx2")]
fn build_sink(config: &Config, allow_null_sink: bool) -> Box<dyn PlaneSink> {
    if allow_null_sink {
        log::warn!("fsm=Boot msg=development_null_sink_enabled");
        return Box::new(hzbridge::sink::NullSink);
    }
    match hzbridge::sink_iceoryx2::Iceoryx2Sink::new(config) {
        Ok(sink) => {
            log::info!("fsm=Boot msg=iceoryx2_sink_ready");
            Box::new(sink)
        }
        Err(error) => {
            log::error!("fsm=Boot msg=iceoryx2_sink_failed error={error}");
            eprintln!("hzbridged: iceoryx2 sink failed: {error}");
            std::process::exit(1);
        }
    }
}

#[cfg(not(feature = "iceoryx2"))]
fn build_sink(_config: &Config, allow_null_sink: bool) -> Box<dyn PlaneSink> {
    if !allow_null_sink {
        eprintln!(
            "hzbridged: iceoryx2 feature disabled and no --allow-null-sink; \
             use --allow-null-sink only for wire/runtime smoke tests"
        );
        std::process::exit(1);
    }
    log::warn!("fsm=Boot msg=development_null_sink_enabled (iceoryx2 feature not available)");
    Box::new(hzbridge::sink::NullSink)
}

struct Arguments {
    config_path: PathBuf,
    allow_null_sink: bool,
}

fn parse_arguments() -> Result<Arguments, String> {
    let args: Vec<_> = std::env::args_os().skip(1).collect();
    match args.as_slice() {
        [flag, path] if flag == "--config" => Ok(Arguments {
            config_path: path.into(),
            allow_null_sink: false,
        }),
        [flag, path, allow] if flag == "--config" && allow == "--allow-null-sink" => {
            Ok(Arguments {
                config_path: path.into(),
                allow_null_sink: true,
            })
        }
        _ => Err("usage: hzbridged --config <path> [--allow-null-sink]".to_owned()),
    }
}