// file: crates/ksp-offchain-transport-lib/tests/public_api.rs
// version: 6

#![warn(missing_docs)]
#![deny(unreachable_pub)]
#![forbid(unsafe_code)]

//! Public API canaries for the market-price foundation and stable Off-chain Transport error-code surface.

#[test]
fn public_pre_002_market_price_foundation_is_available_from_crate_root() -> ksp_core_lib::Result<()> {
    assert_eq!(ksp_offchain_transport_lib::MarketPricePair::SolUsd.code(), "SOL/USD");
    assert_eq!(ksp_offchain_transport_lib::MARKET_PRICE_DECIMAL_MAX_SCALE, 18);
    let price = match ksp_offchain_transport_lib::MarketPriceDecimal::parse("201.2500") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(price.to_canonical_string(), "201.25");
    let id = match ksp_offchain_transport_lib::MarketPriceProviderId::new("provider-canary") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let common = ksp_offchain_transport_lib::MarketPriceProviderCommonSettings::new(id.clone(), true);
    assert_eq!(common.provider_id(), &id);
    let rate_limit = match ksp_offchain_transport_lib::MarketPriceProviderRateLimit::fixed(
        1,
        1,
        std::option::Option::None,
        ksp_offchain_transport_lib::MarketPriceProviderRateLimitScope::Ip,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let descriptor = match ksp_offchain_transport_lib::MarketPriceProviderDescriptor::new(
        id.clone(),
        "Provider Canary",
        ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket,
        ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None,
        rate_limit,
        std::option::Option::None,
        true,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert!(descriptor.supports_sol_usd());
    let provenance = match ksp_offchain_transport_lib::MarketPriceProvenance::new("canary") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let timestamp = ksp_offchain_transport_lib::MarketPriceTimestamp::from_unix_millis(1);
    let observation = match ksp_offchain_transport_lib::MarketPriceObservation::new(
        id,
        price,
        ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket,
        timestamp,
        timestamp,
        std::option::Option::None,
        provenance,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(observation.price(), price);
    return std::result::Result::Ok(());
}

#[test]
fn public_pre_004_aggregator_settings_and_adapters_are_available_from_crate_root() -> ksp_core_lib::Result<()> {
    let coingecko = match ksp_offchain_transport_lib::MarketPriceCoinGeckoSettings::keyless(false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let coingecko_provider = match ksp_offchain_transport_lib::MarketPriceCoinGeckoProvider::new(coingecko) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(coingecko_provider.descriptor().id().as_str(), "coingecko");
    let coinmarketcap = match ksp_offchain_transport_lib::MarketPriceCoinMarketCapSettings::keyless(false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let coinmarketcap_provider = match ksp_offchain_transport_lib::MarketPriceCoinMarketCapProvider::new(coinmarketcap) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(coinmarketcap_provider.descriptor().id().as_str(), "coinmarketcap");
    let coinpaprika = match ksp_offchain_transport_lib::MarketPriceCoinPaprikaSettings::new(false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let coinpaprika_provider = match ksp_offchain_transport_lib::MarketPriceCoinPaprikaProvider::new(coinpaprika) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(coinpaprika_provider.descriptor().id().as_str(), "coinpaprika");
    return std::result::Result::Ok(());
}

#[test]
fn public_pre_005_exchange_settings_and_adapters_are_available_from_crate_root() -> ksp_core_lib::Result<()> {
    let kraken = match ksp_offchain_transport_lib::MarketPriceKrakenSettings::new(false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let kraken_provider = match ksp_offchain_transport_lib::MarketPriceKrakenProvider::new(kraken) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(kraken_provider.descriptor().id().as_str(), "kraken");
    assert_eq!(kraken_provider.descriptor().semantics(), ksp_offchain_transport_lib::MarketPriceSemantics::ExchangeLastTrade);
    let coinbase = match ksp_offchain_transport_lib::MarketPriceCoinbaseExchangeSettings::new(false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let coinbase_provider = match ksp_offchain_transport_lib::MarketPriceCoinbaseExchangeProvider::new(coinbase) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(coinbase_provider.descriptor().id().as_str(), "coinbase_exchange");
    assert_eq!(coinbase_provider.descriptor().semantics(), ksp_offchain_transport_lib::MarketPriceSemantics::ExchangeLastTrade);
    return std::result::Result::Ok(());
}

#[test]
fn offchain_error_codes_use_owned_domain() {
    let codes = [
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_ACCESS_DENIED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_ADMISSION_DEFERRED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_CLIENT_BUILD_FAILED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_CONNECTION_FAILED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_INVALID_JSON,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_RATE_LIMIT_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_RATE_LIMITED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_REQUEST_FAILED,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_REQUEST_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_RESPONSE_TOO_LARGE,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_SETTINGS_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_TEMPORARY_FAILURE,
        ksp_offchain_transport_lib::ERROR_CODE_HTTP_TIMEOUT,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_DECIMAL_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_PROVIDER_DESCRIPTOR_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_PROVIDER_DISABLED,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_PROVIDER_ID_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_PROVIDER_RESPONSE_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_OBSERVATION_INVALID,
        ksp_offchain_transport_lib::ERROR_CODE_MARKET_PRICE_PROVIDER_SETTINGS_INVALID,
    ];
    for code in codes {
        assert_eq!(code.domain(), "offchain_transport");
    }
}