greentic_setup/qa/

shared_questions.rs

//! Shared Questions Support for multi-provider setup.
//!
//! When setting up multiple providers, some questions (like `public_base_url`)
//! appear in all providers. Instead of asking the same question repeatedly,
//! we identify shared questions and prompt for them once upfront.

use anyhow::Result;
use qa_spec::{FormSpec, QuestionSpec};
use serde_json::{Map as JsonMap, Value};
use std::collections::HashMap;

use crate::qa::prompts::ask_form_spec_question;
use crate::setup_to_formspec;

/// Well-known question IDs that are commonly shared across providers.
///
/// These questions will be prompted once at the beginning of a multi-provider
/// setup wizard, and their answers will be applied to all providers.
pub const SHARED_QUESTION_IDS: &[&str] = &[
    "public_base_url",
    // NOTE: api_base_url is NOT shared - each provider has different API endpoints
    // (e.g., slack.com, telegram.org, webexapis.com)
];

/// Placeholder persisted for the public base URL question.
///
/// The externally-reachable URL is never known at setup time — it is provided
/// by an active tunnel, the `PUBLIC_BASE_URL` environment variable, or whatever
/// the runtime resolves — so anything an operator typed here would be
/// overwritten anyway. Rather than surface a question whose answer is always
/// discarded, we skip the prompt and persist this loopback filler; the runtime
/// replaces it with the real public URL when the endpoint comes up.
pub const PUBLIC_URL_FILLER: &str = "http://localhost:8080";

/// Whether `question_id` names the environment's public base URL question.
///
/// These questions are never surfaced interactively — they are auto-filled with
/// [`PUBLIC_URL_FILLER`] and overwritten at runtime. See [`HIDDEN_FROM_PROMPTS`].
pub fn is_public_url_question(question_id: &str) -> bool {
    question_id == "public_base_url"
}

/// Insert [`PUBLIC_URL_FILLER`] for any public-URL question in `question_ids`
/// that lacks a non-empty answer in `answers`.
///
/// Callers pass the question ids straight off whatever spec they hold (FormSpec
/// or the legacy setup spec). Called after prompting so the persisted answers
/// carry a well-formed placeholder the runtime can overwrite, without ever
/// asking the operator.
pub fn fill_public_url_placeholders<'a>(
    question_ids: impl IntoIterator<Item = &'a str>,
    answers: &mut JsonMap<String, Value>,
) {
    for id in question_ids {
        if !is_public_url_question(id) {
            continue;
        }
        let has_value = answers
            .get(id)
            .is_some_and(|v| !v.is_null() && v.as_str() != Some(""));
        if !has_value {
            answers.insert(id.to_string(), Value::String(PUBLIC_URL_FILLER.to_string()));
        }
    }
}

/// Questions hidden from interactive prompts (both terminal and web UI).
///
/// Values may still be supplied via `--answers` file or prefill. Keep this list
/// empty by default. The public URL question is handled separately via
/// [`is_public_url_question`] rather than here: the terminal wizard skips it
/// outright, but the web UI keeps it in the form so a selected tunnel can still
/// auto-generate a real HTTPS URL before falling back to [`PUBLIC_URL_FILLER`].
pub const HIDDEN_FROM_PROMPTS: &[&str] = &[];

/// Information about a provider and its FormSpec for multi-provider setup.
#[derive(Clone)]
pub struct ProviderFormSpec {
    /// Provider identifier (e.g., "messaging-telegram")
    pub provider_id: String,
    /// The FormSpec for this provider
    pub form_spec: FormSpec,
}

/// Result of collecting shared questions across multiple providers.
#[derive(Clone, Default)]
pub struct SharedQuestionsResult {
    /// Questions that appear in multiple providers (deduplicated).
    /// Each question is taken from the first provider that defines it.
    pub shared_questions: Vec<QuestionSpec>,
    /// Provider IDs that contain each shared question ID.
    pub question_providers: HashMap<String, Vec<String>>,
}

/// Collect questions that are shared across multiple providers.
///
/// A question is considered "shared" if:
/// 1. Its ID is in `SHARED_QUESTION_IDS`, OR
/// 2. It appears in 2+ providers with the same ID
///
/// Returns deduplicated questions (taking the first occurrence) along with
/// which providers contain each question.
pub fn collect_shared_questions(providers: &[ProviderFormSpec]) -> SharedQuestionsResult {
    if providers.len() <= 1 {
        return SharedQuestionsResult::default();
    }

    // Count occurrences by borrowed question ID and retain borrowed provider
    // IDs in the same pass. Only allocate owned strings for final shared rows.
    let mut questions: HashMap<&str, (usize, &QuestionSpec, Vec<&str>)> = HashMap::new();

    for provider in providers {
        for question in &provider.form_spec.questions {
            if question.id.is_empty() {
                continue;
            }
            questions
                .entry(question.id.as_str())
                .and_modify(|(count, _, provider_ids)| {
                    *count += 1;
                    provider_ids.push(provider.provider_id.as_str());
                })
                .or_insert_with(|| (1, question, vec![provider.provider_id.as_str()]));
        }
    }

    // Find shared questions (must appear in 2+ providers to be truly shared)
    // SHARED_QUESTION_IDS are hints for what questions are commonly shared,
    // but we only share them if they actually appear in multiple providers.
    //
    // IMPORTANT: Exclude secrets and provider-specific fields from sharing.
    // Each provider needs unique values for these fields.
    let mut shared_questions = Vec::new();
    let mut question_providers = HashMap::new();

    fn is_never_shared(question_id: &str) -> bool {
        matches!(
            question_id,
            "api_base_url"
                | "bot_token"
                | "access_token"
                | "token"
                | "app_id"
                | "app_secret"
                | "client_id"
                | "client_secret"
                | "webhook_secret"
                | "signing_secret"
        )
    }

    for (question_id, (count, question, provider_ids)) in questions {
        // Only share questions that actually appear in 2+ providers
        if count >= 2 {
            // Skip secrets - they should never be shared across providers
            if question.secret {
                continue;
            }

            // Skip provider-specific fields that happen to have the same ID
            if is_never_shared(question_id) {
                continue;
            }

            shared_questions.push(question.clone());
            question_providers.insert(
                question_id.to_string(),
                provider_ids.into_iter().map(str::to_string).collect(),
            );
        }
    }

    // Sort by question ID for deterministic ordering
    shared_questions.sort_by(|a, b| a.id.cmp(&b.id));

    SharedQuestionsResult {
        shared_questions,
        question_providers,
    }
}

/// Prompt for shared questions that apply to multiple providers.
///
/// Takes existing answers from loaded setup file and only prompts for
/// questions that don't already have a valid (non-empty) value.
pub fn prompt_shared_questions(
    shared: &SharedQuestionsResult,
    advanced: bool,
    existing_answers: &Value,
) -> Result<Value> {
    if shared.shared_questions.is_empty() {
        return Ok(Value::Object(JsonMap::new()));
    }

    let existing_map = existing_answers.as_object();

    // Check if all shared questions already have valid answers
    let questions_needing_prompt: Vec<_> = shared
        .shared_questions
        .iter()
        .filter(|q| {
            // Skip questions hidden from interactive prompts (auto-injected by operator)
            if HIDDEN_FROM_PROMPTS.contains(&q.id.as_str()) {
                return false;
            }
            // The public URL question is never surfaced in the terminal wizard;
            // it is auto-filled below. See `PUBLIC_URL_FILLER`.
            if is_public_url_question(&q.id) {
                return false;
            }
            // Skip optional questions in normal mode
            if !advanced && !q.required {
                return false;
            }
            // Check if this question already has a non-empty value
            if let Some(map) = existing_map
                && let Some(value) = map.get(&q.id)
            {
                // Skip if value is non-null and non-empty string
                if !value.is_null() {
                    if let Some(s) = value.as_str() {
                        return s.is_empty(); // Need prompt if empty string
                    }
                    return false; // Has value, skip
                }
            }
            true // Need prompt
        })
        .collect();

    // If no questions need prompting, return existing answers
    if questions_needing_prompt.is_empty() {
        let mut answers = JsonMap::new();
        if let Some(map) = existing_map {
            for question in &shared.shared_questions {
                if let Some(value) = map.get(&question.id) {
                    answers.insert(question.id.clone(), value.clone());
                }
            }
        }
        fill_public_url_placeholders(
            shared.shared_questions.iter().map(|q| q.id.as_str()),
            &mut answers,
        );
        return Ok(Value::Object(answers));
    }

    println!("\n── Shared Configuration ──");
    println!("The following settings apply to all providers:\n");

    let mut answers = JsonMap::new();

    // Copy existing values first
    if let Some(map) = existing_map {
        for question in &shared.shared_questions {
            if let Some(value) = map.get(&question.id)
                && !value.is_null()
                && !(value.is_string() && value.as_str() == Some(""))
            {
                answers.insert(question.id.clone(), value.clone());
            }
        }
    }

    for question in &shared.shared_questions {
        // Skip questions hidden from interactive prompts (auto-injected by operator)
        if HIDDEN_FROM_PROMPTS.contains(&question.id.as_str()) {
            continue;
        }

        // The public URL question is never surfaced; it is auto-filled below.
        if is_public_url_question(&question.id) {
            continue;
        }

        // Skip if we already have a valid answer
        if answers.contains_key(&question.id) {
            continue;
        }

        // Skip optional questions in normal mode
        if !advanced && !question.required {
            continue;
        }

        // Show which providers use this question
        if let Some(provider_ids) = shared.question_providers.get(&question.id) {
            let providers_str = provider_ids
                .iter()
                .map(|id| setup_to_formspec::strip_domain_prefix(id))
                .collect::<Vec<_>>()
                .join(", ");
            println!("  Used by: {providers_str}");
        }

        // None: shared-question prompts keep English chrome (provider-setup flow).
        if let Some(value) = ask_form_spec_question(question, None)? {
            answers.insert(question.id.clone(), value);
        }
    }

    fill_public_url_placeholders(
        shared.shared_questions.iter().map(|q| q.id.as_str()),
        &mut answers,
    );

    println!();
    Ok(Value::Object(answers))
}

/// Merge shared answers with provider-specific answers.
///
/// Shared answers take precedence for non-empty values, but provider-specific
/// answers can override if the shared value is empty.
pub fn merge_shared_with_provider_answers(
    shared: &Value,
    provider_specific: Option<&Value>,
) -> Value {
    let mut merged = JsonMap::new();

    // Start with shared answers
    if let Some(shared_map) = shared.as_object() {
        for (key, value) in shared_map {
            // Only include non-empty values
            if !(value.is_null() || value.is_string() && value.as_str() == Some("")) {
                merged.insert(key.clone(), value.clone());
            }
        }
    }

    // Add provider-specific answers (don't override non-empty shared values)
    if let Some(provider_map) = provider_specific.and_then(Value::as_object) {
        for (key, value) in provider_map {
            // Only add if not already present with a non-empty value
            if !merged.contains_key(key) {
                merged.insert(key.clone(), value.clone());
            }
        }
    }

    Value::Object(merged)
}

/// Build FormSpecs for multiple providers from their pack paths.
///
/// Convenience function to prepare input for `collect_shared_questions`.
pub fn build_provider_form_specs(
    providers: &[(std::path::PathBuf, String)], // (pack_path, provider_id)
) -> Vec<ProviderFormSpec> {
    providers
        .iter()
        .filter_map(|(pack_path, provider_id)| {
            setup_to_formspec::pack_to_form_spec(pack_path, provider_id).map(|form_spec| {
                ProviderFormSpec {
                    provider_id: provider_id.clone(),
                    form_spec,
                }
            })
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use qa_spec::QuestionType;

    fn make_provider_form_spec(provider_id: &str, question_ids: &[&str]) -> ProviderFormSpec {
        let questions = question_ids
            .iter()
            .map(|id| QuestionSpec {
                id: id.to_string(),
                kind: QuestionType::String,
                title: format!("{} Question", id),
                title_i18n: None,
                description: None,
                description_i18n: None,
                required: true,
                choices: None,
                default_value: None,
                secret: false,
                visible_if: None,
                constraint: None,
                list: None,
                computed: None,
                policy: Default::default(),
                computed_overridable: false,
            })
            .collect();

        ProviderFormSpec {
            provider_id: provider_id.to_string(),
            form_spec: FormSpec {
                id: format!("{}-setup", provider_id),
                title: format!("{} Setup", provider_id),
                version: "1.0.0".into(),
                description: None,
                presentation: None,
                progress_policy: None,
                secrets_policy: None,
                store: vec![],
                validations: vec![],
                includes: vec![],
                questions,
            },
        }
    }

    #[test]
    fn collect_shared_questions_finds_common_questions() {
        let providers = vec![
            make_provider_form_spec("messaging-telegram", &["public_base_url", "bot_token"]),
            make_provider_form_spec("messaging-slack", &["public_base_url", "slack_token"]),
            make_provider_form_spec("messaging-teams", &["public_base_url", "teams_app_id"]),
        ];

        let result = collect_shared_questions(&providers);

        // public_base_url appears in all 3 providers
        assert_eq!(result.shared_questions.len(), 1);
        assert_eq!(result.shared_questions[0].id, "public_base_url");

        // Check provider mapping
        let providers_for_url = result.question_providers.get("public_base_url").unwrap();
        assert_eq!(providers_for_url.len(), 3);
        assert!(providers_for_url.contains(&"messaging-telegram".to_string()));
        assert!(providers_for_url.contains(&"messaging-slack".to_string()));
        assert!(providers_for_url.contains(&"messaging-teams".to_string()));
    }

    #[test]
    fn collect_shared_questions_excludes_single_provider_questions() {
        let providers = vec![
            make_provider_form_spec("messaging-telegram", &["public_base_url", "bot_token"]),
            make_provider_form_spec("messaging-slack", &["slack_token"]), // no public_base_url
        ];

        let result = collect_shared_questions(&providers);
        assert!(result.shared_questions.is_empty());
    }

    #[test]
    fn collect_shared_questions_returns_empty_for_single_provider() {
        let providers = vec![make_provider_form_spec(
            "messaging-telegram",
            &["public_base_url", "bot_token"],
        )];

        let result = collect_shared_questions(&providers);
        assert!(result.shared_questions.is_empty());
    }

    #[test]
    fn collect_shared_questions_finds_non_wellknown_duplicates() {
        let providers = vec![
            make_provider_form_spec("provider-a", &["custom_field", "field_a"]),
            make_provider_form_spec("provider-b", &["custom_field", "field_b"]),
        ];

        let result = collect_shared_questions(&providers);
        assert_eq!(result.shared_questions.len(), 1);
        assert_eq!(result.shared_questions[0].id, "custom_field");
    }

    #[test]
    fn collect_shared_questions_deduplicates() {
        let providers = vec![
            make_provider_form_spec("provider-a", &["public_base_url"]),
            make_provider_form_spec("provider-b", &["public_base_url"]),
            make_provider_form_spec("provider-c", &["public_base_url"]),
        ];

        let result = collect_shared_questions(&providers);
        assert_eq!(result.shared_questions.len(), 1);
    }

    #[test]
    fn public_url_question_is_recognized() {
        assert!(is_public_url_question("public_base_url"));
        assert!(!is_public_url_question("api_base_url"));
        assert!(!is_public_url_question("bot_token"));
    }

    #[test]
    fn fill_public_url_placeholders_injects_filler_when_absent() {
        let form = make_provider_form_spec("p", &["public_base_url", "bot_token"]);
        let mut answers = JsonMap::new();
        fill_public_url_placeholders(
            form.form_spec.questions.iter().map(|q| q.id.as_str()),
            &mut answers,
        );
        assert_eq!(
            answers.get("public_base_url"),
            Some(&Value::String(PUBLIC_URL_FILLER.to_string()))
        );
        // Non-public-URL questions are left untouched.
        assert!(answers.get("bot_token").is_none());
    }

    #[test]
    fn fill_public_url_placeholders_keeps_existing_value() {
        let form = make_provider_form_spec("p", &["public_base_url"]);
        let mut answers = JsonMap::new();
        answers.insert(
            "public_base_url".to_string(),
            Value::String("https://real.example.com".to_string()),
        );
        fill_public_url_placeholders(
            form.form_spec.questions.iter().map(|q| q.id.as_str()),
            &mut answers,
        );
        assert_eq!(
            answers.get("public_base_url"),
            Some(&Value::String("https://real.example.com".to_string()))
        );
    }

    #[test]
    fn prompt_shared_questions_fills_public_url_without_prompting() {
        // public_base_url is the only shared question and it is hidden from
        // prompts, so this returns the placeholder without reading stdin.
        let providers = vec![
            make_provider_form_spec("provider-a", &["public_base_url"]),
            make_provider_form_spec("provider-b", &["public_base_url"]),
        ];
        let shared = collect_shared_questions(&providers);
        let answers =
            prompt_shared_questions(&shared, false, &Value::Object(JsonMap::new())).unwrap();
        assert_eq!(
            answers.get("public_base_url"),
            Some(&Value::String(PUBLIC_URL_FILLER.to_string()))
        );
    }
}