mod client;
mod error;
mod model;

use async_trait::async_trait;
use crank_core::{
    AdapterResponse, ExecutionMode, PreparedRequest, Protocol, ProtocolAdapter,
    ProtocolAdapterError, RestTarget, RuntimeRequestContext, Target,
};

pub use client::RestAdapter;
pub use error::RestAdapterError;
pub use model::{RestRequest, RestResponse};

#[async_trait]
impl ProtocolAdapter for RestAdapter {
    fn protocol(&self) -> Protocol {
        Protocol::Rest
    }

    fn supports_mode(&self, mode: ExecutionMode) -> bool {
        matches!(mode, ExecutionMode::Unary)
    }

    async fn invoke_unary(
        &self,
        target: &Target,
        prepared: &PreparedRequest,
        _context: &RuntimeRequestContext,
    ) -> Result<AdapterResponse, ProtocolAdapterError> {
        let target = rest_target(target)?;
        let request = RestRequest {
            path_params: prepared.path_params.clone(),
            query_params: prepared.query_params.clone(),
            headers: prepared.headers.clone(),
            body: prepared.body.clone(),
            timeout_ms: prepared.timeout_ms,
        };
        let response = self.execute(target, &request).await?;

        Ok(AdapterResponse {
            status_code: response.status_code,
            headers: response.headers,
            data: response.body.clone(),
            body: response.body,
        })
    }
}

fn rest_target(target: &Target) -> Result<&RestTarget, ProtocolAdapterError> {
    match target {
        Target::Rest(target) => Ok(target),
    }
}

impl From<RestAdapterError> for ProtocolAdapterError {
    fn from(value: RestAdapterError) -> Self {
        ProtocolAdapterError::Message(value.to_string())
    }
}