//! Directive API methods.

use serde::Serialize;
use uuid::Uuid;

use super::client::{ApiClient, ApiError};
use super::supervisor::JsonValue;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateStepRequest {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_plan: Option<String>,
    pub depends_on: Vec<Uuid>,
    pub order_index: i32,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateGoalRequest {
    pub goal: String,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateStepDepsRequest {
    pub depends_on: Vec<Uuid>,
}

impl ApiClient {
    /// List all directives.
    pub async fn list_directives(&self) -> Result<JsonValue, ApiError> {
        self.get("/api/v1/directives").await
    }

    /// Get a directive with its steps.
    pub async fn get_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.get(&format!("/api/v1/directives/{}", directive_id)).await
    }

    /// Add a step to a directive.
    pub async fn directive_add_step(
        &self,
        directive_id: Uuid,
        req: CreateStepRequest,
    ) -> Result<JsonValue, ApiError> {
        self.post(&format!("/api/v1/directives/{}/steps", directive_id), &req).await
    }

    /// Remove a step from a directive.
    pub async fn directive_remove_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<(), ApiError> {
        self.delete(&format!("/api/v1/directives/{}/steps/{}", directive_id, step_id)).await
    }

    /// Set dependencies for a step.
    pub async fn directive_set_deps(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
        depends_on: Vec<Uuid>,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateStepDepsRequest { depends_on };
        self.put(&format!("/api/v1/directives/{}/steps/{}", directive_id, step_id), &req).await
    }

    /// Start a directive.
    pub async fn directive_start(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/start", directive_id)).await
    }

    /// Pause a directive.
    pub async fn directive_pause(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/pause", directive_id)).await
    }

    /// Advance the directive DAG.
    pub async fn directive_advance(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/advance", directive_id)).await
    }

    /// Mark a step as completed.
    pub async fn directive_complete_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/complete", directive_id, step_id)).await
    }

    /// Mark a step as failed.
    pub async fn directive_fail_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/fail", directive_id, step_id)).await
    }

    /// Mark a step as skipped.
    pub async fn directive_skip_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/skip", directive_id, step_id)).await
    }

    /// Batch add steps to a directive.
    pub async fn directive_batch_add_steps(
        &self,
        directive_id: Uuid,
        steps: serde_json::Value,
    ) -> Result<JsonValue, ApiError> {
        self.post(
            &format!("/api/v1/directives/{}/steps/batch", directive_id),
            &steps,
        )
        .await
    }

    /// Update the directive's goal.
    pub async fn directive_update_goal(
        &self,
        directive_id: Uuid,
        goal: &str,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateGoalRequest { goal: goal.to_string() };
        self.put(&format!("/api/v1/directives/{}/goal", directive_id), &req).await
    }

    /// Update directive metadata (PR URL, PR branch, status, etc.)
    pub async fn directive_update(
        &self,
        directive_id: Uuid,
        pr_url: Option<String>,
        pr_branch: Option<String>,
        status: Option<String>,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateDirectiveMetadataRequest { pr_url, pr_branch, status };
        self.put(&format!("/api/v1/directives/{}", directive_id), &req).await
    }

}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateDirectiveMetadataRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pr_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pr_branch: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}