use rkyv::{Archive, Deserialize, Serialize};

#[derive(Archive, Serialize, Deserialize)]
struct Person {
    name: String,
    age: u32,
    email: Option<String>,
    scores: Vec<u32>,
}

use rkyv_js_codegen::CodeGenerator;
use std::env;
use std::path::PathBuf;

fn main() {
    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());

    let mut codegen = CodeGenerator::new();

    codegen.set_header(
        "Generated TypeScript bindings from rkyv-js-codegen\n\
         These types match the Rust structs in src/lib.rs",
    );

    // Automatically extract all types annotated with #[derive(rkyv::Archive)]
    codegen.add_source_file(manifest_dir.join("src/lib.rs"))
        .expect("Failed to parse source file");

    // Write generated bindings
    codegen.write_to_file(out_dir.join("bindings.ts"))
        .expect("Failed to write bindings");

    println!("cargo:rerun-if-changed=src/lib.rs");
    println!("cargo:rerun-if-changed=build.rs");
}

use rkyv_js_codegen::CodeGenerator;

fn main() {
    let mut codegen = CodeGenerator::new();

    // Single file
    codegen.add_source_file("src/lib.rs").unwrap();

    // Or scan an entire directory recursively
    codegen.add_source_dir("src/").unwrap();

    // Or pass source code directly
    codegen.add_source_str(r#"
        use rkyv::Archive;

        #[derive(Archive)]
        struct Point { x: f64, y: f64 }
    "#);

    codegen.write_to_file("bindings.ts").unwrap();
}

use rkyv::Archive;
use std::collections::BTreeMap as MyMap;

#[derive(Archive)]
struct Config {
    data: MyMap<String, u32>,  // Resolved as std::collections::BTreeMap
}

use rkyv::Archive as Rkyv;

#[derive(Rkyv)]  // Recognized as rkyv::Archive
struct Point { x: f64, y: f64 }

use rkyv_js_codegen::{CodeGenerator, TypeDef};

let mut codegen = CodeGenerator::new();

// Register a custom type with a fully-qualified Rust path.
// {0}, {1} are placeholders for type parameters.
codegen.register_type("my_crate::CustomMap",
    TypeDef::new("customMap({0}, {1})", "Map<{0}, {1}>")
        .with_import("my-package/codecs", "customMap"),
);

// Now `my_crate::CustomMap<K, V>` (or a `use my_crate::CustomMap` alias)
// in source files will generate:
//   import { customMap } from 'my-package/codecs';
//   field: customMap(r.string, r.u32)

use rkyv_js_codegen::{CodeGenerator, TypeDef};

let mut codegen = CodeGenerator::new();

// Register a codec for the external type (use the fully-qualified path)
codegen.register_type("external::Coord",
    TypeDef::new("Coord", "Coord")
        .with_import("./coord.ts", "Coord"),
);

codegen.add_source_str(r#"
    use rkyv::Archive;

    // This proxy type is skipped by codegen
    #[derive(Archive)]
    #[rkyv(remote = external::Coord)]
    struct CoordDef {
        x: f32,
        y: f32,
    }

    #[derive(Archive)]
    struct Event {
        name: String,
        location: Coord,  // Uses the registered codec for external::Coord
    }
"#);

use rkyv_js_codegen::{CodeGenerator, TypeDef, EnumVariant};

let mut codegen = CodeGenerator::new();

codegen.add_struct("Person", &[
    ("name", TypeDef::string()),
    ("age", TypeDef::u32()),
    ("email", TypeDef::option(TypeDef::string())),
    ("scores", TypeDef::vec(TypeDef::u32())),
]);

codegen.add_enum("Status", &[
    EnumVariant::Unit("Pending".to_string()),
    EnumVariant::Unit("Active".to_string()),
    EnumVariant::Struct("Error".to_string(), vec![
        ("message".to_string(), TypeDef::string()),
    ]),
]);

codegen.write_to_file("bindings.ts").unwrap();