build.rs

// SPDX-FileCopyrightText: 2026 SOV710
//
// SPDX-License-Identifier: GPL-3.0-or-later

use std::env;
use std::fs;
use std::path::PathBuf;

use serde::Deserialize;

#[derive(Deserialize)]
struct WallpaperContract {
    protocol: ProtocolContract,
    renderer: RendererContract,
    decoder: DecoderContract,
}

#[derive(Deserialize)]
struct ProtocolContract {
    proto_version: String,
    topic: String,
}

#[derive(Deserialize)]
struct RendererContract {
    binary_name: String,
    client_name: String,
    client_version: String,
    layer_namespace: String,
}

#[derive(Deserialize)]
struct DecoderContract {
    software_backend: String,
    catalog: Vec<String>,
    default_order: Vec<String>,
}

fn main() {
    let manifest_path = PathBuf::from("protocol/wallpaper-contract.json");
    println!("cargo:rerun-if-changed={}", manifest_path.display());

    let manifest = fs::read_to_string(&manifest_path)
        .expect("failed to read protocol/wallpaper-contract.json");
    let contract: WallpaperContract =
        serde_json::from_str(&manifest).expect("failed to parse wallpaper contract JSON");

    if !contract
        .decoder
        .catalog
        .iter()
        .any(|entry| entry == &contract.decoder.software_backend)
    {
        panic!("wallpaper contract decoder catalog must contain the software backend");
    }

    for entry in &contract.decoder.default_order {
        if !contract
            .decoder
            .catalog
            .iter()
            .any(|candidate| candidate == entry)
        {
            panic!("wallpaper contract default_order contains backend outside catalog");
        }
    }

    if !contract
        .decoder
        .default_order
        .iter()
        .any(|entry| entry == &contract.decoder.software_backend)
    {
        panic!("wallpaper contract default_order must include the software backend");
    }

    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR missing"));
    let output_path = out_dir.join("wallpaper_contract.rs");

    let render_list = |items: &[String]| -> String {
        items
            .iter()
            .map(|item| format!("{item:?}"))
            .collect::<Vec<_>>()
            .join(", ")
    };

    let generated = format!(
        concat!(
            "// @generated by build.rs from protocol/wallpaper-contract.json\n",
            "pub const QSOV_PROTO_VERSION: &str = {:?};\n",
            "pub const WALLPAPER_TOPIC: &str = {:?};\n",
            "pub const WALLPAPER_RENDERER_BINARY: &str = {:?};\n",
            "pub const WALLPAPER_RENDERER_CLIENT_NAME: &str = {:?};\n",
            "pub const WALLPAPER_RENDERER_CLIENT_VERSION: &str = {:?};\n",
            "pub const WALLPAPER_LAYER_NAMESPACE: &str = {:?};\n",
            "pub const WALLPAPER_SOFTWARE_DECODE_BACKEND: &str = {:?};\n",
            "pub const WALLPAPER_DECODE_BACKEND_CATALOG: &[&str] = &[{}];\n",
            "pub const WALLPAPER_DEFAULT_DECODE_BACKEND_ORDER: &[&str] = &[{}];\n"
        ),
        contract.protocol.proto_version,
        contract.protocol.topic,
        contract.renderer.binary_name,
        contract.renderer.client_name,
        contract.renderer.client_version,
        contract.renderer.layer_namespace,
        contract.decoder.software_backend,
        render_list(&contract.decoder.catalog),
        render_list(&contract.decoder.default_order),
    );

    fs::write(output_path, generated).expect("failed to write generated wallpaper contract");
}