//! The engine actor's inbound message/query types and its outbound response type.

use crate::api::dto::{
    BucketValueDto, LogEntryDto, LogsParams, MetricDeclarationDto, ParamDeclarationDto,
    PromqlSeriesDto, StatsDto, TimelineBucketDto, TimelineParams,
};
use crate::engine::{ClearParamsResult, DeclareMetricRequest, DeclareParamRequest, IngestedLine, MetricSample};
use std::collections::BTreeMap;
use tokio::sync::oneshot;

#[allow(dead_code)]
pub enum EngineQuery {
    Logs(LogsParams),
    Timeline(TimelineParams),
    Stats,
    ParamDeclarations,
    MetricDeclarations,
    BucketValues {
        metric_name: String,
        labels_filter: Option<BTreeMap<String, String>>,
        start_ms: Option<i64>,
        end_ms: Option<i64>,
        since_sequence: Option<u64>,
        limit: Option<usize>,
    },
    Promql { query: String, start_ms: Option<i64>, end_ms: Option<i64> },
}

#[allow(dead_code)]
pub enum EngineMessage {
    Ingest(IngestedLine),
    IngestMetricSample(MetricSample),
    DeclareParam {
        request: DeclareParamRequest,
        respond_to: oneshot::Sender<Result<(), String>>,
    },
    RemoveParamDeclaration {
        name: String,
        respond_to: oneshot::Sender<bool>,
    },
    ClearParams {
        respond_to: oneshot::Sender<ClearParamsResult>,
    },
    DeclareMetric {
        request: DeclareMetricRequest,
        respond_to: oneshot::Sender<Result<(), String>>,
    },
    UpdateMetric {
        name: String,
        request: DeclareMetricRequest,
        respond_to: oneshot::Sender<Result<(), String>>,
    },
    RemoveMetricDeclaration {
        name: String,
        respond_to: oneshot::Sender<bool>,
    },
    SetMaxLogs(Option<usize>),
    EnsureSortHelperIndex {
        param_name: String,
        respond_to: oneshot::Sender<()>,
    },
    Barrier(oneshot::Sender<()>),
}

#[allow(dead_code)]
pub enum EngineResponse {
    Logs(Vec<LogEntryDto>),
    Timeline(Vec<TimelineBucketDto>),
    Stats(StatsDto),
    ParamDeclarations(Vec<ParamDeclarationDto>),
    MetricDeclarations(Vec<MetricDeclarationDto>),
    BucketValues(Vec<BucketValueDto>),
    Promql(Result<Vec<PromqlSeriesDto>, String>),
    Error(String),
}

impl EngineQuery {
    pub(crate) fn sort_by(&self) -> Option<&str> {
        match self {
            EngineQuery::Logs(params) => params.sort_by.as_deref(),
            _ => None,
        }
    }
}