reasoninglayer 0.2.1

//! Row polymorphism DTOs.

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FeatureTypeDto {
    String,
    Integer,
    Real,
    Boolean,
    Reference,
    Any,
}

/// Value pattern for matching.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ValuePatternDto {
    Any,
    OfType { feature_type: FeatureTypeDto },
    Exact { value: serde_json::Value },
    GreaterThan { value: serde_json::Value },
    LessThan { value: serde_json::Value },
    Contains { substring: String },
    Regex { pattern: String },
    Bind { variable: String },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FeatureRequirementDto {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub feature_type: Option<FeatureTypeDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowTypeDto {
    pub features: Vec<FeatureRequirementDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub open: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowMatchDto {
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
    pub id: String,
    pub similarity: f64,
    pub sort_id: String,
    pub sort_name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowSearchRequest {
    pub pattern: RowTypeDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub collection_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RowSearchResponse {
    #[serde(default)]
    pub matches: Vec<RowMatchDto>,
    pub scanned: u64,
    pub sorts_matched: u64,
    pub duration_us: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowUnifyRequest {
    pub row1: RowTypeDto,
    pub row2: RowTypeDto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowUnifyResponse {
    pub success: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unified: Option<RowTypeDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowSimilarityRequest {
    pub row1: RowTypeDto,
    pub row2: RowTypeDto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowSimilarityResponse {
    pub similarity: f64,
    #[serde(default)]
    pub shared_features: Vec<String>,
    #[serde(default)]
    pub only_in_row1: Vec<String>,
    #[serde(default)]
    pub only_in_row2: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RowIntegrateRequest {
    pub match_features: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub merge_features: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_similarity: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_namespaces: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub create_merged: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntegrationGroupDto {
    #[serde(default)]
    pub entities: Vec<RowMatchDto>,
    pub group_similarity: f64,
    #[serde(default)]
    pub match_key: BTreeMap<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub merged_entity_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub merged_features: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RowIntegrateResponse {
    #[serde(default)]
    pub integration_groups: Vec<IntegrationGroupDto>,
    pub entities_analyzed: u64,
    pub groups_found: u64,
    pub duration_us: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicQueryClauseDto {
    pub feature: String,
    pub pattern: ValuePatternDto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicQueryResultDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bindings: Option<BTreeMap<String, serde_json::Value>>,
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
    pub id: String,
    pub sort_name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicQueryGroupDto {
    pub count: u64,
    #[serde(default)]
    pub entities: Vec<DynamicQueryResultDto>,
    #[serde(default)]
    pub key: BTreeMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicQueryRequest {
    pub clauses: Vec<DynamicQueryClauseDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub open: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub project: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group_by: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub descending: Option<bool>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DynamicQueryResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub results: Option<Vec<DynamicQueryResultDto>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub groups: Option<Vec<DynamicQueryGroupDto>>,
    pub total_matches: u64,
    pub duration_us: u64,
}