use ctor::{ctor, dtor};
use linkme::distributed_slice;
use std::sync::Once;

#[distributed_slice]
static CTORS: [fn()] = [..];

#[distributed_slice]
static DTORS: [fn()] = [..];

static INIT: Once = Once::new();
static DROP: Once = Once::new();

fn run_ctors() {
    INIT.call_once(|| {
        for linkme_ctor in CTORS {
            linkme_ctor();
        }
    });
}

fn run_dtors() {
    DROP.call_once(|| {
        for linkme_dtor in DTORS {
            linkme_dtor();
        }
    });
}

#[linkme::distributed_slice(CTORS)]
fn linkme_ctor() {
    println!("Hello from linkme");
}

#[linkme::distributed_slice(DTORS)]
fn linkme_dtor() {
    println!("Goodbye from linkme");
}

#[ctor]
unsafe fn ctor() {
    println!("Hello from ctor");
}

#[dtor]
unsafe fn dtor() {
    println!("Goodbye from ctor");
}

ctor_lite::ctor! {
    unsafe fn ctor_lite() {
        println!("Hello from ctor_lite");
    }
}

ctor_lite::dtor! {
    unsafe fn dtor_lite() {
        println!("Goodbye from ctor_lite");
    }
}

struct HelloPrinter;

impl HelloPrinter {
    pub fn print(self) {
        println!("Hello from printer");
    }
}

impl Drop for HelloPrinter {
    fn drop(&mut self) {
        println!("Goodbye from printer");
    }
}

fn main() {
    run_ctors();
    println!("Hello from main");
    let printer = HelloPrinter;
    printer.print();
    run_dtors();
}