databuild/databuild/status_utils.rs

use crate::*;

/// Utilities for converting status enums to human-readable strings
/// This provides consistent status naming across CLI and Service interfaces

impl PartitionStatus {
    /// Convert partition status to human-readable string matching current CLI/service format
    pub fn to_display_string(&self) -> String {
        match self {
            PartitionStatus::PartitionUnknown => "unknown".to_string(),
            PartitionStatus::PartitionRequested => "requested".to_string(),
            PartitionStatus::PartitionAnalyzed => "analyzed".to_string(),
            PartitionStatus::PartitionBuilding => "building".to_string(),
            PartitionStatus::PartitionAvailable => "available".to_string(),
            PartitionStatus::PartitionFailed => "failed".to_string(),
            PartitionStatus::PartitionDelegated => "delegated".to_string(),
        }
    }

    /// Parse a display string back to enum (for filtering, etc.)
    pub fn from_display_string(s: &str) -> Option<Self> {
        match s {
            "unknown" => Some(PartitionStatus::PartitionUnknown),
            "requested" => Some(PartitionStatus::PartitionRequested),
            "analyzed" => Some(PartitionStatus::PartitionAnalyzed),
            "building" => Some(PartitionStatus::PartitionBuilding),
            "available" => Some(PartitionStatus::PartitionAvailable),
            "failed" => Some(PartitionStatus::PartitionFailed),
            "delegated" => Some(PartitionStatus::PartitionDelegated),
            _ => None,
        }
    }
}

impl JobStatus {
    /// Convert job status to human-readable string matching current CLI/service format
    pub fn to_display_string(&self) -> String {
        match self {
            JobStatus::JobUnknown => "unknown".to_string(),
            JobStatus::JobScheduled => "scheduled".to_string(),
            JobStatus::JobRunning => "running".to_string(),
            JobStatus::JobCompleted => "completed".to_string(),
            JobStatus::JobFailed => "failed".to_string(),
            JobStatus::JobCancelled => "cancelled".to_string(),
            JobStatus::JobSkipped => "skipped".to_string(),
        }
    }

    /// Parse a display string back to enum
    pub fn from_display_string(s: &str) -> Option<Self> {
        match s {
            "unknown" => Some(JobStatus::JobUnknown),
            "scheduled" => Some(JobStatus::JobScheduled),
            "running" => Some(JobStatus::JobRunning),
            "completed" => Some(JobStatus::JobCompleted),
            "failed" => Some(JobStatus::JobFailed),
            "cancelled" => Some(JobStatus::JobCancelled),
            "skipped" => Some(JobStatus::JobSkipped),
            _ => None,
        }
    }
}

impl BuildRequestStatus {
    /// Convert build request status to human-readable string matching current CLI/service format
    pub fn to_display_string(&self) -> String {
        match self {
            BuildRequestStatus::BuildRequestUnknown => "unknown".to_string(),
            BuildRequestStatus::BuildRequestReceived => "received".to_string(),
            BuildRequestStatus::BuildRequestPlanning => "planning".to_string(),
            BuildRequestStatus::BuildRequestAnalysisCompleted => "analysis_completed".to_string(),
            BuildRequestStatus::BuildRequestExecuting => "executing".to_string(),
            BuildRequestStatus::BuildRequestCompleted => "completed".to_string(),
            BuildRequestStatus::BuildRequestFailed => "failed".to_string(),
            BuildRequestStatus::BuildRequestCancelled => "cancelled".to_string(),
        }
    }

    /// Parse a display string back to enum
    pub fn from_display_string(s: &str) -> Option<Self> {
        match s {
            "unknown" => Some(BuildRequestStatus::BuildRequestUnknown),
            "received" => Some(BuildRequestStatus::BuildRequestReceived),
            "planning" => Some(BuildRequestStatus::BuildRequestPlanning),
            "analysis_completed" => Some(BuildRequestStatus::BuildRequestAnalysisCompleted),
            "executing" => Some(BuildRequestStatus::BuildRequestExecuting),
            "completed" => Some(BuildRequestStatus::BuildRequestCompleted),
            "failed" => Some(BuildRequestStatus::BuildRequestFailed),
            "cancelled" => Some(BuildRequestStatus::BuildRequestCancelled),
            _ => None,
        }
    }
}

impl DepType {
    /// Convert dependency type to human-readable string
    pub fn to_display_string(&self) -> String {
        match self {
            DepType::Query => "query".to_string(),
            DepType::Materialize => "materialize".to_string(),
        }
    }

    /// Parse a display string back to enum
    pub fn from_display_string(s: &str) -> Option<Self> {
        match s {
            "query" => Some(DepType::Query),
            "materialize" => Some(DepType::Materialize),
            _ => None,
        }
    }
}

/// Helper functions for creating protobuf list responses with dual status fields
pub mod list_response_helpers {
    use super::*;

    /// Create a PartitionSummary from repository data
    pub fn create_partition_summary(
        partition_ref: PartitionRef,
        status: PartitionStatus,
        last_updated: i64,
        builds_count: usize,
        invalidation_count: usize,
        last_successful_build: Option<String>,
    ) -> PartitionSummary {
        PartitionSummary {
            partition_ref: Some(partition_ref),
            status_code: status as i32,
            status_name: status.to_display_string(),
            last_updated,
            builds_count: builds_count as u32,
            invalidation_count: invalidation_count as u32,
            last_successful_build,
        }
    }

    /// Create a JobSummary from repository data
    pub fn create_job_summary(
        job_label: String,
        total_runs: usize,
        successful_runs: usize,
        failed_runs: usize,
        cancelled_runs: usize,
        average_partitions_per_run: f64,
        last_run_timestamp: i64,
        last_run_status: JobStatus,
        recent_builds: Vec<String>,
    ) -> JobSummary {
        JobSummary {
            job_label,
            total_runs: total_runs as u32,
            successful_runs: successful_runs as u32,
            failed_runs: failed_runs as u32,
            cancelled_runs: cancelled_runs as u32,
            average_partitions_per_run,
            last_run_timestamp,
            last_run_status_code: last_run_status as i32,
            last_run_status_name: last_run_status.to_display_string(),
            recent_builds,
        }
    }

    /// Create a TaskSummary from repository data
    pub fn create_task_summary(
        job_run_id: String,
        job_label: String,
        build_request_id: String,
        status: JobStatus,
        target_partitions: Vec<PartitionRef>,
        scheduled_at: i64,
        started_at: Option<i64>,
        completed_at: Option<i64>,
        duration_ms: Option<i64>,
        cancelled: bool,
        message: String,
    ) -> TaskSummary {
        TaskSummary {
            job_run_id,
            job_label,
            build_request_id,
            status_code: status as i32,
            status_name: status.to_display_string(),
            target_partitions,
            scheduled_at,
            started_at,
            completed_at,
            duration_ms,
            cancelled,
            message,
        }
    }

    /// Create a BuildSummary from repository data
    pub fn create_build_summary(
        build_request_id: String,
        status: BuildRequestStatus,
        requested_partitions: Vec<PartitionRef>,
        total_jobs: usize,
        completed_jobs: usize,
        failed_jobs: usize,
        cancelled_jobs: usize,
        requested_at: i64,
        started_at: Option<i64>,
        completed_at: Option<i64>,
        duration_ms: Option<i64>,
        cancelled: bool,
    ) -> BuildSummary {
        BuildSummary {
            build_request_id,
            status_code: status as i32,
            status_name: status.to_display_string(),
            requested_partitions,
            total_jobs: total_jobs as u32,
            completed_jobs: completed_jobs as u32,
            failed_jobs: failed_jobs as u32,
            cancelled_jobs: cancelled_jobs as u32,
            requested_at,
            started_at,
            completed_at,
            duration_ms,
            cancelled,
        }
    }

    /// Create a DataDep with dual fields from repository data
    pub fn create_data_dep(
        dep_type: DepType,
        partition_ref: PartitionRef,
    ) -> DataDep {
        DataDep {
            dep_type_code: dep_type as i32,
            dep_type_name: dep_type.to_display_string(),
            partition_ref: Some(partition_ref),
        }
    }
}

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

    #[test]
    fn test_partition_status_conversions() {
        let status = PartitionStatus::PartitionAvailable;
        assert_eq!(status.to_display_string(), "available");
        assert_eq!(PartitionStatus::from_display_string("available"), Some(status));
    }

    #[test]
    fn test_job_status_conversions() {
        let status = JobStatus::JobCompleted;
        assert_eq!(status.to_display_string(), "completed");
        assert_eq!(JobStatus::from_display_string("completed"), Some(status));
    }

    #[test]
    fn test_build_request_status_conversions() {
        let status = BuildRequestStatus::BuildRequestCompleted;
        assert_eq!(status.to_display_string(), "completed");
        assert_eq!(BuildRequestStatus::from_display_string("completed"), Some(status));
    }

    #[test]
    fn test_dep_type_conversions() {
        let dep_type = DepType::Materialize;
        assert_eq!(dep_type.to_display_string(), "materialize");
        assert_eq!(DepType::from_display_string("materialize"), Some(dep_type));
        
        let dep_type = DepType::Query;
        assert_eq!(dep_type.to_display_string(), "query");
        assert_eq!(DepType::from_display_string("query"), Some(dep_type));
    }

    #[test]
    fn test_invalid_display_string() {
        assert_eq!(PartitionStatus::from_display_string("invalid"), None);
        assert_eq!(JobStatus::from_display_string("invalid"), None);
        assert_eq!(BuildRequestStatus::from_display_string("invalid"), None);
        assert_eq!(DepType::from_display_string("invalid"), None);
    }
}