xbp_cli/strategies/

deployment_config.rs

//! deployment configuration management module
//!
//! handles reading and writing deployment configurations
//! including xbp.yaml/xbp.json files and cli argument parsing
//! supports both legacy single service and new multi service formats
//! validates service configurations for duplicates and invalid targets

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value as JsonValue;
use std::collections::{BTreeMap, HashMap};
use std::fs;
use std::path::{Path, PathBuf};

use crate::config::{DiscordConfig, LinearConfig, ServiceDiscordConfig};
use crate::utils::{
    collapse_project_path, config_kind_from_path, find_xbp_config_upwards,
    maybe_auto_convert_legacy_xbp_json_to_yaml, parse_config_with_auto_heal,
    resolve_env_placeholders, resolve_project_config_write_path, resolve_project_dir,
    resolve_project_path,
};
use xbp_core::RunnerExecutionRuntime;

fn default_xbp_version() -> String {
    "0.1.0".to_string()
}

fn default_auto_push_on_commit() -> bool {
    true
}

/// Default GitHub release branch name template.
///
/// Placeholders (see [`validate_github_release_branch_naming_template`]):
/// `{VERSION}`, `{TAG}`, `{SERVICE_NAME}`, `${GITHUB_VERSION}`, `${GITHUB_TAG}`, `${SERVICE_NAME}`.
pub const DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE: &str =
    "releases/{SERVICE_NAME}-{VERSION}";

/// Human-readable list of supported placeholders for release branch naming templates.
pub const GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE_TOKENS: &str =
    "{VERSION} {TAG} {SERVICE_NAME}  ${GITHUB_VERSION} ${GITHUB_TAG} ${SERVICE_NAME}";

/// Validate a release-branch naming template before writing config or creating a branch.
///
/// Rules:
/// - non-empty, no whitespace
/// - every `{...}` / `${...}` token must be a known placeholder
/// - must include a version token so each release gets a distinct branch
pub fn validate_github_release_branch_naming_template(template: &str) -> Result<(), String> {
    let template = template.trim();
    if template.is_empty() {
        return Err("Release branch naming template must not be empty".to_string());
    }
    if template.chars().any(char::is_whitespace) {
        return Err("Release branch naming template must not contain whitespace".to_string());
    }

    let mut brace_tokens: Vec<String> = Vec::new();
    let mut dollar_tokens: Vec<String> = Vec::new();
    let bytes = template.as_bytes();
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'$' && i + 1 < bytes.len() && bytes[i + 1] == b'{' {
            let rest = &template[i + 2..];
            let Some(end) = rest.find('}') else {
                return Err(
                    "Unclosed ${...} placeholder in release branch naming template".to_string(),
                );
            };
            let name = &rest[..end];
            if name.is_empty() {
                return Err("Empty ${} placeholder in release branch naming template".to_string());
            }
            if !name
                .chars()
                .all(|c| c.is_ascii_alphanumeric() || c == '_')
            {
                return Err(format!(
                    "Invalid placeholder name ${{{name}}} in release branch naming template"
                ));
            }
            dollar_tokens.push(name.to_string());
            i += 2 + end + 1;
            continue;
        }
        if bytes[i] == b'{' {
            let rest = &template[i + 1..];
            let Some(end) = rest.find('}') else {
                return Err(
                    "Unclosed {...} placeholder in release branch naming template".to_string(),
                );
            };
            let name = &rest[..end];
            if name.is_empty() {
                return Err("Empty {} placeholder in release branch naming template".to_string());
            }
            if !name
                .chars()
                .all(|c| c.is_ascii_alphanumeric() || c == '_')
            {
                return Err(format!(
                    "Invalid placeholder name {{{name}}} in release branch naming template"
                ));
            }
            brace_tokens.push(name.to_string());
            i += 1 + end + 1;
            continue;
        }
        i += 1;
    }

    const BRACE_OK: &[&str] = &["VERSION", "TAG", "SERVICE_NAME"];
    const DOLLAR_OK: &[&str] = &["GITHUB_VERSION", "GITHUB_TAG", "SERVICE_NAME"];

    for token in &brace_tokens {
        if !BRACE_OK.contains(&token.as_str()) {
            return Err(format!(
                "Unknown template token {{{token}}}. Supported: {GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE_TOKENS}"
            ));
        }
    }
    for token in &dollar_tokens {
        if !DOLLAR_OK.contains(&token.as_str()) {
            return Err(format!(
                "Unknown template token ${{{token}}}. Supported: {GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE_TOKENS}"
            ));
        }
    }

    let has_version = brace_tokens.iter().any(|t| t == "VERSION" || t == "TAG")
        || dollar_tokens
            .iter()
            .any(|t| t == "GITHUB_VERSION" || t == "GITHUB_TAG");
    if !has_version {
        return Err(
            "Release branch naming template must include a version token ({VERSION}, {TAG}, ${GITHUB_VERSION}, or ${GITHUB_TAG})"
                .to_string(),
        );
    }

    Ok(())
}

/// One package under a multi-package monorepo publish provider.
///
/// Shared token / preflight / command settings live on the parent
/// [`PublishTargetConfig`]; each entry only needs identity + paths.
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
pub struct PublishPackageEntry {
    #[serde(default)]
    pub package_name: Option<String>,
    #[serde(default)]
    pub working_directory: Option<String>,
    #[serde(default)]
    pub manifest_path: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PublishTargetConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub package_name: Option<String>,
    #[serde(default)]
    pub working_directory: Option<String>,
    #[serde(default)]
    pub manifest_path: Option<String>,
    /// Extra monorepo packages that share this provider's token / command settings.
    ///
    /// When non-empty, each entry is published independently (npm packages and
    /// rust crates from the same repo). Legacy single-package configs keep using
    /// top-level `package_name` / `manifest_path` only.
    #[serde(default)]
    pub packages: Vec<PublishPackageEntry>,
    #[serde(default)]
    pub token: Option<String>,
    #[serde(default)]
    pub preflight_commands: Vec<String>,
    #[serde(default)]
    pub publish_command: Option<String>,
    #[serde(default)]
    pub use_wsl: Option<bool>,
    #[serde(default)]
    pub wsl_distribution: Option<String>,
    #[serde(default)]
    pub generate_npmrc: Option<bool>,
    #[serde(default)]
    pub access: Option<String>,
    /// Retry `cargo publish --no-verify` after local tarball verification fails (default true for crates).
    #[serde(default)]
    pub retry_no_verify: Option<bool>,
    /// Package names that always receive a `--no-verify` retry on publish failure (e.g. `athena_rs`).
    #[serde(default)]
    pub no_verify_retry_packages: Vec<String>,
    /// Seconds to wait for each published version to appear on the registry (default 180).
    #[serde(default)]
    pub visibility_timeout_seconds: Option<f64>,
    /// Poll interval while waiting for registry visibility (default 5).
    #[serde(default)]
    pub visibility_poll_seconds: Option<f64>,
}

impl PublishTargetConfig {
    /// Expand monorepo `packages[]` or fall back to the legacy single-package fields.
    pub fn package_entries(&self) -> Vec<PublishPackageEntry> {
        if !self.packages.is_empty() {
            return self.packages.clone();
        }
        if self.package_name.is_some()
            || self.manifest_path.is_some()
            || self.working_directory.is_some()
        {
            return vec![PublishPackageEntry {
                package_name: self.package_name.clone(),
                working_directory: self.working_directory.clone(),
                manifest_path: self.manifest_path.clone(),
            }];
        }
        // Empty entry still produces one target (detect name from default manifest).
        vec![PublishPackageEntry::default()]
    }

    /// Build a single-package clone with shared provider settings for one entry.
    pub fn for_package_entry(&self, entry: &PublishPackageEntry) -> Self {
        let mut clone = self.clone();
        clone.packages = Vec::new();
        if let Some(name) = entry
            .package_name
            .as_ref()
            .map(|s| s.trim())
            .filter(|s| !s.is_empty())
        {
            clone.package_name = Some(name.to_string());
        }
        if let Some(path) = entry
            .manifest_path
            .as_ref()
            .map(|s| s.trim())
            .filter(|s| !s.is_empty())
        {
            clone.manifest_path = Some(path.to_string());
        }
        if let Some(dir) = entry
            .working_directory
            .as_ref()
            .map(|s| s.trim())
            .filter(|s| !s.is_empty())
        {
            clone.working_directory = Some(dir.to_string());
        } else if let Some(manifest) = clone.manifest_path.as_deref() {
            let parent = std::path::Path::new(manifest)
                .parent()
                .map(|p| p.to_string_lossy().replace('\\', "/"))
                .filter(|p| !p.is_empty())
                .unwrap_or_else(|| ".".to_string());
            clone.working_directory = Some(parent);
        }
        clone
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PublishProjectConfig {
    #[serde(default)]
    pub npm: Option<PublishTargetConfig>,
    #[serde(default)]
    pub crates: Option<PublishTargetConfig>,
    /// cargo-dist binary packaging for GitHub release assets / installers.
    #[serde(default)]
    pub dist: Option<PublishDistConfig>,
}

/// Project-level cargo-dist settings used by `xbp version release`.
///
/// When `enabled` is true (or a `dist-workspace.toml` is present), release
/// builds host/global artifacts with the `dist` CLI and uploads them to the
/// GitHub release. Multi-platform targets beyond the host are expected from
/// generated GitHub Actions CI (`generate_ci`).
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PublishDistConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    /// Package names to ship (defaults to crates publish package_name / dist metadata).
    #[serde(default)]
    pub packages: Vec<String>,
    /// cargo-dist installers: shell, msi, powershell, npm, homebrew.
    #[serde(default)]
    pub installers: Vec<String>,
    /// Rust target triples. Empty keeps host-mode defaults for local builds.
    #[serde(default)]
    pub targets: Vec<String>,
    /// Artifact modes to run: host, local, global (default: host + global).
    #[serde(default, alias = "artifacts")]
    pub artifacts_modes: Vec<String>,
    /// Pass `--allow-dirty` to dist (default true during release ledgers).
    #[serde(default)]
    pub allow_dirty: Option<bool>,
    /// Run `dist generate --mode ci` when missing/out of date (default true).
    #[serde(default)]
    pub generate_ci: Option<bool>,
    /// Override dist CLI binary name (`dist` or `cargo-dist`).
    #[serde(default)]
    pub tool: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceCommands {
    #[serde(default)]
    pub pre: Option<String>,
    #[serde(default)]
    pub install: Option<String>,
    #[serde(default)]
    pub build: Option<String>,
    #[serde(default)]
    pub start: Option<String>,
    #[serde(default)]
    pub dev: Option<String>,
    /// Additional named commands such as `test`, `lint`, `check`, or `publish`.
    #[serde(default, flatten)]
    pub custom: BTreeMap<String, String>,
}

impl ServiceCommands {
    pub fn get(&self, name: &str) -> Option<&String> {
        match name {
            "pre" => self.pre.as_ref(),
            "install" => self.install.as_ref(),
            "build" => self.build.as_ref(),
            "start" => self.start.as_ref(),
            "dev" => self.dev.as_ref(),
            other => self.custom.get(other),
        }
    }

    pub fn available_names(&self) -> Vec<String> {
        let mut names = ["pre", "install", "build", "start", "dev"]
            .into_iter()
            .filter(|name| self.get(name).is_some_and(|value| !value.trim().is_empty()))
            .map(str::to_string)
            .collect::<Vec<_>>();
        names.extend(
            self.custom
                .iter()
                .filter(|(_, value)| !value.trim().is_empty())
                .map(|(name, _)| name.clone()),
        );
        names
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SystemdConfig {
    #[serde(default)]
    pub environment_files: Vec<String>,
    #[serde(default)]
    pub config_paths: Vec<String>,
    #[serde(default)]
    pub read_write_paths: Vec<String>,
    #[serde(default)]
    pub runtime_directories: Vec<String>,
    #[serde(default)]
    pub state_directories: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerDeployConfig {
    #[serde(default)]
    pub command: Option<String>,
    #[serde(default)]
    pub ci_script: Option<String>,
    #[serde(default)]
    pub select_script: Option<String>,
    /// Force OpenNext deploy through WSL on Windows (`true`/`false`).
    /// When unset, OpenNext apps auto-use WSL on Windows hosts.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub use_wsl: Option<bool>,
    /// Optional WSL distro name (`wsl -d <name>`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub wsl_distribution: Option<String>,
    /// Package script for OpenNext build (default: first of `cf:build`, `build:worker`,
    /// or `node scripts/opennext-cloudflare.mjs build` when present).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub build_script: Option<String>,
    /// Run `pnpm install --ignore-scripts` when node_modules is incomplete (default true for OpenNext).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub install_ignore_scripts: Option<bool>,
    /// Restore `@heroui-pro/react` dist from `~/.heroui/cache` when postinstall is a stub (default true for OpenNext).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub restore_heroui_cache: Option<bool>,
    /// Extra wrangler args after `deploy` (OpenNext default: `--keep-vars --autoconfig=false`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub wrangler_args: Option<Vec<String>>,
    /// Env vars that must be present locally before install/build (hard fail).
    /// Merged with auto-detected build requirements (e.g. HEROUI_AUTH_TOKEN for HeroUI Pro).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub build_required_env: Vec<String>,
    /// Package.json script to run as a fast preflight before install/build
    /// (defaults: `predeploy`, `xbp:preflight`, `test:deploy` when present).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preflight_script: Option<String>,
    /// When true, wrangler `secrets.required` missing locally hard-fail doctor/deploy
    /// (default false: runtime secrets may already live on the Worker).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub require_local_secrets: Option<bool>,
    /// Prefer local Docker/OpenNext builds over remote-only paths (default true).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefer_local_build: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerContainerConfig {
    #[serde(default)]
    pub class_name: Option<String>,
    #[serde(default)]
    pub binding: Option<String>,
    #[serde(default)]
    pub dockerfile: Option<String>,
    #[serde(default)]
    pub port: Option<u16>,
    #[serde(default)]
    pub application_id: Option<String>,
    #[serde(default)]
    pub healthcheck_path: Option<String>,
    #[serde(default)]
    pub health_urls: Vec<String>,
    #[serde(default)]
    pub expected_image_name: Option<String>,
    #[serde(default)]
    pub image_tag_keep_count: Option<usize>,
    #[serde(default)]
    pub allow_unchanged_container_image: bool,
    #[serde(default)]
    pub required_secrets: Vec<String>,
    #[serde(default)]
    pub version_var: Option<String>,
    #[serde(default)]
    pub instance_name_template: Option<String>,
    #[serde(default)]
    pub default_rollout: Option<String>,
    /// Wrangler Containers image reference. XBP's legacy `container` shape
    /// remains supported; this field is used by the typed `containers` list.
    #[serde(default)]
    pub image: Option<String>,
    #[serde(default)]
    pub build_context: Option<String>,
    #[serde(default)]
    pub instance_type: Option<String>,
    #[serde(default)]
    pub max_instances: Option<u32>,
    #[serde(default)]
    pub rollout_active_grace_period: Option<u32>,
    #[serde(default)]
    pub rollout_step_percentage: Vec<u8>,
    #[serde(default)]
    pub regions: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerDurableObjectBinding {
    pub name: String,
    pub class_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub script_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub environment: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerDurableObjectMigration {
    pub tag: String,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub new_classes: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub new_sqlite_classes: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerDurableObjectNamespace {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub script: Option<String>,
    #[serde(rename = "class", alias = "class_name")]
    pub class_name: String,
    #[serde(default)]
    pub use_sqlite: bool,
    #[serde(default)]
    pub use_containers: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WorkerDurableObjectsConfig {
    #[serde(default)]
    pub bindings: Vec<WorkerDurableObjectBinding>,
    #[serde(default)]
    pub migrations: Vec<WorkerDurableObjectMigration>,
    #[serde(default)]
    pub namespaces: Vec<WorkerDurableObjectNamespace>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkerConfig {
    pub name: String,
    pub root: String,
    #[serde(default)]
    pub script_name: Option<String>,
    #[serde(default)]
    pub service: Option<String>,
    #[serde(default)]
    pub deploy: Option<WorkerDeployConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container: Option<WorkerContainerConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<WorkerContainerConfig>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable_objects: Option<WorkerDurableObjectsConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct VersionDomainSurfaceConfig {
    pub kind: String,
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marker: Option<String>,
    #[serde(default)]
    pub packages: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct VersionDomainConfig {
    pub name: String,
    pub root: String,
    pub version: String,
    #[serde(default)]
    pub owned_package_names: Vec<String>,
    #[serde(default)]
    pub owned_package_prefixes: Vec<String>,
    #[serde(default)]
    pub version_surfaces: Vec<VersionDomainSurfaceConfig>,
    #[serde(default)]
    pub allowed_bumps: Vec<String>,
    #[serde(default)]
    pub validation_commands: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image_version_probe: Option<String>,
    #[serde(default)]
    pub live_health_urls: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cloudflare_app: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatabaseConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub backend: Option<String>,
    #[serde(default)]
    pub url_env: Option<String>,
    #[serde(default)]
    pub key_env: Option<String>,
    #[serde(default)]
    pub schema: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenApiOutputsConfig {
    #[serde(default)]
    pub yaml: Option<String>,
    #[serde(default)]
    pub json: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenApiServiceDefaultsConfig {
    #[serde(default)]
    pub spec_version: Option<String>,
    #[serde(default)]
    pub strict: Option<bool>,
    #[serde(default)]
    pub source_roots: Option<Vec<String>>,
    #[serde(default)]
    pub outputs: Option<OpenApiOutputsConfig>,
    #[serde(default)]
    pub unknown_schema: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenApiAggregateConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub outputs: Option<OpenApiOutputsConfig>,
    #[serde(default)]
    pub overlay: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProjectOpenApiConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub auto_detect_services: Option<bool>,
    #[serde(default)]
    pub generate_on_release: Option<bool>,
    #[serde(default)]
    pub service_defaults: Option<OpenApiServiceDefaultsConfig>,
    #[serde(default)]
    pub aggregate: Option<OpenApiAggregateConfig>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenApiLocalServerConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub scheme: Option<String>,
    #[serde(default)]
    pub host: Option<String>,
    #[serde(default)]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenApiServerDerivationConfig {
    #[serde(default)]
    pub from_service_url: Option<bool>,
    #[serde(default)]
    pub service_url_description: Option<String>,
    #[serde(default)]
    pub local: Option<OpenApiLocalServerConfig>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OpenApiWebSocketRouteConfig {
    pub path: String,
    #[serde(default)]
    pub client_message_schema: Option<String>,
    #[serde(default)]
    pub server_message_schema: Option<String>,
    #[serde(default)]
    pub message_format: Option<String>,
    #[serde(default)]
    pub server_sends_first: Option<bool>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ServiceOpenApiConfig {
    #[serde(default)]
    pub enabled: Option<bool>,
    #[serde(default)]
    pub framework: Option<String>,
    #[serde(default)]
    pub spec_version: Option<String>,
    #[serde(default)]
    pub strict: Option<bool>,
    #[serde(default)]
    pub source_roots: Option<Vec<String>>,
    #[serde(default)]
    pub outputs: Option<OpenApiOutputsConfig>,
    #[serde(default)]
    pub unknown_schema: Option<String>,
    #[serde(default)]
    pub overlay: Option<String>,
    #[serde(default)]
    pub aggregate_path_prefix: Option<String>,
    #[serde(default)]
    pub server_derivation: Option<OpenApiServerDerivationConfig>,
    #[serde(default)]
    pub websocket_routes: Option<Vec<OpenApiWebSocketRouteConfig>>,
}

/// Project-level OCI registry defaults (`oci:` in xbp.yaml).
///
/// Image coordinates for GHCR-style registries:
/// `{default_registry}/{owner}/{image_name}`.
///
/// `owner` / `repository` may differ from the app source repo (`github.repository`)
/// when packages live under another GitHub org or a dedicated package repository.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct OciProjectConfig {
    #[serde(default)]
    pub registries: HashMap<String, OciRegistryConfig>,
    #[serde(default)]
    pub default_registry: Option<String>,
    /// GitHub org/user (or registry namespace) used when composing image paths.
    /// Example: `xylex-group` → `ghcr.io/xylex-group/<service>`.
    #[serde(default, alias = "github_owner")]
    pub owner: Option<String>,
    /// Optional package-linked GitHub repository (`owner/repo`).
    /// Used to derive [`Self::owner`] when `owner` is unset, and as documentation
    /// for where OCI packages are published / permission-linked.
    /// May differ from `github.repository` (source code repo).
    #[serde(default, alias = "github_repository", alias = "package_repository")]
    pub repository: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct OciRegistryConfig {
    #[serde(default)]
    pub provider: Option<String>,
    #[serde(default)]
    pub username: Option<String>,
    #[serde(default)]
    pub token_source: Option<String>,
    #[serde(default)]
    pub url: Option<String>,
}

/// Extract `owner` from `owner/repo` (GitHub-style). Returns `None` for empty or single-segment.
pub fn github_owner_from_repository_ref(repository: &str) -> Option<String> {
    let repo = repository.trim().trim_matches('/');
    if repo.is_empty() || !repo.contains('/') {
        return None;
    }
    let owner = repo.split('/').next()?.trim();
    if owner.is_empty() || owner.contains(':') {
        return None;
    }
    Some(owner.to_string())
}

/// True when `image` already looks like a fully-qualified registry path
/// (`ghcr.io/org/name`, `registry.example.com:5000/ns/img`, …).
pub fn is_absolute_oci_image_ref(image: &str) -> bool {
    let image = image.trim();
    if image.is_empty() {
        return false;
    }
    // Digest or tag suffix does not affect host detection.
    let path = image.split('@').next().unwrap_or(image);
    let path = path.split(':').next().unwrap_or(path);
    let parts: Vec<&str> = path.split('/').filter(|p| !p.is_empty()).collect();
    if parts.len() < 2 {
        return false;
    }
    let host = parts[0];
    host.contains('.') || host.contains(':') || host == "localhost"
}

/// Resolve the OCI/GitHub namespace (owner) for image compose + auth hints.
///
/// Preference:
/// 1. `oci.owner`
/// 2. owner segment of `oci.repository`
/// 3. `oci.registries.<default_registry>.username`
/// 4. owner of `github.repository` (source repo)
/// 5. `project_name` (last resort; may be scoped npm names — prefer explicit owner)
pub fn resolve_oci_image_owner(
    oci: Option<&OciProjectConfig>,
    github_repository: Option<&str>,
    project_name: &str,
) -> Option<String> {
    if let Some(oci) = oci {
        if let Some(owner) = oci
            .owner
            .as_deref()
            .map(str::trim)
            .filter(|s| !s.is_empty())
        {
            return Some(owner.to_string());
        }
        if let Some(owner) = oci
            .repository
            .as_deref()
            .and_then(github_owner_from_repository_ref)
        {
            return Some(owner);
        }
        if let Some(registry) = oci
            .default_registry
            .as_deref()
            .map(str::trim)
            .filter(|s| !s.is_empty())
        {
            if let Some(user) = oci
                .registries
                .get(registry)
                .and_then(|r| r.username.as_deref())
                .map(str::trim)
                .filter(|s| !s.is_empty())
            {
                return Some(user.to_string());
            }
        }
        // Any registry username as weak fallback.
        if let Some(user) = oci.registries.values().find_map(|r| {
            r.username
                .as_deref()
                .map(str::trim)
                .filter(|s| !s.is_empty())
        }) {
            return Some(user.to_string());
        }
    }
    if let Some(owner) = github_repository.and_then(github_owner_from_repository_ref) {
        return Some(owner);
    }
    let pn = project_name.trim().trim_start_matches('@');
    let pn = pn.split('/').next().unwrap_or(pn).trim();
    if pn.is_empty() {
        None
    } else {
        Some(pn.to_string())
    }
}

/// Compose the image repository path (no tag) for a service.
///
/// - Absolute `service_image` → returned as-is (trimmed, tag/digest stripped only if
///   callers pass a bare path; full refs with tags are preserved by using the path
///   before the last `:` only when host-shaped — here we keep the string as given
///   when absolute).
/// - Relative / missing → `{registry}/{owner}/{name}` where `name` is the relative
///   image or `service_name`.
pub fn compose_service_oci_image(
    oci: Option<&OciProjectConfig>,
    github_repository: Option<&str>,
    project_name: &str,
    service_name: &str,
    service_image: Option<&str>,
) -> Option<String> {
    if let Some(img) = service_image.map(str::trim).filter(|s| !s.is_empty()) {
        if is_absolute_oci_image_ref(img) {
            return Some(img.to_string());
        }
    }

    let registry = oci
        .and_then(|o| o.default_registry.as_deref())
        .map(str::trim)
        .filter(|s| !s.is_empty())?;
    let owner = resolve_oci_image_owner(oci, github_repository, project_name)?;
    let name = service_image
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .unwrap_or(service_name)
        .trim()
        .trim_matches('/');
    // Relative image may be `ns/name` — still place under registry/owner only when
    // single segment; multi-segment relative keeps as `{registry}/{relative}`.
    if name.contains('/') {
        return Some(format!("{registry}/{name}"));
    }
    if name.is_empty() {
        return None;
    }
    Some(format!("{registry}/{owner}/{name}"))
}

/// Per-service OCI image settings (`services[].oci`).
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceOciConfig {
    #[serde(default)]
    pub image: Option<String>,
    #[serde(default)]
    pub tag: Option<String>,
    #[serde(default)]
    pub tag_from: Option<String>,
    #[serde(default)]
    pub dockerfile: Option<String>,
    #[serde(default)]
    pub context: Option<String>,
    #[serde(default)]
    pub platforms: Vec<String>,
    #[serde(default)]
    pub build_args: HashMap<String, String>,
}

/// Project-level Kubernetes defaults (`kubernetes:` in xbp.yaml).
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct KubernetesProjectConfig {
    #[serde(default)]
    pub default_context: Option<String>,
    #[serde(default)]
    pub default_namespace: Option<String>,
    #[serde(default)]
    pub require_context_confirmation_for_apply: Option<bool>,
    #[serde(default)]
    pub kubeconfig: Option<String>,
}

/// Project-level deploy defaults and groups (`deploy:` in xbp.yaml).
///
/// Primary deployable units remain `services[]`. This block only holds shared
/// defaults and named groups for `xbp deploy <group>`.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DeployProjectConfig {
    #[serde(default)]
    pub default_env: Option<String>,
    #[serde(default)]
    pub history_dir: Option<String>,
    #[serde(default)]
    pub lock_file: Option<String>,
    #[serde(default)]
    pub groups: HashMap<String, DeployGroupConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DeployGroupConfig {
    #[serde(default)]
    pub services: Vec<String>,
    #[serde(default)]
    pub order: Vec<String>,
    #[serde(default)]
    pub description: Option<String>,
}

/// Per-service deploy orchestration (`services[].deploy`).
/// Distinct from `commands.deploy` (a local lifecycle script name).
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployConfig {
    /// Default provider when `--to` is omitted and `destinations` is empty:
    /// `kubernetes`, `kubernetes-operator`, `cloudflare-containers`, `worker`, `local`, …
    ///
    /// When `destinations` is non-empty, the default is **every enabled destination**
    /// (multi-target: e.g. Cloudflare Worker+Container and Kubernetes together).
    #[serde(default)]
    pub provider: Option<String>,
    /// Cloudflare worker app name (`workers[].name`). Defaults to service name.
    #[serde(default)]
    pub worker: Option<String>,
    /// Cloudflare containers rollout (`immediate` | `gradual`).
    #[serde(default)]
    pub rollout: Option<String>,
    /// Named destinations for multi-target deploy.
    ///
    /// ```toml
    /// [services.deploy]
    /// provider = "cloudflare-containers"
    /// worker = "athena-auth"
    ///
    /// [services.deploy.destinations.kubernetes]
    /// provider = "kubernetes"
    ///
    /// [services.deploy.destinations.cloudflare]
    /// provider = "cloudflare-containers"
    /// worker = "athena-auth"
    /// rollout = "immediate"
    /// ```
    ///
    /// Then: `xbp deploy athena-auth --run` ships both; narrow with
    /// `--to cloudflare` / `--to kubernetes` / expand with `--to all`.
    #[serde(default)]
    pub destinations: HashMap<String, ServiceDeployDestinationConfig>,
    #[serde(default)]
    pub envs: HashMap<String, ServiceDeployEnvConfig>,
}

/// One entry under `services[].deploy.destinations.<name>`.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployDestinationConfig {
    #[serde(default)]
    pub provider: Option<String>,
    #[serde(default)]
    pub worker: Option<String>,
    #[serde(default)]
    pub rollout: Option<String>,
    #[serde(default)]
    pub enabled: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployEnvConfig {
    #[serde(default)]
    pub namespace: Option<String>,
    #[serde(default)]
    pub replicas: Option<u32>,
    #[serde(default)]
    pub health: Vec<String>,
    #[serde(default)]
    pub kubernetes: Option<ServiceDeployKubernetesConfig>,
    /// Explicit env key/values for this deploy env (supports `${VAR}` placeholders).
    /// Merged over `env_files` and `services[].environment`.
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub env: HashMap<String, String>,
    /// Dotenv-style files relative to project or service root (e.g. `.env`, `.env.production`).
    /// When empty, deploy auto-loads existing `.env`, `.env.{env}`, `.env.local` if present.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub env_files: Vec<String>,
    /// Files to mount into the container as a ConfigMap (e.g. `config.yaml` → `/app/config.yaml`).
    /// When empty, auto-includes `config.yaml` / `config.yml` if present at project or service root.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub config_files: Vec<String>,
    /// Container listen port for bootstrap Service/Deployment (default 8080).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container_port: Option<u16>,
    /// Keys that must be non-empty after compose (fail deploy or interactive prompt).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub required_env: Vec<String>,
    /// Public Service type, local port-forward, and optional DNS hosts.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expose: Option<ServiceDeployExposeConfig>,
}

/// `services[].deploy.envs.<env>.expose` — map Service → public/local access.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployExposeConfig {
    /// `ClusterIP` | `NodePort` | `LoadBalancer` (bootstrap Service.spec.type).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service_type: Option<String>,
    /// Fixed NodePort when type is NodePort.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub node_port: Option<u16>,
    /// Pod hostPort (docker-desktop convenience).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host_port: Option<u16>,
    /// localhost port for kubectl port-forward (defaults to container_port).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub local_port: Option<u16>,
    /// Auto port-forward after rollout (default: true when local_port is set).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port_forward: Option<bool>,
    /// Hostnames written to the OS hosts file → 127.0.0.1 (with port-forward).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub dns_hosts: Vec<String>,
    /// `hosts` (default), `none`, or `cloudflare`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dns_mode: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployKubernetesConfig {
    #[serde(default)]
    pub manifests: Option<ServiceDeployManifestsConfig>,
    #[serde(default)]
    pub workload: Option<String>,
    #[serde(default)]
    pub service: Option<String>,
    #[serde(default)]
    pub crds_path: Option<String>,
    #[serde(default)]
    pub install_path: Option<String>,
    #[serde(default)]
    pub selector: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ServiceDeployManifestsConfig {
    #[serde(default)]
    pub base: Option<String>,
    #[serde(default)]
    pub overlay: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct ServiceConfig {
    pub name: String,
    pub target: String,
    /// When `true`, discovery / generate-config must not overwrite `target`
    /// (e.g. Dockerfile detection flipping `nextjs` → `docker`). Default `false`.
    #[serde(
        default,
        skip_serializing_if = "is_false_or_none",
        alias = "freeze_target",
        alias = "target_frozen"
    )]
    pub target_freeze: Option<bool>,
    pub branch: String,
    pub port: u16,
    #[serde(default)]
    pub root_directory: Option<String>,
    #[serde(default)]
    pub environment: Option<HashMap<String, String>>,
    #[serde(default)]
    pub url: Option<String>,
    #[serde(default)]
    pub healthcheck_path: Option<String>,
    #[serde(default)]
    pub restart_policy: Option<String>,
    #[serde(default)]
    pub restart_policy_max_failure_count: Option<u32>,
    #[serde(default)]
    pub start_wrapper: Option<String>,
    #[serde(default)]
    pub commands: Option<ServiceCommands>,
    #[serde(default)]
    pub force_run_from_root: Option<bool>,
    #[serde(default)]
    pub version_targets: Option<Vec<String>>,
    /// Optional deploy-time dependency edges for service graph ordering.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub depends_on: Option<Vec<String>>,
    /// Path prefixes that, when dirty, mark this service as a version-bump candidate.
    /// Isolates multi-service dirty worktrees so each service versions independently.
    #[serde(default)]
    pub watch_paths: Option<Vec<String>>,
    /// When `false`, exclude this service from version bumps and release scopes.
    /// Defaults to enabled when omitted. Aliases: `versioning_enabled`, `enable_versioning`.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        alias = "versioning_enabled",
        alias = "enable_versioning"
    )]
    pub versioning: Option<bool>,
    /// When `false`, exclude this service from `xbp version release` (bumps may still run).
    /// Defaults to enabled when omitted. Requires `versioning` to remain enabled.
    /// Aliases: `release_enabled`, `enable_release`.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        alias = "release_enabled",
        alias = "enable_release"
    )]
    pub release: Option<bool>,
    #[serde(default)]
    pub systemd_service_name: Option<String>,
    #[serde(default)]
    pub systemd: Option<SystemdConfig>,
    #[serde(default)]
    pub openapi: Option<ServiceOpenApiConfig>,
    /// Optional OCI image settings for deploy/OCI flows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oci: Option<ServiceOciConfig>,
    /// Optional deploy orchestration (provider + envs). Not `commands.deploy`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deploy: Option<ServiceDeployConfig>,
    /// Optional per-service Discord notification overrides.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discord: Option<ServiceDiscordConfig>,
    /// Per-service path/extension → bump-kind associations (override project `versioning`).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub file_associations: Vec<VersionFileAssociation>,
}

/// One glob pattern → suggested bump kind for `xbp version bump`.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct VersionFileAssociation {
    /// Glob against repo-relative paths (`**/*.md`, `docs/**`, `README.md`, `**/sql/**`).
    pub pattern: String,
    /// `patch`, `minor`, or `major`.
    pub bump: String,
}

/// Project-level versioning defaults and file associations.
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
pub struct VersioningProjectConfig {
    /// Default bump when no association/history match (`patch` | `minor` | `major`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_bump: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub file_associations: Vec<VersionFileAssociation>,
}

fn is_false_or_none(value: &Option<bool>) -> bool {
    !value.unwrap_or(false)
}

impl ServiceConfig {
    /// Whether this service participates in version bumps / dirty-tree versioning.
    pub fn is_versioning_enabled(&self) -> bool {
        self.versioning.unwrap_or(true)
    }

    /// Whether this service may be released (`xbp version release`).
    /// Release is always off when versioning is disabled.
    pub fn is_release_enabled(&self) -> bool {
        self.is_versioning_enabled() && self.release.unwrap_or(true)
    }

    /// When true, auto-discovery must not replace `target` from filesystem detection.
    pub fn is_target_frozen(&self) -> bool {
        self.target_freeze.unwrap_or(false)
    }
}

fn resolve_systemd_fields(
    systemd_service_name: Option<String>,
    systemd: Option<JsonValue>,
) -> Result<(Option<String>, Option<SystemdConfig>), String> {
    match systemd {
        None | Some(JsonValue::Null) => Ok((systemd_service_name, None)),
        Some(JsonValue::String(name)) => {
            let resolved_name = if systemd_service_name
                .as_ref()
                .is_some_and(|value| !value.trim().is_empty())
            {
                systemd_service_name
            } else if name.is_empty() {
                None
            } else {
                Some(name)
            };
            Ok((resolved_name, None))
        }
        Some(value) => {
            let config: SystemdConfig = serde_json::from_value(value)
                .map_err(|error| format!("invalid systemd config: {error}"))?;
            Ok((systemd_service_name, Some(config)))
        }
    }
}

fn deserialize_service_config<'de, D>(deserializer: D) -> Result<ServiceConfig, D::Error>
where
    D: Deserializer<'de>,
{
    #[derive(Deserialize)]
    struct ServiceConfigRaw {
        name: String,
        target: String,
        #[serde(default, alias = "freeze_target", alias = "target_frozen")]
        target_freeze: Option<bool>,
        branch: String,
        port: u16,
        #[serde(default)]
        root_directory: Option<String>,
        #[serde(default)]
        environment: Option<HashMap<String, String>>,
        #[serde(default)]
        url: Option<String>,
        #[serde(default)]
        healthcheck_path: Option<String>,
        #[serde(default)]
        restart_policy: Option<String>,
        #[serde(default)]
        restart_policy_max_failure_count: Option<u32>,
        #[serde(default)]
        start_wrapper: Option<String>,
        #[serde(default)]
        commands: Option<ServiceCommands>,
        #[serde(default)]
        force_run_from_root: Option<bool>,
        #[serde(default)]
        version_targets: Option<Vec<String>>,
        #[serde(default)]
        depends_on: Option<Vec<String>>,
        #[serde(default)]
        watch_paths: Option<Vec<String>>,
        #[serde(default, alias = "versioning_enabled", alias = "enable_versioning")]
        versioning: Option<bool>,
        #[serde(default, alias = "release_enabled", alias = "enable_release")]
        release: Option<bool>,
        #[serde(default)]
        systemd_service_name: Option<String>,
        #[serde(default)]
        systemd: Option<JsonValue>,
        #[serde(default)]
        openapi: Option<ServiceOpenApiConfig>,
        #[serde(default)]
        oci: Option<ServiceOciConfig>,
        #[serde(default)]
        deploy: Option<ServiceDeployConfig>,
        #[serde(default)]
        discord: Option<ServiceDiscordConfig>,
        #[serde(default)]
        file_associations: Vec<VersionFileAssociation>,
    }

    let raw = ServiceConfigRaw::deserialize(deserializer)?;
    let (systemd_service_name, systemd) =
        resolve_systemd_fields(raw.systemd_service_name, raw.systemd)
            .map_err(serde::de::Error::custom)?;

    Ok(ServiceConfig {
        name: raw.name,
        target: raw.target,
        target_freeze: raw.target_freeze,
        branch: raw.branch,
        port: raw.port,
        root_directory: raw.root_directory,
        environment: raw.environment,
        url: raw.url,
        healthcheck_path: raw.healthcheck_path,
        restart_policy: raw.restart_policy,
        restart_policy_max_failure_count: raw.restart_policy_max_failure_count,
        start_wrapper: raw.start_wrapper,
        commands: raw.commands,
        force_run_from_root: raw.force_run_from_root,
        version_targets: raw.version_targets,
        depends_on: raw.depends_on,
        watch_paths: raw.watch_paths,
        versioning: raw.versioning,
        release: raw.release,
        systemd_service_name,
        systemd,
        openapi: raw.openapi,
        oci: raw.oci,
        deploy: raw.deploy,
        discord: raw.discord,
        file_associations: raw.file_associations,
    })
}

impl<'de> Deserialize<'de> for ServiceConfig {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserialize_service_config(deserializer)
    }
}

#[derive(Debug, Clone, Serialize)]
pub struct XbpConfig {
    pub project_name: String,
    #[serde(default = "default_xbp_version")]
    pub version: String,
    pub port: u16,
    pub build_dir: String,
    #[serde(default)]
    pub app_type: Option<String>,
    #[serde(default)]
    pub build_command: Option<String>,
    #[serde(default)]
    pub start_command: Option<String>,
    #[serde(default)]
    pub install_command: Option<String>,
    #[serde(default)]
    pub environment: Option<HashMap<String, String>>,
    #[serde(default)]
    pub services: Option<Vec<ServiceConfig>>,
    #[serde(default)]
    pub openapi: Option<ProjectOpenApiConfig>,
    #[serde(default)]
    pub workers: Option<Vec<WorkerConfig>>,
    #[serde(default)]
    pub systemd_service_name: Option<String>,
    #[serde(default)]
    pub systemd: Option<SystemdConfig>,
    #[serde(default)]
    pub kafka_brokers: Option<String>,
    #[serde(default)]
    pub kafka_topic: Option<String>,
    #[serde(default)]
    pub kafka_public_url: Option<String>,
    #[serde(default)]
    pub log_files: Option<Vec<String>>,
    #[serde(default)]
    pub monitor_url: Option<String>,
    #[serde(default)]
    pub monitor_method: Option<String>,
    #[serde(default)]
    pub monitor_expected_code: Option<u16>,
    #[serde(default)]
    pub monitor_interval: Option<u64>,
    #[serde(default)]
    pub database: Option<DatabaseConfig>,
    /// Project-level OCI registry credentials / defaults.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oci: Option<OciProjectConfig>,
    /// Project-level Kubernetes defaults for deploy providers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kubernetes: Option<KubernetesProjectConfig>,
    /// Project-level deploy defaults and named service groups.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deploy: Option<DeployProjectConfig>,
    // Legacy fields for backward compatibility
    #[serde(default)]
    pub target: Option<String>,
    #[serde(default)]
    pub branch: Option<String>,
    #[serde(default)]
    pub crate_name: Option<String>,
    #[serde(default)]
    pub npm_script: Option<String>,
    #[serde(default)]
    pub port_storybook: Option<u16>,
    #[serde(default)]
    pub url: Option<String>,
    #[serde(default)]
    pub url_storybook: Option<String>,
    #[serde(default)]
    pub linear: Option<LinearConfig>,
    #[serde(default)]
    pub github: Option<GitHubProjectConfig>,
    #[serde(default)]
    pub publish: Option<PublishProjectConfig>,
    #[serde(default)]
    pub version_targets: Vec<String>,
    #[serde(default)]
    pub version_domains: Vec<VersionDomainConfig>,
    /// Project-relative ignore patterns (gitignore-style subset).
    ///
    /// Also loaded from `.xbp/.xbpignore` and optional root `.xbpignore`.
    /// Used to skip service discovery roots and version-target discovery.
    /// Does **not** silence worktree-watch activity; use `watch_ignore_paths` for that.
    #[serde(default, alias = "ignored_paths", alias = "xbpignore")]
    pub ignore_paths: Vec<String>,
    /// Worktree-watch-only ignore patterns (gitignore-style subset).
    /// Does not affect service discovery. Aliases: `watch_ignore`.
    #[serde(default, alias = "watch_ignore")]
    pub watch_ignore_paths: Vec<String>,
    /// Service names or root directories (globs allowed) excluded from version bumps.
    /// Also applied on top of per-service `versioning: false`.
    #[serde(
        default,
        alias = "disabled_versioning_services",
        alias = "no_version_services",
        alias = "versioning_disabled_services"
    )]
    pub versioning_disabled: Vec<String>,
    /// Service names or root directories (globs allowed) excluded from releases.
    /// Also applied on top of per-service `release: false`.
    #[serde(
        default,
        alias = "disabled_release_services",
        alias = "no_release_services",
        alias = "release_disabled_services"
    )]
    pub release_disabled: Vec<String>,
    /// Project-level version bump defaults and path → kind associations.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub versioning: Option<VersioningProjectConfig>,
    /// Project Discord webhook + per-event notification toggles.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discord: Option<DiscordConfig>,
    /// Static analysis / `xbp audit errors` configuration (language-agnostic).
    #[serde(default, skip_serializing_if = "Option::is_none", alias = "analysis")]
    pub audit: Option<AuditProjectConfig>,
}

/// Project-level config for `xbp audit` (also parsed by `xbp-analysis` config adapter).
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct AuditProjectConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub languages: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rules: Option<AuditRulesConfig>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub path_exclusions: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub generated_exclusions: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_severity: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub adapters: Option<JsonValue>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct AuditRulesConfig {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub enabled: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub disabled: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_severity: Option<String>,
}

fn deserialize_xbp_config<'de, D>(deserializer: D) -> Result<XbpConfig, D::Error>
where
    D: Deserializer<'de>,
{
    let mut value = JsonValue::deserialize(deserializer)?;
    let _ = crate::utils::normalize_xbp_config_value(&mut value);
    XbpConfigBody::deserialize(value)
        .map(Into::into)
        .map_err(serde::de::Error::custom)
}

#[derive(Deserialize)]
struct XbpConfigBody {
    project_name: String,
    #[serde(default = "default_xbp_version")]
    version: String,
    port: u16,
    build_dir: String,
    #[serde(default)]
    app_type: Option<String>,
    #[serde(default)]
    build_command: Option<String>,
    #[serde(default)]
    start_command: Option<String>,
    #[serde(default)]
    install_command: Option<String>,
    #[serde(default)]
    environment: Option<HashMap<String, String>>,
    #[serde(default)]
    services: Option<Vec<ServiceConfig>>,
    #[serde(default)]
    openapi: Option<ProjectOpenApiConfig>,
    #[serde(default)]
    workers: Option<Vec<WorkerConfig>>,
    #[serde(default)]
    systemd_service_name: Option<String>,
    #[serde(default)]
    systemd: Option<SystemdConfig>,
    #[serde(default)]
    kafka_brokers: Option<String>,
    #[serde(default)]
    kafka_topic: Option<String>,
    #[serde(default)]
    kafka_public_url: Option<String>,
    #[serde(default)]
    log_files: Option<Vec<String>>,
    #[serde(default)]
    monitor_url: Option<String>,
    #[serde(default)]
    monitor_method: Option<String>,
    #[serde(default)]
    monitor_expected_code: Option<u16>,
    #[serde(default)]
    monitor_interval: Option<u64>,
    #[serde(default)]
    database: Option<DatabaseConfig>,
    #[serde(default)]
    oci: Option<OciProjectConfig>,
    #[serde(default)]
    kubernetes: Option<KubernetesProjectConfig>,
    #[serde(default)]
    deploy: Option<DeployProjectConfig>,
    #[serde(default)]
    target: Option<String>,
    #[serde(default)]
    branch: Option<String>,
    #[serde(default)]
    crate_name: Option<String>,
    #[serde(default)]
    npm_script: Option<String>,
    #[serde(default)]
    port_storybook: Option<u16>,
    #[serde(default)]
    url: Option<String>,
    #[serde(default)]
    url_storybook: Option<String>,
    #[serde(default)]
    linear: Option<LinearConfig>,
    #[serde(default)]
    github: Option<GitHubProjectConfig>,
    #[serde(default)]
    publish: Option<PublishProjectConfig>,
    #[serde(default)]
    version_targets: Vec<String>,
    #[serde(default)]
    version_domains: Vec<VersionDomainConfig>,
    #[serde(default, alias = "ignored_paths", alias = "xbpignore")]
    ignore_paths: Vec<String>,
    #[serde(default, alias = "watch_ignore")]
    watch_ignore_paths: Vec<String>,
    #[serde(
        default,
        alias = "disabled_versioning_services",
        alias = "no_version_services",
        alias = "versioning_disabled_services"
    )]
    versioning_disabled: Vec<String>,
    #[serde(
        default,
        alias = "disabled_release_services",
        alias = "no_release_services",
        alias = "release_disabled_services"
    )]
    release_disabled: Vec<String>,
    #[serde(default)]
    versioning: Option<VersioningProjectConfig>,
    #[serde(default)]
    discord: Option<DiscordConfig>,
    #[serde(default, alias = "analysis")]
    audit: Option<AuditProjectConfig>,
}

impl From<XbpConfigBody> for XbpConfig {
    fn from(body: XbpConfigBody) -> Self {
        Self {
            project_name: body.project_name,
            version: body.version,
            port: body.port,
            build_dir: body.build_dir,
            app_type: body.app_type,
            build_command: body.build_command,
            start_command: body.start_command,
            install_command: body.install_command,
            environment: body.environment,
            services: body.services,
            openapi: body.openapi,
            workers: body.workers,
            systemd_service_name: body.systemd_service_name,
            systemd: body.systemd,
            kafka_brokers: body.kafka_brokers,
            kafka_topic: body.kafka_topic,
            kafka_public_url: body.kafka_public_url,
            log_files: body.log_files,
            monitor_url: body.monitor_url,
            monitor_method: body.monitor_method,
            monitor_expected_code: body.monitor_expected_code,
            monitor_interval: body.monitor_interval,
            database: body.database,
            oci: body.oci,
            kubernetes: body.kubernetes,
            deploy: body.deploy,
            target: body.target,
            branch: body.branch,
            crate_name: body.crate_name,
            npm_script: body.npm_script,
            port_storybook: body.port_storybook,
            url: body.url,
            url_storybook: body.url_storybook,
            linear: body.linear,
            github: body.github,
            publish: body.publish,
            version_targets: body.version_targets,
            version_domains: body.version_domains,
            ignore_paths: body.ignore_paths,
            watch_ignore_paths: body.watch_ignore_paths,
            versioning_disabled: body.versioning_disabled,
            release_disabled: body.release_disabled,
            versioning: body.versioning,
            discord: body.discord,
            audit: body.audit,
        }
    }
}

/// Match a service name or root directory against project-level disable patterns.
/// Patterns support `*` wildcards within a single segment and `**` across segments
/// via simple glob rules (`foo`, `apps/*`, `packages/**`).
pub fn service_matches_disable_pattern(service: &ServiceConfig, pattern: &str) -> bool {
    let pattern = pattern.trim().replace('\\', "/");
    if pattern.is_empty() {
        return false;
    }
    let name = service.name.trim();
    if glob_simple_match(&pattern, name) {
        return true;
    }
    if let Some(root) = service.root_directory.as_deref() {
        let normalized = root
            .replace('\\', "/")
            .trim_start_matches("./")
            .trim_matches('/')
            .to_string();
        if !normalized.is_empty() && glob_simple_match(&pattern, &normalized) {
            return true;
        }
    }
    false
}

pub fn service_matches_any_disable_pattern(service: &ServiceConfig, patterns: &[String]) -> bool {
    patterns
        .iter()
        .any(|pattern| service_matches_disable_pattern(service, pattern))
}

/// Whether a configured service should participate in version bumps / scopes.
pub fn service_versioning_allowed(config: &XbpConfig, service: &ServiceConfig) -> bool {
    service.is_versioning_enabled()
        && !service_matches_any_disable_pattern(service, &config.versioning_disabled)
}

/// Whether a configured service should participate in releases.
pub fn service_release_allowed(config: &XbpConfig, service: &ServiceConfig) -> bool {
    service.is_release_enabled()
        && service_versioning_allowed(config, service)
        && !service_matches_any_disable_pattern(service, &config.release_disabled)
}

/// Match a repo-relative path against a versioning association pattern.
/// Supports `*`, `**`, `{a,b}` brace groups, and basename-only patterns like `README.md`.
pub fn path_matches_association_pattern(pattern: &str, path: &str) -> bool {
    let pattern = pattern.trim().replace('\\', "/");
    let path = path.replace('\\', "/");
    let path = path.trim_start_matches("./").trim_matches('/');
    if pattern.is_empty() {
        return false;
    }
    if let Some((prefix, rest)) = pattern.split_once('{') {
        if let Some((choices, suffix)) = rest.split_once('}') {
            return choices.split(',').any(|choice| {
                let expanded = format!("{prefix}{}{suffix}", choice.trim());
                path_matches_association_pattern(&expanded, path)
            });
        }
    }
    if glob_simple_match(&pattern, path) {
        return true;
    }
    if !pattern.contains('/') {
        if let Some(name) = path.rsplit('/').next() {
            return glob_simple_match(&pattern, name);
        }
    }
    false
}

pub fn parse_bump_kind_label(value: &str) -> Option<&'static str> {
    match value.trim().to_ascii_lowercase().as_str() {
        "patch" => Some("patch"),
        "minor" => Some("minor"),
        "major" => Some("major"),
        _ => None,
    }
}

fn glob_simple_match(pattern: &str, value: &str) -> bool {
    let pattern = pattern.trim_matches('/');
    let value = value.trim_matches('/');
    if pattern == value {
        return true;
    }
    if pattern == "*" || pattern == "**" {
        return true;
    }
    // Case-insensitive exact for bare names.
    if !pattern.contains('*') && !pattern.contains('/') {
        return pattern.eq_ignore_ascii_case(value)
            || value
                .split('/')
                .any(|segment| segment.eq_ignore_ascii_case(pattern));
    }

    let pattern_parts: Vec<&str> = pattern.split('/').filter(|p| !p.is_empty()).collect();
    let value_parts: Vec<&str> = value.split('/').filter(|p| !p.is_empty()).collect();
    glob_parts_match(&pattern_parts, &value_parts)
}

fn glob_parts_match(pattern: &[&str], value: &[&str]) -> bool {
    match (pattern.first().copied(), value.first().copied()) {
        (None, None) => true,
        (Some("**"), _) => {
            if glob_parts_match(&pattern[1..], value) {
                return true;
            }
            if value.is_empty() {
                return false;
            }
            glob_parts_match(pattern, &value[1..])
        }
        (Some(pat), Some(seg)) => {
            if segment_star_match(pat, seg) {
                glob_parts_match(&pattern[1..], &value[1..])
            } else {
                false
            }
        }
        _ => false,
    }
}

fn segment_star_match(pattern: &str, segment: &str) -> bool {
    if pattern == "*" {
        return true;
    }
    if !pattern.contains('*') {
        return pattern.eq_ignore_ascii_case(segment);
    }
    let parts: Vec<&str> = pattern.split('*').collect();
    let lower = segment.to_ascii_lowercase();
    let mut rest = lower.as_str();
    for (index, part) in parts.iter().enumerate() {
        let part_l = part.to_ascii_lowercase();
        if part_l.is_empty() {
            continue;
        }
        if index == 0 {
            if !rest.starts_with(&part_l) {
                return false;
            }
            rest = &rest[part_l.len()..];
            continue;
        }
        if index == parts.len() - 1 {
            return rest.ends_with(&part_l);
        }
        if let Some(pos) = rest.find(&part_l) {
            rest = &rest[pos + part_l.len()..];
        } else {
            return false;
        }
    }
    true
}

impl<'de> Deserialize<'de> for XbpConfig {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserialize_xbp_config(deserializer)
    }
}

#[derive(Debug, Clone)]
pub struct GitHubProjectConfig {
    pub repository: Option<String>,
    pub auto_push_on_commit: bool,
    pub release_branch: Option<GitHubReleaseBranchConfig>,
    pub runners: Option<GitHubRunnersProjectConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct GitHubProjectConfigObject {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    repository: Option<String>,
    #[serde(
        default = "default_auto_push_on_commit",
        skip_serializing_if = "github_auto_push_on_commit_is_default"
    )]
    auto_push_on_commit: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    release_branch: Option<GitHubReleaseBranchConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    runners: Option<GitHubRunnersProjectConfig>,
}

fn github_auto_push_on_commit_is_default(value: &bool) -> bool {
    *value
}

impl Default for GitHubProjectConfig {
    fn default() -> Self {
        Self {
            repository: None,
            auto_push_on_commit: default_auto_push_on_commit(),
            release_branch: None,
            runners: None,
        }
    }
}

impl Serialize for GitHubProjectConfig {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        if let Some(repository) = &self.repository {
            if self.auto_push_on_commit && self.release_branch.is_none() && self.runners.is_none() {
                return serializer.serialize_str(repository);
            }
        }

        GitHubProjectConfigObject {
            repository: self.repository.clone(),
            auto_push_on_commit: self.auto_push_on_commit,
            release_branch: self.release_branch.clone(),
            runners: self.runners.clone(),
        }
        .serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for GitHubProjectConfig {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum Repr {
            Repository(String),
            Config(GitHubProjectConfigObject),
        }

        match Repr::deserialize(deserializer)? {
            Repr::Repository(repository) => Ok(Self {
                repository: Some(repository),
                ..Self::default()
            }),
            Repr::Config(config) => Ok(Self {
                repository: config.repository,
                auto_push_on_commit: config.auto_push_on_commit,
                release_branch: config.release_branch,
                runners: config.runners,
            }),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GitHubRunnersProjectConfig {
    #[serde(default)]
    pub default_organization: Option<String>,
    #[serde(default)]
    pub default_runner_group: Option<String>,
    #[serde(default)]
    pub visibility: Option<String>,
    #[serde(default)]
    pub default_labels: Vec<String>,
    #[serde(default)]
    pub preferred_runtime: Option<RunnerExecutionRuntime>,
    #[serde(default)]
    pub work_directory: Option<String>,
    #[serde(default)]
    pub templates: Vec<GitHubRunnerTemplateConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GitHubRunnerTemplateConfig {
    #[serde(default)]
    pub name: Option<String>,
    #[serde(default)]
    pub runner_group: Option<String>,
    #[serde(default)]
    pub labels: Vec<String>,
    #[serde(default)]
    pub runtime: Option<RunnerExecutionRuntime>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GitHubReleaseBranchConfig {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default, alias = "template")]
    pub naming_template: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GitHubReleaseBranchSettings {
    pub naming_template: String,
}

#[derive(Debug, Clone)]
pub struct DeploymentConfig {
    pub app_name: String,
    pub port: u16,
    pub app_dir: PathBuf,
    pub build_command: Option<String>,
    pub start_command: Option<String>,
    pub install_command: Option<String>,
    pub environment: HashMap<String, String>,
}

pub fn normalize_config_paths_for_persistence(
    config: &mut XbpConfig,
    project_root: &std::path::Path,
) {
    config.build_dir = collapse_project_path(project_root, &config.build_dir);
    if let Some(publish) = &mut config.publish {
        for target in [&mut publish.npm, &mut publish.crates]
            .into_iter()
            .flatten()
        {
            if let Some(working_directory) = &target.working_directory {
                target.working_directory =
                    Some(collapse_project_path(project_root, working_directory));
            }
            if let Some(manifest_path) = &target.manifest_path {
                target.manifest_path = Some(collapse_project_path(project_root, manifest_path));
            }
            for entry in &mut target.packages {
                if let Some(working_directory) = &entry.working_directory {
                    entry.working_directory =
                        Some(collapse_project_path(project_root, working_directory));
                }
                if let Some(manifest_path) = &entry.manifest_path {
                    entry.manifest_path =
                        Some(collapse_project_path(project_root, manifest_path));
                }
            }
        }
    }
    for target in &mut config.version_targets {
        *target = collapse_project_path(project_root, target);
    }
    for domain in &mut config.version_domains {
        domain.root = collapse_project_path(project_root, &domain.root);
        for surface in &mut domain.version_surfaces {
            surface.path = collapse_project_path(project_root, &surface.path);
        }
    }
    if let Some(services) = &mut config.services {
        for service in services {
            if let Some(root_directory) = &service.root_directory {
                service.root_directory = Some(collapse_project_path(project_root, root_directory));
            }
            if let Some(version_targets) = &mut service.version_targets {
                for target in version_targets {
                    *target = collapse_project_path(project_root, target);
                }
            }
            if let Some(watch_paths) = &mut service.watch_paths {
                for path in watch_paths {
                    *path = collapse_project_path(project_root, path);
                }
            }
        }
    }
    if let Some(workers) = &mut config.workers {
        for worker in workers {
            let original_worker_root = PathBuf::from(&worker.root);
            if let Some(container) = &mut worker.container {
                normalize_worker_container_paths(project_root, &original_worker_root, container);
            }
            worker.root = collapse_project_path(project_root, &worker.root);
        }
    }
}

pub fn resolve_config_paths_for_runtime(config: &mut XbpConfig, project_root: &std::path::Path) {
    // build_dir / service roots must point at real directories; remap stale
    // absolute paths from other machines (e.g. Linux /home/... on Windows).
    config.build_dir = resolve_project_dir(project_root, &config.build_dir);
    if let Some(publish) = &mut config.publish {
        for target in [&mut publish.npm, &mut publish.crates]
            .into_iter()
            .flatten()
        {
            if let Some(working_directory) = &target.working_directory {
                target.working_directory =
                    Some(resolve_project_path(project_root, working_directory));
            }
            if let Some(manifest_path) = &target.manifest_path {
                target.manifest_path = Some(resolve_project_path(project_root, manifest_path));
            }
            for entry in &mut target.packages {
                if let Some(working_directory) = &entry.working_directory {
                    entry.working_directory =
                        Some(resolve_project_path(project_root, working_directory));
                }
                if let Some(manifest_path) = &entry.manifest_path {
                    entry.manifest_path =
                        Some(resolve_project_path(project_root, manifest_path));
                }
            }
        }
    }
    for target in &mut config.version_targets {
        *target = resolve_project_path(project_root, target);
    }
    for domain in &mut config.version_domains {
        domain.root = resolve_project_path(project_root, &domain.root);
        for surface in &mut domain.version_surfaces {
            surface.path = resolve_project_path(project_root, &surface.path);
        }
    }
    if let Some(services) = &mut config.services {
        for service in services {
            if let Some(root_directory) = &service.root_directory {
                service.root_directory = Some(resolve_project_dir(project_root, root_directory));
            }
            if let Some(version_targets) = &mut service.version_targets {
                for target in version_targets {
                    *target = resolve_project_path(project_root, target);
                }
            }
            if let Some(watch_paths) = &mut service.watch_paths {
                for path in watch_paths {
                    *path = resolve_project_path(project_root, path);
                }
            }
        }
    }
    if let Some(workers) = &mut config.workers {
        for worker in workers {
            worker.root = resolve_project_path(project_root, &worker.root);
            if let Some(container) = &mut worker.container {
                resolve_worker_container_paths(Path::new(&worker.root), container);
            }
        }
    }
}

fn normalize_worker_container_paths(
    project_root: &Path,
    worker_root: &Path,
    container: &mut WorkerContainerConfig,
) {
    let Some(dockerfile) = container.dockerfile.as_ref() else {
        return;
    };
    let dockerfile_path = PathBuf::from(dockerfile);
    if !dockerfile_path.is_absolute() {
        return;
    }

    if let Ok(relative) = dockerfile_path.strip_prefix(worker_root) {
        let rendered = relative.to_string_lossy().replace('\\', "/");
        container.dockerfile = Some(if rendered.is_empty() {
            "Dockerfile".to_string()
        } else {
            rendered
        });
        return;
    }

    container.dockerfile = Some(collapse_project_path(project_root, dockerfile));
}

fn resolve_worker_container_paths(worker_root: &Path, container: &mut WorkerContainerConfig) {
    let Some(dockerfile) = container.dockerfile.as_ref() else {
        return;
    };
    if PathBuf::from(dockerfile).is_absolute() {
        return;
    }
    container.dockerfile = Some(worker_root.join(dockerfile).to_string_lossy().to_string());
}

impl XbpConfig {
    pub fn auto_push_on_commit_enabled(&self) -> bool {
        self.github
            .as_ref()
            .map(|config| config.auto_push_on_commit)
            .unwrap_or(true)
    }

    pub fn github_release_branch_settings(&self) -> Option<GitHubReleaseBranchSettings> {
        let release_branch = self
            .github
            .as_ref()
            .and_then(|config| config.release_branch.as_ref())?;
        if !release_branch.enabled {
            return None;
        }

        let naming_template = release_branch
            .naming_template
            .as_deref()
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .unwrap_or(DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE)
            .to_string();

        Some(GitHubReleaseBranchSettings { naming_template })
    }
}

impl DeploymentConfig {
    /// Create deployment config from CLI arguments and xbp config fallback
    pub async fn from_args_or_config(
        app_name: Option<String>,
        port: Option<u16>,
        app_dir: Option<PathBuf>,
        config_path: Option<PathBuf>,
    ) -> Result<Self, String> {
        // Try to load from xbp config if not all args provided
        let xbp_config = if app_name.is_none() || port.is_none() || app_dir.is_none() {
            Self::load_xbp_config(config_path).await.ok()
        } else {
            None
        };

        let app_name = app_name
            .or_else(|| xbp_config.as_ref().map(|c| c.project_name.clone()))
            .ok_or("Missing app name")?;

        let port = port
            .or_else(|| xbp_config.as_ref().map(|c| c.port))
            .ok_or("Missing port")?;

        let app_dir = app_dir
            .or_else(|| xbp_config.as_ref().map(|c| PathBuf::from(&c.build_dir)))
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());

        let app_dir = app_dir
            .canonicalize()
            .map_err(|e| format!("Failed to resolve app directory: {}", e))?;

        // Get build/start commands from config if available
        let build_command = xbp_config.as_ref().and_then(|c| c.build_command.clone());
        let start_command = xbp_config.as_ref().and_then(|c| c.start_command.clone());
        let install_command = xbp_config.as_ref().and_then(|c| c.install_command.clone());
        let environment = xbp_config
            .as_ref()
            .and_then(|c| c.environment.clone())
            .unwrap_or_default();
        let environment = resolve_env_placeholders(&app_dir, &environment);

        Ok(DeploymentConfig {
            app_name,
            port,
            app_dir,
            build_command,
            start_command,
            install_command,
            environment,
        })
    }

    /// Load xbp configuration from file (with service validation).
    pub async fn load_xbp_config(config_path: Option<PathBuf>) -> Result<XbpConfig, String> {
        Self::load_xbp_config_with_options(config_path, true).await
    }

    /// Load xbp configuration without service validation.
    ///
    /// Use this for metadata-only reads (release tags, Linear settings, etc.) where
    /// deploy-time constraints such as unique ports must not block the command.
    pub async fn load_xbp_config_lenient(
        config_path: Option<PathBuf>,
    ) -> Result<XbpConfig, String> {
        Self::load_xbp_config_with_options(config_path, false).await
    }

    /// Load xbp configuration from file.
    ///
    /// When `validate_services` is true, rejects configs with duplicate names/ports/URLs
    /// or empty service targets. Set false for non-deploy command paths.
    pub async fn load_xbp_config_with_options(
        config_path: Option<PathBuf>,
        validate_services_cfg: bool,
    ) -> Result<XbpConfig, String> {
        let cwd = std::env::current_dir().unwrap_or_default();

        let (project_root, resolved_path, resolved_kind) = if let Some(p) = config_path.clone() {
            let root = p
                .parent()
                .map(|parent| {
                    if parent.file_name() == Some(std::ffi::OsStr::new(".xbp")) {
                        parent
                            .parent()
                            .map(std::path::Path::to_path_buf)
                            .unwrap_or_else(|| parent.to_path_buf())
                    } else {
                        parent.to_path_buf()
                    }
                })
                .unwrap_or_else(|| cwd.clone());
            (root, p, "auto")
        } else {
            let found = find_xbp_config_upwards(&cwd)
                .ok_or_else(|| "Configuration file not found".to_string())?;
            (found.project_root, found.config_path, found.kind)
        };

        let _ = maybe_auto_convert_legacy_xbp_json_to_yaml(&project_root, &resolved_path);

        let (config_path, kind) = (resolved_path, resolved_kind);

        let content = fs::read_to_string(&config_path)
            .map_err(|e| format!("Failed to read config: {}", e))?;

        let effective_kind = match kind {
            "yaml" | "json" | "jsonc" | "toml" => kind,
            _ => config_kind_from_path(&config_path)?,
        };

        let (mut config, healed_content): (XbpConfig, Option<String>) =
            parse_config_with_auto_heal(&content, effective_kind).map_err(|e| {
                format!("Failed to parse {effective_kind} config: {e}")
            })?;

        if let Some(healed_content) = healed_content {
            let _ = fs::write(&config_path, healed_content);
        }

        resolve_config_paths_for_runtime(&mut config, &project_root);

        // Validate services if present (deploy-time constraints; skip for metadata-only loads)
        if validate_services_cfg {
            if let Some(services) = &config.services {
                validate_services(services)?;
            }
        }

        Ok(config)
    }

    /// Save updated configuration back to project config files (any supported format).
    pub async fn save_xbp_config(&self, config_path: Option<PathBuf>) -> Result<(), String> {
        let found = find_xbp_config_upwards(&self.app_dir);
        let primary_path = config_path.unwrap_or_else(|| {
            resolve_project_config_write_path(&self.app_dir, found.as_ref())
        });

        let mut xbp_config = XbpConfig {
            project_name: self.app_name.clone(),
            version: default_xbp_version(),
            port: self.port,
            build_dir: self.app_dir.to_string_lossy().to_string(),
            app_type: None,
            build_command: self.build_command.clone(),
            start_command: self.start_command.clone(),
            install_command: self.install_command.clone(),
            environment: if self.environment.is_empty() {
                None
            } else {
                Some(self.environment.clone())
            },
            services: None,
            openapi: None,
            workers: None,
            systemd_service_name: None,
            systemd: None,
            kafka_brokers: None,
            kafka_topic: None,
            kafka_public_url: None,
            log_files: None,
            monitor_url: None,
            monitor_method: None,
            monitor_expected_code: None,
            monitor_interval: None,
            database: None,
            oci: None,
            kubernetes: None,
            deploy: None,
            target: None,
            branch: None,
            crate_name: None,
            npm_script: None,
            port_storybook: None,
            url: None,
            url_storybook: None,
            linear: None,
            github: None,
            publish: None,
            version_targets: Vec::new(),
            version_domains: Vec::new(),
            ignore_paths: Vec::new(),
            watch_ignore_paths: Vec::new(),
            versioning_disabled: Vec::new(),
            release_disabled: Vec::new(),
            versioning: None,
            discord: None,
        audit: None,
        };

        normalize_config_paths_for_persistence(&mut xbp_config, &self.app_dir);

        crate::utils::write_xbp_project_config_at_path(&primary_path, &xbp_config)?;

        // Keep a sibling xbp.json in sync only if it already exists and is not the primary file.
        let sibling_json = primary_path
            .parent()
            .map(|p| p.join("xbp.json"))
            .unwrap_or_else(|| self.app_dir.join(".xbp").join("xbp.json"));
        if sibling_json.exists() && sibling_json != primary_path {
            crate::utils::write_xbp_project_config_at_path(&sibling_json, &xbp_config).map_err(
                |e| {
                    format!(
                        "Failed to sync sibling JSON config {}: {e}",
                        sibling_json.display()
                    )
                },
            )?;
        }

        Ok(())
    }

    /// Update port in the configuration
    pub fn update_port(&mut self, new_port: u16) {
        self.port = new_port;
    }

    /// Merge with deployment recommendations from project detection
    pub fn merge_with_recommendations(
        &mut self,
        recommendations: &super::project_detector::DeploymentRecommendations,
    ) {
        // Use recommendations if not already set
        if self.build_command.is_none() {
            self.build_command = recommendations.build_command.clone();
        }

        if self.start_command.is_none() {
            self.start_command = recommendations.start_command.clone();
        }

        if self.install_command.is_none() {
            self.install_command = recommendations.install_command.clone();
        }

        // Use recommended process name if app_name is generic
        if let Some(recommended_name) = &recommendations.process_name {
            if self.app_name == "app" || self.app_name == "unknown" {
                self.app_name = recommended_name.clone();
            }
        }
    }
}

/// Validate services configuration
pub fn validate_services(services: &[ServiceConfig]) -> Result<(), String> {
    let mut names = std::collections::HashSet::new();
    let mut ports = std::collections::HashSet::new();
    let mut urls = std::collections::HashSet::new();

    for service in services {
        // Check for duplicate names
        if !names.insert(&service.name) {
            return Err(format!("Duplicate service name found: {}", service.name));
        }

        // Check for duplicate ports
        if !ports.insert(service.port) {
            return Err(format!("Duplicate port found: {}", service.port));
        }

        // Check for duplicate URLs
        if let Some(url) = &service.url {
            if !urls.insert(url) {
                return Err(format!("Duplicate URL found: {}", url));
            }
        }

        // Validate target
        if service.target.trim().is_empty() {
            return Err(format!(
                "Service '{}' is missing a target. Set it to something like rust, nextjs, nodejs, python, docker, or a custom runtime label.",
                service.name
            ));
        }
    }

    Ok(())
}

pub fn legacy_service_from_config(config: &XbpConfig) -> ServiceConfig {
    ServiceConfig {
        name: config.project_name.clone(),
        target: config.target.clone().unwrap_or_else(|| "rust".to_string()),
        target_freeze: None,
        branch: config.branch.clone().unwrap_or_else(|| "main".to_string()),
        port: config.port,
        root_directory: Some(config.build_dir.clone()),
        environment: config.environment.clone(),
        url: config.url.clone(),
        healthcheck_path: None,
        restart_policy: Some("on_failure".to_string()),
        restart_policy_max_failure_count: Some(10),
        start_wrapper: Some("pm2".to_string()),
        commands: Some(ServiceCommands {
            pre: None,
            install: config.install_command.clone(),
            build: config.build_command.clone(),
            start: config.start_command.clone(),
            dev: None,
            custom: Default::default(),
        }),
        force_run_from_root: Some(false),
        version_targets: if config.version_targets.is_empty() {
            None
        } else {
            Some(config.version_targets.clone())
        },
        depends_on: None,
        watch_paths: None,
        versioning: None,
        release: None,
        systemd_service_name: config.systemd_service_name.clone(),
        systemd: config.systemd.clone(),
        openapi: None,
        oci: None,
        deploy: None,
        discord: None,
        file_associations: Vec::new(),
    }
}

/// Find a service by name
pub fn get_service_by_name(config: &XbpConfig, name: &str) -> Result<ServiceConfig, String> {
    if let Some(services) = &config.services {
        services
            .iter()
            .find(|s| s.name == name)
            .cloned()
            .ok_or_else(|| format!("Service '{}' not found in configuration", name))
    } else {
        let legacy = legacy_service_from_config(config);
        if legacy.name == name {
            Ok(legacy)
        } else {
            Err(format!(
                "Service '{}' not found. Legacy single-service projects expose only '{}'.",
                name, legacy.name
            ))
        }
    }
}

/// Get all configured Workers entries.
pub fn get_all_workers(config: &XbpConfig) -> Vec<WorkerConfig> {
    config.workers.clone().unwrap_or_default()
}

/// Find a Worker entry by name.
pub fn get_worker_by_name(config: &XbpConfig, name: &str) -> Result<WorkerConfig, String> {
    get_all_workers(config)
        .into_iter()
        .find(|worker| worker.name == name)
        .ok_or_else(|| {
            let available = get_all_workers(config)
                .iter()
                .map(|worker| worker.name.as_str())
                .collect::<Vec<_>>()
                .join(", ");
            if available.is_empty() {
                format!(
                    "Worker app '{name}' was not found. Add a `workers:` section to project config (`.xbp/xbp.toml` by default) or run `xbp workers deploy configure --write-config`."
                )
            } else {
                format!(
                    "Worker app '{name}' was not found. Available workers: {available}"
                )
            }
        })
}

/// Get all services from config (or create a virtual one from legacy config)
pub fn get_all_services(config: &XbpConfig) -> Vec<ServiceConfig> {
    if let Some(services) = &config.services {
        services.clone()
    } else {
        // Backward compatibility: create a virtual service from top-level config
        vec![legacy_service_from_config(config)]
    }
}

#[cfg(test)]
mod tests {
    use super::{
        normalize_config_paths_for_persistence, resolve_config_paths_for_runtime,
        validate_github_release_branch_naming_template, validate_services, ServiceConfig,
        XbpConfig, DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE,
    };

    fn sample_service(name: &str, port: u16) -> ServiceConfig {
        ServiceConfig {
            name: name.to_string(),
            target: "rust".to_string(),
            target_freeze: None,
            branch: "main".to_string(),
            port,
            root_directory: None,
            environment: None,
            url: None,
            healthcheck_path: None,
            restart_policy: None,
            restart_policy_max_failure_count: None,
            start_wrapper: None,
            commands: None,
            force_run_from_root: None,
            version_targets: None,
            depends_on: None,
            watch_paths: None,
            versioning: None,
            release: None,
            systemd_service_name: None,
            systemd: None,
            openapi: None,
            oci: None,
            deploy: None,
            discord: None,
            file_associations: Vec::new(),
        }
    }

    #[test]
    fn validate_services_rejects_duplicate_ports() {
        let services = vec![sample_service("a", 3004), sample_service("b", 3004)];
        let err = validate_services(&services).expect_err("duplicate ports");
        assert!(err.contains("Duplicate port found: 3004"));
    }

    #[test]
    fn validate_services_allows_unique_ports() {
        let services = vec![sample_service("a", 3004), sample_service("b", 3005)];
        validate_services(&services).expect("unique ports should pass");
    }

    #[test]
    fn service_versioning_and_release_flags_default_enabled() {
        let service = sample_service("api", 3000);
        assert!(service.is_versioning_enabled());
        assert!(service.is_release_enabled());

        let disabled: ServiceConfig = serde_yaml::from_str(
            r#"
name: docs
target: nextjs
branch: main
port: 3001
versioning: false
release: false
"#,
        )
        .expect("parse");
        assert!(!disabled.is_versioning_enabled());
        assert!(!disabled.is_release_enabled());

        let version_only: ServiceConfig = serde_yaml::from_str(
            r#"
name: internal
target: rust
branch: main
port: 3002
release: false
"#,
        )
        .expect("parse");
        assert!(version_only.is_versioning_enabled());
        assert!(!version_only.is_release_enabled());
    }

    #[test]
    fn project_disable_lists_match_name_and_root_globs() {
        let mut service = sample_service("web", 3000);
        service.root_directory = Some("apps/web".to_string());
        let config = XbpConfig {
            project_name: "demo".to_string(),
            version: "0.1.0".to_string(),
            port: 3000,
            build_dir: "./".to_string(),
            app_type: None,
            build_command: None,
            start_command: None,
            install_command: None,
            environment: None,
            services: None,
            openapi: None,
            workers: None,
            systemd_service_name: None,
            systemd: None,
            kafka_brokers: None,
            kafka_topic: None,
            kafka_public_url: None,
            log_files: None,
            monitor_url: None,
            monitor_method: None,
            monitor_expected_code: None,
            monitor_interval: None,
            database: None,
            oci: None,
            kubernetes: None,
            deploy: None,
            target: None,
            branch: None,
            crate_name: None,
            npm_script: None,
            port_storybook: None,
            url: None,
            url_storybook: None,
            linear: None,
            github: None,
            publish: None,
            version_targets: Vec::new(),
            version_domains: Vec::new(),
            ignore_paths: Vec::new(),
            watch_ignore_paths: Vec::new(),
            versioning_disabled: vec!["docs".to_string(), "apps/*".to_string()],
            release_disabled: vec!["web".to_string()],
            versioning: None,
            discord: None,
        audit: None,
        };

        assert!(!super::service_versioning_allowed(&config, &service));
        assert!(!super::service_release_allowed(&config, &service));

        let mut docs = sample_service("docs", 3001);
        docs.root_directory = Some("apps/docs".to_string());
        assert!(!super::service_versioning_allowed(&config, &docs));

        let mut api = sample_service("api", 3002);
        api.root_directory = Some("crates/api".to_string());
        assert!(super::service_versioning_allowed(&config, &api));
        assert!(super::service_release_allowed(&config, &api));
    }

    #[test]
    fn service_commands_accept_arbitrary_named_commands() {
        let commands: super::ServiceCommands =
            serde_yaml::from_str("build: cargo build\ntest: cargo test\nlint: cargo clippy\n")
                .expect("parse service commands");

        assert_eq!(
            commands.get("build").map(String::as_str),
            Some("cargo build")
        );
        assert_eq!(commands.get("test").map(String::as_str), Some("cargo test"));
        assert_eq!(
            commands.available_names(),
            vec!["build".to_string(), "lint".to_string(), "test".to_string()]
        );
    }

    #[test]
    fn parses_systemd_string_shorthand_without_struct_error() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: athena
version: 4.5.0
port: 4052
build_dir: ./
services:
  - name: athena-gateway
    target: rust
    branch: main
    port: 4052
    systemd: athena.service
    systemd_service_name: athena
"#,
        )
        .expect("parse config");

        let service = &config.services.expect("services")[0];
        assert_eq!(service.systemd_service_name.as_deref(), Some("athena"));
        assert!(service.systemd.is_none());
    }

    #[test]
    fn service_config_accepts_systemd_string_shorthand_directly() {
        let service: ServiceConfig = serde_yaml::from_str(
            r#"
name: athena-gateway
target: rust
branch: main
port: 4052
systemd: athena.service
"#,
        )
        .expect("parse service");

        assert_eq!(
            service.systemd_service_name.as_deref(),
            Some("athena.service")
        );
        assert!(service.systemd.is_none());
    }

    #[test]
    fn parses_discord_webhook_and_service_overrides() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 1.2.3
port: 3000
build_dir: ./
discord:
  enabled: true
  webhook_url: ${DISCORD_WEBHOOK_URL}
  username: XBP
  events:
    version_release: true
    crates_io: true
    npm: false
    linear: true
    cargo_dist: true
    oci: true
services:
  - name: api
    target: rust
    branch: main
    port: 3000
    discord:
      enabled: true
      events:
        oci: false
"#,
        )
        .expect("parse discord schema");
        let discord = config.discord.expect("project discord");
        assert_eq!(discord.enabled, Some(true));
        assert_eq!(
            discord.webhook_url.as_deref(),
            Some("${DISCORD_WEBHOOK_URL}")
        );
        let events = discord.events.expect("events");
        assert_eq!(events.npm, Some(false));
        assert_eq!(events.crates_io, Some(true));
        let service = config
            .services
            .as_ref()
            .and_then(|s| s.first())
            .expect("service");
        let service_discord = service.discord.as_ref().expect("service discord");
        assert_eq!(
            service_discord
                .events
                .as_ref()
                .and_then(|e| e.oci),
            Some(false)
        );
    }

    #[test]
    fn parses_project_and_service_deploy_oci_blocks() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 1.2.3
port: 3000
build_dir: ./
oci:
  default_registry: ghcr.io
  owner: xylex-group
  repository: xylex-group/container-images
  registries:
    ghcr.io:
      provider: github
      username: xylex-group
      token_source: github
kubernetes:
  default_namespace: demo-system
  require_context_confirmation_for_apply: true
deploy:
  default_env: production
  history_dir: .xbp/deployments
  groups:
    core:
      services: [api]
      order: [api]
services:
  - name: api
    target: rust
    branch: main
    port: 3000
    oci:
      image: ghcr.io/xylex-group/demo-api
      tag_from: project_version
      dockerfile: Dockerfile
      platforms: [linux/amd64]
    deploy:
      provider: kubernetes
      envs:
        production:
          namespace: demo-system
          replicas: 2
          health:
            - https://api.example.com/health
          kubernetes:
            workload: deployment/api
            service: api
"#,
        )
        .expect("parse deploy/oci schema");

        let oci = config.oci.expect("project oci");
        assert!(oci.registries.contains_key("ghcr.io"));
        assert_eq!(oci.owner.as_deref(), Some("xylex-group"));
        assert_eq!(
            oci.repository.as_deref(),
            Some("xylex-group/container-images")
        );
        assert_eq!(
            super::compose_service_oci_image(Some(&oci), None, "demo", "api", None).as_deref(),
            Some("ghcr.io/xylex-group/api")
        );
        assert_eq!(
            super::compose_service_oci_image(
                Some(&oci),
                None,
                "demo",
                "api",
                Some("ghcr.io/other-org/custom")
            )
            .as_deref(),
            Some("ghcr.io/other-org/custom")
        );
        assert_eq!(
            config.kubernetes.as_ref().and_then(|k| k.default_namespace.as_deref()),
            Some("demo-system")
        );
        let group = config
            .deploy
            .as_ref()
            .and_then(|d| d.groups.get("core"))
            .expect("group");
        assert_eq!(group.services, vec!["api".to_string()]);
        let service = config.services.as_ref().unwrap().first().unwrap();
        assert_eq!(
            service.oci.as_ref().and_then(|o| o.image.as_deref()),
            Some("ghcr.io/xylex-group/demo-api")
        );
        assert_eq!(
            service.deploy.as_ref().and_then(|d| d.provider.as_deref()),
            Some("kubernetes")
        );
        let env = service
            .deploy
            .as_ref()
            .and_then(|d| d.envs.get("production"))
            .expect("production env");
        assert_eq!(env.replicas, Some(2));
        assert_eq!(
            env.kubernetes
                .as_ref()
                .and_then(|k| k.workload.as_deref()),
            Some("deployment/api")
        );
    }

    #[test]
    fn github_auto_push_defaults_to_true_when_missing() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
"#,
        )
        .expect("parse config");

        assert!(config.auto_push_on_commit_enabled());
    }

    #[test]
    fn github_auto_push_can_be_disabled_per_project() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
github:
  auto_push_on_commit: false
"#,
        )
        .expect("parse config");

        assert!(!config.auto_push_on_commit_enabled());
    }

    #[test]
    fn github_scalar_repository_shorthand_parses_with_defaults() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
github: xylex-group/statbot-js
"#,
        )
        .expect("parse config");

        let github = config.github.expect("github config");
        assert_eq!(github.repository.as_deref(), Some("xylex-group/statbot-js"));
        assert!(github.auto_push_on_commit);
        assert!(github.release_branch.is_none());
    }

    #[test]
    fn github_scalar_repository_shorthand_round_trips_to_scalar_yaml() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
github: xylex-group/statbot-js
"#,
        )
        .expect("parse config");

        let yaml = serde_yaml::to_string(&config).expect("serialize config");

        assert!(yaml.contains("github: xylex-group/statbot-js"));
    }

    #[test]
    fn default_release_branch_template_is_service_then_version() {
        assert_eq!(
            DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE,
            "releases/{SERVICE_NAME}-{VERSION}"
        );
        assert!(
            validate_github_release_branch_naming_template(
                DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE
            )
            .is_ok()
        );
    }

    #[test]
    fn release_branch_template_rejects_unknown_and_missing_version_tokens() {
        assert!(validate_github_release_branch_naming_template(
            "releases/{PROJECT_NAME}-{VERSION}"
        )
        .is_err());
        assert!(validate_github_release_branch_naming_template("releases/{SERVICE_NAME}").is_err());
        assert!(validate_github_release_branch_naming_template("releases/{FLAG}-{VERSION}").is_err());
        assert!(validate_github_release_branch_naming_template("").is_err());
        assert!(validate_github_release_branch_naming_template("release / {VERSION}").is_err());
        assert!(validate_github_release_branch_naming_template("rel/${GITHUB_TAG}").is_ok());
        assert!(validate_github_release_branch_naming_template(
            "releases/{SERVICE_NAME}-{VERSION}"
        )
        .is_ok());
    }

    #[test]
    fn github_release_branch_is_disabled_by_default() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
"#,
        )
        .expect("parse config");

        assert!(config.github_release_branch_settings().is_none());
    }

    #[test]
    fn github_release_branch_uses_default_template_when_enabled_without_one() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
github:
  release_branch:
    enabled: true
"#,
        )
        .expect("parse config");

        let settings = config
            .github_release_branch_settings()
            .expect("release branch settings");
        assert_eq!(
            settings.naming_template,
            DEFAULT_GITHUB_RELEASE_BRANCH_NAMING_TEMPLATE
        );
    }

    #[test]
    fn github_release_branch_uses_custom_template_when_configured() {
        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
github:
  release_branch:
    enabled: true
    naming_template: rel/${GITHUB_TAG}
"#,
        )
        .expect("parse config");

        let settings = config
            .github_release_branch_settings()
            .expect("release branch settings");
        assert_eq!(settings.naming_template, "rel/${GITHUB_TAG}");
    }

    #[test]
    fn config_version_targets_resolve_for_runtime_and_persist_relatively() {
        let project_root = std::env::temp_dir().join("xbp-version-target-config");
        let mut config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
version_targets:
  - crates/cli/Cargo.toml
  - apps/web/package.json
"#,
        )
        .expect("parse config");

        resolve_config_paths_for_runtime(&mut config, &project_root);
        assert!(std::path::Path::new(&config.version_targets[0]).ends_with("crates/cli/Cargo.toml"));
        assert!(std::path::Path::new(&config.version_targets[1]).ends_with("apps/web/package.json"));

        normalize_config_paths_for_persistence(&mut config, &project_root);
        assert_eq!(
            config.version_targets,
            vec![
                "crates/cli/Cargo.toml".to_string(),
                "apps/web/package.json".to_string()
            ]
        );
    }

    #[test]
    fn worker_container_config_round_trips_and_normalizes_dockerfile() {
        let project_root = std::env::temp_dir().join("xbp-worker-container-config");
        let mut config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
workers:
  - name: auth
    root: apps/auth-worker
    script_name: demo-auth
    container:
      class_name: AuthContainer
      binding: AUTH_CONTAINER
      dockerfile: Dockerfile
      port: 8787
      application_id: app_123
      healthcheck_path: /health
      health_urls:
        - https://auth.example.com/health
      expected_image_name: demo-auth-authcontainer
      image_tag_keep_count: 10
      allow_unchanged_container_image: false
      required_secrets:
        - AUTH_SECRET
      version_var: AUTH_VERSION
      instance_name_template: auth-${VERSION}
      default_rollout: gradual
"#,
        )
        .expect("parse config");

        let worker = config
            .workers
            .as_ref()
            .and_then(|workers| workers.first())
            .expect("worker");
        let container = worker.container.as_ref().expect("container");
        assert_eq!(container.class_name.as_deref(), Some("AuthContainer"));
        assert_eq!(container.port, Some(8787));
        assert_eq!(container.required_secrets, vec!["AUTH_SECRET"]);
        assert_eq!(
            container.health_urls,
            vec!["https://auth.example.com/health"]
        );
        assert_eq!(
            container.expected_image_name.as_deref(),
            Some("demo-auth-authcontainer")
        );
        assert_eq!(container.image_tag_keep_count, Some(10));
        assert!(!container.allow_unchanged_container_image);

        resolve_config_paths_for_runtime(&mut config, &project_root);
        let worker = config
            .workers
            .as_ref()
            .and_then(|workers| workers.first())
            .expect("worker");
        assert!(std::path::Path::new(&worker.root).ends_with("apps/auth-worker"));
        assert!(std::path::Path::new(
            worker
                .container
                .as_ref()
                .and_then(|container| container.dockerfile.as_deref())
                .expect("dockerfile")
        )
        .ends_with("apps/auth-worker/Dockerfile"));

        normalize_config_paths_for_persistence(&mut config, &project_root);
        let yaml = serde_yaml::to_string(&config).expect("serialize config");
        assert!(yaml.contains("container:"));
        assert!(yaml.contains("class_name: AuthContainer"));
        assert!(yaml.contains("dockerfile: Dockerfile"));
    }

    #[test]
    fn legacy_get_service_by_name_resolves_virtual_project_service() {
        use super::{get_all_services, get_service_by_name};

        let config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: "@suitsfinance/formations"
version: 0.7.0
port: 3000
build_dir: ./
target: nextjs
branch: main
build_command: pnpm run build
start_command: pnpm run start
install_command: pnpm install
"#,
        )
        .expect("parse config");

        let listed = get_all_services(&config);
        assert_eq!(listed.len(), 1);
        assert_eq!(listed[0].name, "@suitsfinance/formations");

        let resolved =
            get_service_by_name(&config, "@suitsfinance/formations").expect("resolve legacy");
        assert_eq!(resolved.name, "@suitsfinance/formations");
        assert_eq!(
            resolved.commands.as_ref().and_then(|c| c.build.as_deref()),
            Some("pnpm run build")
        );

        let err = get_service_by_name(&config, "missing").expect_err("unknown legacy name");
        assert!(err.contains("not found"));
        assert!(err.contains("@suitsfinance/formations"));
    }

    #[test]
    fn service_version_targets_resolve_for_runtime_and_persist_relatively() {
        let project_root = std::env::temp_dir().join("xbp-service-version-target-config");
        let mut config: XbpConfig = serde_yaml::from_str(
            r#"
project_name: demo
version: 0.1.0
port: 3000
build_dir: ./
services:
  - name: web
    target: nextjs
    branch: main
    port: 3001
    root_directory: apps/web
    version_targets:
      - apps/web/package.json
"#,
        )
        .expect("parse config");

        resolve_config_paths_for_runtime(&mut config, &project_root);
        let services = config.services.as_ref().expect("services");
        assert!(std::path::Path::new(
            services[0]
                .version_targets
                .as_ref()
                .expect("service targets")
                .first()
                .expect("first target")
        )
        .ends_with("apps/web/package.json"));

        normalize_config_paths_for_persistence(&mut config, &project_root);
        assert_eq!(
            config.services.unwrap()[0].version_targets,
            Some(vec!["apps/web/package.json".to_string()])
        );
    }
}