rustorch 0.6.29

//! Quality Metrics and Assessment System
//! 品質メトリクス・評価システム

use crate::error::{RusTorchError, RusTorchResult};
use std::collections::{HashMap, VecDeque};
use std::fmt;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

/// Quality metrics system for data assessment
/// データ評価のための品質メトリクスシステム
#[derive(Debug)]
pub struct QualityMetrics {
    /// Historical quality assessments
    /// 過去の品質評価
    history: VecDeque<DataQualityAssessment>,
    /// Maximum history size
    /// 最大履歴サイズ
    max_history_size: usize,
    /// Quality thresholds
    /// 品質閾値
    thresholds: MetricThresholds,
    /// Aggregated statistics
    /// 集計統計
    aggregated_stats: AggregatedQualityStats,
}

/// Data quality assessment with comprehensive metrics
/// 包括的メトリクス付きデータ品質評価
#[derive(Debug, Clone)]
pub struct DataQualityAssessment {
    /// Overall quality score (0.0 - 1.0)
    /// 総合品質スコア（0.0 - 1.0）
    pub overall_score: f64,
    /// Individual quality dimensions
    /// 個別品質次元
    pub dimensions: HashMap<QualityDimension, QualityScore>,
    /// Assessment timestamp
    /// 評価タイムスタンプ
    pub timestamp: SystemTime,
    /// Data characteristics
    /// データ特性
    pub characteristics: DataCharacteristics,
    /// Quality trends
    /// 品質トレンド
    pub trends: Option<QualityTrend>,
}

/// Quality dimensions for comprehensive assessment
/// 包括的評価のための品質次元
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum QualityDimension {
    /// Data completeness (no missing values)
    /// データ完全性（欠損値なし）
    Completeness,
    /// Data accuracy (values within expected ranges)
    /// データ正確性（期待範囲内の値）
    Accuracy,
    /// Data consistency (no contradictions)
    /// データ整合性（矛盾なし）
    Consistency,
    /// Data validity (conforms to format/type)
    /// データ有効性（形式/型への適合）
    Validity,
    /// Data uniqueness (no duplicates where expected)
    /// データ一意性（期待される場所での重複なし）
    Uniqueness,
    /// Data timeliness (freshness)
    /// データ適時性（鮮度）
    Timeliness,
    /// Data integrity (structural soundness)
    /// データ整合性（構造的健全性）
    Integrity,
}

/// Quality score with detailed breakdown
/// 詳細分解付き品質スコア
#[derive(Debug, Clone)]
pub struct QualityScore {
    /// Score value (0.0 - 1.0)
    /// スコア値（0.0 - 1.0）
    pub score: f64,
    /// Maximum possible score
    /// 可能な最大スコア
    pub max_score: f64,
    /// Detailed metrics contributing to score
    /// スコアに貢献する詳細メトリクス
    pub metrics: HashMap<String, f64>,
    /// Issues detected in this dimension
    /// この次元で検出された問題
    pub issues: Vec<QualityIssue>,
    /// Confidence level in the assessment
    /// 評価の信頼度
    pub confidence: f64,
}

/// Quality issue with context and remediation
/// コンテキストと修復付き品質問題
#[derive(Debug, Clone)]
pub struct QualityIssue {
    /// Issue category
    /// 問題カテゴリ
    pub category: IssueCategory,
    /// Issue severity
    /// 問題重要度
    pub severity: IssueSeverity,
    /// Description of the issue
    /// 問題の説明
    pub description: String,
    /// Affected data range or location
    /// 影響を受けるデータ範囲または場所
    pub affected_range: Option<DataRange>,
    /// Suggested remediation
    /// 修復提案
    pub remediation: Option<String>,
    /// Impact score on overall quality
    /// 全体品質への影響スコア
    pub impact_score: f64,
}

/// Issue categories for quality problems
/// 品質問題の問題カテゴリ
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum IssueCategory {
    /// Missing or null values
    /// 欠損値またはnull値
    MissingData,
    /// Invalid format or type
    /// 無効な形式または型
    FormatError,
    /// Values outside acceptable range
    /// 許容範囲外の値
    RangeViolation,
    /// Duplicate values where uniqueness expected
    /// 一意性が期待される場所での重複値
    Duplication,
    /// Inconsistent values across related fields
    /// 関連フィールド間での一貫性のない値
    Inconsistency,
    /// Outdated or stale data
    /// 古いまたは陳腐化したデータ
    StalenessIssue,
    /// Statistical anomaly
    /// 統計的異常
    StatisticalAnomaly,
}

/// Issue severity levels
/// 問題重要度レベル
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum IssueSeverity {
    /// Informational - no action required
    /// 情報提供 - アクション不要
    Info,
    /// Low impact on quality
    /// 品質への軽微な影響
    Low,
    /// Medium impact - attention recommended
    /// 中程度の影響 - 注意推奨
    Medium,
    /// High impact - action required
    /// 高い影響 - アクション必要
    High,
    /// Critical - immediate action required
    /// 重要 - 即座のアクション必要
    Critical,
}

/// Data range specification
/// データ範囲仕様
#[derive(Debug, Clone)]
pub struct DataRange {
    /// Start index or position
    /// 開始インデックスまたは位置
    pub start: usize,
    /// End index or position
    /// 終了インデックスまたは位置
    pub end: usize,
    /// Dimension or axis affected
    /// 影響を受ける次元または軸
    pub dimension: Option<usize>,
}

/// Data characteristics for quality assessment
/// 品質評価のためのデータ特性
#[derive(Debug, Clone)]
pub struct DataCharacteristics {
    /// Total data points
    /// 総データポイント数
    pub total_points: usize,
    /// Data type information
    /// データ型情報
    pub data_type: String,
    /// Shape or structure
    /// 形状または構造
    pub shape: Vec<usize>,
    /// Value distribution statistics
    /// 値分布統計
    pub distribution_stats: DistributionStats,
    /// Memory footprint
    /// メモリフットプリント
    pub memory_footprint: usize,
}

/// Distribution statistics for data
/// データの分布統計
#[derive(Debug, Clone)]
pub struct DistributionStats {
    /// Mean value
    /// 平均値
    pub mean: f64,
    /// Standard deviation
    /// 標準偏差
    pub std_dev: f64,
    /// Minimum value
    /// 最小値
    pub min: f64,
    /// Maximum value
    /// 最大値
    pub max: f64,
    /// Percentiles (25th, 50th, 75th, 95th, 99th)
    /// パーセンタイル（25、50、75、95、99番目）
    pub percentiles: HashMap<u8, f64>,
    /// Skewness measure
    /// 歪度測定
    pub skewness: f64,
    /// Kurtosis measure
    /// 尖度測定
    pub kurtosis: f64,
}

/// Quality trend analysis
/// 品質トレンド分析
#[derive(Debug, Clone)]
pub struct QualityTrend {
    /// Trend direction
    /// トレンド方向
    pub direction: TrendDirection,
    /// Trend strength (0.0 - 1.0)
    /// トレンド強度（0.0 - 1.0）
    pub strength: f64,
    /// Rate of change per time unit
    /// 時間単位あたりの変化率
    pub change_rate: f64,
    /// Confidence in trend analysis
    /// トレンド分析の信頼度
    pub confidence: f64,
    /// Prediction for next assessment
    /// 次回評価の予測
    pub prediction: Option<f64>,
}

/// Trend direction enumeration
/// トレンド方向列挙型
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TrendDirection {
    /// Quality is improving
    /// 品質が改善中
    Improving,
    /// Quality is declining
    /// 品質が低下中
    Declining,
    /// Quality is stable
    /// 品質が安定
    Stable,
    /// Trend is volatile/unpredictable
    /// トレンドが不安定/予測不可能
    Volatile,
}

/// Quality metric thresholds for assessment
/// 評価のための品質メトリクス閾値
#[derive(Debug, Clone)]
pub struct MetricThresholds {
    /// Minimum acceptable overall score
    /// 許容可能な最小総合スコア
    pub min_overall_score: f64,
    /// Individual dimension thresholds
    /// 個別次元閾値
    pub dimension_thresholds: HashMap<QualityDimension, f64>,
    /// Maximum allowed issues by severity
    /// 重要度別の最大許容問題数
    pub max_issues_by_severity: HashMap<IssueSeverity, usize>,
}

impl Default for MetricThresholds {
    fn default() -> Self {
        let mut dimension_thresholds = HashMap::new();
        dimension_thresholds.insert(QualityDimension::Completeness, 0.95);
        dimension_thresholds.insert(QualityDimension::Accuracy, 0.9);
        dimension_thresholds.insert(QualityDimension::Consistency, 0.9);
        dimension_thresholds.insert(QualityDimension::Validity, 0.95);
        dimension_thresholds.insert(QualityDimension::Uniqueness, 0.98);
        dimension_thresholds.insert(QualityDimension::Timeliness, 0.8);
        dimension_thresholds.insert(QualityDimension::Integrity, 0.95);

        let mut max_issues = HashMap::new();
        max_issues.insert(IssueSeverity::Critical, 0);
        max_issues.insert(IssueSeverity::High, 2);
        max_issues.insert(IssueSeverity::Medium, 5);
        max_issues.insert(IssueSeverity::Low, 10);
        max_issues.insert(IssueSeverity::Info, 50);

        Self {
            min_overall_score: 0.8,
            dimension_thresholds,
            max_issues_by_severity: max_issues,
        }
    }
}

/// Aggregated quality statistics over time
/// 時間にわたる集計品質統計
#[derive(Debug, Default)]
pub struct AggregatedQualityStats {
    /// Total assessments performed
    /// 実行された総評価数
    pub total_assessments: usize,
    /// Average overall score
    /// 平均総合スコア
    pub average_overall_score: f64,
    /// Best score achieved
    /// 達成された最高スコア
    pub best_score: f64,
    /// Worst score recorded
    /// 記録された最低スコア
    pub worst_score: f64,
    /// Score variance
    /// スコア分散
    pub score_variance: f64,
    /// Quality stability measure
    /// 品質安定性測定
    pub stability_measure: f64,
}

impl QualityMetrics {
    /// Create new quality metrics system
    /// 新しい品質メトリクスシステムを作成
    pub fn new() -> Self {
        Self {
            history: VecDeque::new(),
            max_history_size: 1000,
            thresholds: MetricThresholds::default(),
            aggregated_stats: AggregatedQualityStats::default(),
        }
    }

    /// Assess data quality for a tensor
    /// テンソルのデータ品質を評価
    pub fn assess_quality<T>(
        &mut self,
        tensor: &crate::tensor::Tensor<T>,
    ) -> RusTorchResult<DataQualityAssessment>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        let start_time = Instant::now();

        // Collect basic data characteristics
        let characteristics = self.collect_data_characteristics(tensor);

        // Assess each quality dimension
        let mut dimensions = HashMap::new();

        // Completeness assessment
        dimensions.insert(
            QualityDimension::Completeness,
            self.assess_completeness(tensor, &characteristics)?,
        );

        // Accuracy assessment
        dimensions.insert(
            QualityDimension::Accuracy,
            self.assess_accuracy(tensor, &characteristics)?,
        );

        // Consistency assessment
        dimensions.insert(
            QualityDimension::Consistency,
            self.assess_consistency(tensor, &characteristics)?,
        );

        // Validity assessment
        dimensions.insert(
            QualityDimension::Validity,
            self.assess_validity(tensor, &characteristics)?,
        );

        // Uniqueness assessment
        dimensions.insert(
            QualityDimension::Uniqueness,
            self.assess_uniqueness(tensor, &characteristics)?,
        );

        // Timeliness assessment
        dimensions.insert(
            QualityDimension::Timeliness,
            self.assess_timeliness(&characteristics)?,
        );

        // Integrity assessment
        dimensions.insert(
            QualityDimension::Integrity,
            self.assess_integrity(tensor, &characteristics)?,
        );

        // Calculate overall score
        let overall_score = self.calculate_overall_score(&dimensions);

        // Analyze trends if history exists
        let trends = if self.history.len() > 2 {
            Some(self.analyze_trends(&overall_score))
        } else {
            None
        };

        let assessment = DataQualityAssessment {
            overall_score,
            dimensions,
            timestamp: SystemTime::now(),
            characteristics,
            trends,
        };

        // Update history
        self.history.push_back(assessment.clone());
        if self.history.len() > self.max_history_size {
            self.history.pop_front();
        }

        // Update aggregated statistics
        self.update_aggregated_stats(&assessment);

        println!(
            "📊 Quality assessment completed in {:.2}ms, score: {:.3}",
            start_time.elapsed().as_secs_f64() * 1000.0,
            overall_score
        );

        Ok(assessment)
    }

    /// Collect basic data characteristics
    /// 基本データ特性を収集
    fn collect_data_characteristics<T>(
        &self,
        tensor: &crate::tensor::Tensor<T>,
    ) -> DataCharacteristics
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        let shape = tensor.shape();
        let total_points = shape.iter().product();

        // Placeholder distribution stats - would implement actual calculation
        let distribution_stats = DistributionStats {
            mean: 0.0,
            std_dev: 1.0,
            min: -1.0,
            max: 1.0,
            percentiles: {
                let mut percentiles = HashMap::new();
                percentiles.insert(25, -0.5);
                percentiles.insert(50, 0.0);
                percentiles.insert(75, 0.5);
                percentiles.insert(95, 0.9);
                percentiles.insert(99, 0.99);
                percentiles
            },
            skewness: 0.0,
            kurtosis: 3.0,
        };

        DataCharacteristics {
            total_points,
            data_type: std::any::type_name::<T>().to_string(),
            shape: shape.to_vec(),
            distribution_stats,
            memory_footprint: total_points * std::mem::size_of::<T>(),
        }
    }

    /// Assess data completeness
    /// データ完全性を評価
    fn assess_completeness<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Placeholder implementation - would check for NaN, null, missing values
        let nan_count = 0; // Would implement actual NaN counting
        let total_points = characteristics.total_points;
        let completeness_ratio = if total_points > 0 {
            (total_points - nan_count) as f64 / total_points as f64
        } else {
            1.0
        };

        let mut metrics = HashMap::new();
        metrics.insert("completeness_ratio".to_string(), completeness_ratio);
        metrics.insert("missing_values".to_string(), nan_count as f64);

        let mut issues = Vec::new();
        if completeness_ratio
            < self.thresholds.dimension_thresholds[&QualityDimension::Completeness]
        {
            issues.push(QualityIssue {
                category: IssueCategory::MissingData,
                severity: IssueSeverity::Medium,
                description: format!(
                    "Completeness ratio {:.3} below threshold {:.3}",
                    completeness_ratio,
                    self.thresholds.dimension_thresholds[&QualityDimension::Completeness]
                ),
                affected_range: None,
                remediation: Some("Consider imputation or data cleaning".to_string()),
                impact_score: 1.0 - completeness_ratio,
            });
        }

        Ok(QualityScore {
            score: completeness_ratio,
            max_score: 1.0,
            metrics,
            issues,
            confidence: 0.95,
        })
    }

    /// Assess data accuracy
    /// データ正確性を評価
    fn assess_accuracy<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Placeholder implementation - would check value ranges, outliers
        let stats = &characteristics.distribution_stats;
        let range_violations = 0; // Would implement actual range checking
        let accuracy_score = 1.0 - (range_violations as f64 / characteristics.total_points as f64);

        let mut metrics = HashMap::new();
        metrics.insert("accuracy_score".to_string(), accuracy_score);
        metrics.insert("range_violations".to_string(), range_violations as f64);
        metrics.insert("value_range_width".to_string(), stats.max - stats.min);

        Ok(QualityScore {
            score: accuracy_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 0.9,
        })
    }

    /// Assess data consistency
    /// データ整合性を評価
    fn assess_consistency<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        _characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Placeholder implementation - would check for internal contradictions
        let consistency_score = 0.95; // Placeholder

        let mut metrics = HashMap::new();
        metrics.insert("consistency_score".to_string(), consistency_score);

        Ok(QualityScore {
            score: consistency_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 0.85,
        })
    }

    /// Assess data validity
    /// データ有効性を評価
    fn assess_validity<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Check for valid tensor shape and type
        let has_valid_shape = !characteristics.shape.is_empty();
        let validity_score = if has_valid_shape { 1.0 } else { 0.0 };

        let mut metrics = HashMap::new();
        metrics.insert(
            "valid_shape".to_string(),
            if has_valid_shape { 1.0 } else { 0.0 },
        );

        Ok(QualityScore {
            score: validity_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 1.0,
        })
    }

    /// Assess data uniqueness
    /// データ一意性を評価
    fn assess_uniqueness<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Placeholder implementation - would check for duplicate values
        let duplicates = 0; // Would implement actual duplicate detection
        let uniqueness_score = if characteristics.total_points > 0 {
            1.0 - (duplicates as f64 / characteristics.total_points as f64)
        } else {
            1.0
        };

        let mut metrics = HashMap::new();
        metrics.insert("uniqueness_score".to_string(), uniqueness_score);
        metrics.insert("duplicate_count".to_string(), duplicates as f64);

        Ok(QualityScore {
            score: uniqueness_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 0.8,
        })
    }

    /// Assess data timeliness
    /// データ適時性を評価
    fn assess_timeliness(
        &self,
        _characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore> {
        // Placeholder implementation - would check data freshness
        let timeliness_score = 0.9; // Assume relatively fresh data

        let mut metrics = HashMap::new();
        metrics.insert("timeliness_score".to_string(), timeliness_score);

        Ok(QualityScore {
            score: timeliness_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 0.7,
        })
    }

    /// Assess data integrity
    /// データ整合性を評価
    fn assess_integrity<T>(
        &self,
        _tensor: &crate::tensor::Tensor<T>,
        characteristics: &DataCharacteristics,
    ) -> RusTorchResult<QualityScore>
    where
        T: num_traits::Float + std::fmt::Debug + Clone + Send + Sync + 'static,
    {
        // Check structural integrity
        let has_valid_structure =
            !characteristics.shape.is_empty() && characteristics.total_points > 0;
        let integrity_score = if has_valid_structure { 1.0 } else { 0.0 };

        let mut metrics = HashMap::new();
        metrics.insert(
            "structural_integrity".to_string(),
            if has_valid_structure { 1.0 } else { 0.0 },
        );

        Ok(QualityScore {
            score: integrity_score,
            max_score: 1.0,
            metrics,
            issues: Vec::new(),
            confidence: 0.95,
        })
    }

    /// Calculate overall quality score from dimensions
    /// 次元から総合品質スコアを計算
    fn calculate_overall_score(&self, dimensions: &HashMap<QualityDimension, QualityScore>) -> f64 {
        let weights: HashMap<QualityDimension, f64> = [
            (QualityDimension::Completeness, 0.2),
            (QualityDimension::Accuracy, 0.2),
            (QualityDimension::Consistency, 0.15),
            (QualityDimension::Validity, 0.15),
            (QualityDimension::Uniqueness, 0.1),
            (QualityDimension::Timeliness, 0.1),
            (QualityDimension::Integrity, 0.1),
        ]
        .iter()
        .cloned()
        .collect();

        let mut weighted_sum = 0.0;
        let mut total_weight = 0.0;

        for (dimension, score) in dimensions {
            if let Some(&weight) = weights.get(dimension) {
                weighted_sum += score.score * weight;
                total_weight += weight;
            }
        }

        if total_weight > 0.0 {
            weighted_sum / total_weight
        } else {
            0.0
        }
    }

    /// Analyze quality trends over time
    /// 時間経過による品質トレンドを分析
    fn analyze_trends(&self, _current_score: &f64) -> QualityTrend {
        // Placeholder implementation - would perform actual trend analysis
        QualityTrend {
            direction: TrendDirection::Stable,
            strength: 0.1,
            change_rate: 0.001,
            confidence: 0.7,
            prediction: None,
        }
    }

    /// Update aggregated statistics
    /// 集計統計を更新
    fn update_aggregated_stats(&mut self, assessment: &DataQualityAssessment) {
        self.aggregated_stats.total_assessments += 1;

        let count = self.aggregated_stats.total_assessments as f64;
        let old_mean = self.aggregated_stats.average_overall_score;
        let new_score = assessment.overall_score;

        // Update running average
        self.aggregated_stats.average_overall_score = old_mean + (new_score - old_mean) / count;

        // Update best/worst scores
        if self.aggregated_stats.total_assessments == 1 {
            self.aggregated_stats.best_score = new_score;
            self.aggregated_stats.worst_score = new_score;
        } else {
            self.aggregated_stats.best_score = self.aggregated_stats.best_score.max(new_score);
            self.aggregated_stats.worst_score = self.aggregated_stats.worst_score.min(new_score);
        }

        // Update variance (simplified calculation)
        let variance_delta =
            (new_score - old_mean) * (new_score - self.aggregated_stats.average_overall_score);
        self.aggregated_stats.score_variance =
            (self.aggregated_stats.score_variance * (count - 1.0) + variance_delta) / count;

        // Update stability measure
        self.aggregated_stats.stability_measure = 1.0 - self.aggregated_stats.score_variance.sqrt();
    }

    /// Get quality metrics history
    /// 品質メトリクス履歴を取得
    pub fn get_history(&self) -> &VecDeque<DataQualityAssessment> {
        &self.history
    }

    /// Get aggregated statistics
    /// 集計統計を取得
    pub fn get_aggregated_stats(&self) -> &AggregatedQualityStats {
        &self.aggregated_stats
    }
}

impl DataQualityAssessment {
    /// Get quality grade as a letter
    /// 品質グレードを文字で取得
    pub fn quality_grade(&self) -> &str {
        match self.overall_score {
            s if s >= 0.95 => "A+",
            s if s >= 0.9 => "A",
            s if s >= 0.85 => "A-",
            s if s >= 0.8 => "B+",
            s if s >= 0.75 => "B",
            s if s >= 0.7 => "B-",
            s if s >= 0.65 => "C+",
            s if s >= 0.6 => "C",
            s if s >= 0.5 => "C-",
            s if s >= 0.4 => "D",
            _ => "F",
        }
    }
}

impl fmt::Display for DataQualityAssessment {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "📊 Data Quality Assessment\n\
             ==========================\n\
             Overall Score: {:.3} (Grade: {})\n\
             Total Points: {}\n\
             Dimensions Assessed: {}\n\
             Timestamp: {:?}",
            self.overall_score,
            self.quality_grade(),
            self.characteristics.total_points,
            self.dimensions.len(),
            self.timestamp
        )
    }
}