gitstack/

stats.rs

//! 統計情報モジュール
//!
//! リポジトリの著者別統計やファイル変更頻度を計算する

use chrono::{DateTime, Local};
use std::collections::HashMap;

use crate::event::GitEvent;

// =============================================================================
// Quality Score
// =============================================================================

/// コミット品質スコア
#[derive(Debug, Clone)]
pub struct CommitQualityScore {
    /// コミットハッシュ
    pub commit_hash: String,
    /// コミットメッセージ
    pub commit_message: String,
    /// 著者
    pub author: String,
    /// 日付
    pub date: DateTime<Local>,
    /// 変更ファイル数
    pub files_changed: usize,
    /// 追加行数
    pub insertions: usize,
    /// 削除行数
    pub deletions: usize,
    /// 総合スコア (0.0〜1.0)
    pub score: f64,
    /// メッセージ品質要素 (0.0〜0.3)
    pub message_score: f64,
    /// サイズ適切性要素 (0.0〜0.25)
    pub size_score: f64,
    /// テスト包含要素 (0.0〜0.25)
    pub test_score: f64,
    /// 原子性要素 (0.0〜0.2)
    pub atomicity_score: f64,
}

impl CommitQualityScore {
    /// スコアに応じた色を取得
    pub fn score_color(&self) -> &'static str {
        if self.score >= 0.6 {
            "green" // Excellent/Good
        } else if self.score >= 0.4 {
            "yellow" // Fair
        } else {
            "red" // Poor
        }
    }

    /// スコアバーを生成（5段階）
    pub fn score_bar(&self) -> &'static str {
        if self.score >= 0.8 {
            "█████"
        } else if self.score >= 0.6 {
            "████ "
        } else if self.score >= 0.4 {
            "███  "
        } else if self.score >= 0.2 {
            "██   "
        } else {
            "█    "
        }
    }

    /// 品質レベルの文字列を取得
    pub fn quality_level(&self) -> &'static str {
        if self.score >= 0.8 {
            "Excellent"
        } else if self.score >= 0.6 {
            "Good"
        } else if self.score >= 0.4 {
            "Fair"
        } else {
            "Poor"
        }
    }
}

/// Quality Score分析結果
#[derive(Debug, Clone, Default)]
pub struct CommitQualityAnalysis {
    /// コミット一覧（スコア降順）
    pub commits: Vec<CommitQualityScore>,
    /// 総コミット数
    pub total_commits: usize,
    /// 平均スコア
    pub avg_score: f64,
    /// 高品質コミット数（スコア >= 0.6）
    pub high_quality_count: usize,
    /// 低品質コミット数（スコア < 0.4）
    pub low_quality_count: usize,
}

impl CommitQualityAnalysis {
    /// コミット数を取得
    pub fn commit_count(&self) -> usize {
        self.commits.len()
    }
}

/// メッセージ品質を計算 (0.0〜1.0)
///
/// 評価基準:
/// - Conventional Commit形式: 40%
/// - 長さ（10-72文字）: 30%
/// - 意味のある内容: 30%
fn calculate_message_quality(message: &str) -> f64 {
    let mut score = 0.0;

    // Conventional Commit形式チェック（40%）
    let conventional_prefixes = [
        "feat:",
        "fix:",
        "docs:",
        "style:",
        "refactor:",
        "test:",
        "chore:",
        "perf:",
        "ci:",
        "build:",
        "revert:",
    ];
    let has_conventional_prefix = conventional_prefixes
        .iter()
        .any(|prefix| message.to_lowercase().starts_with(prefix));
    if has_conventional_prefix {
        score += 0.4;
    }

    // 長さチェック（30%）
    let len = message.len();
    if (10..=72).contains(&len) {
        score += 0.3;
    } else if (5..=100).contains(&len) {
        // 許容範囲内だが最適ではない
        score += 0.15;
    }

    // 意味のある内容チェック（30%）
    let meaningless_patterns = ["update", "fix", "wip", "changes", "commit", "test", "."];
    let trimmed = message.trim().to_lowercase();
    let is_meaningful = !meaningless_patterns.contains(&trimmed.as_str())
        && message.trim().len() > 3
        && !message.trim().chars().all(|c| !c.is_alphabetic());
    if is_meaningful {
        score += 0.3;
    }

    score
}

/// サイズ適切性を計算 (0.0〜1.0)
///
/// 評価基準:
/// - ファイル数（1-5が理想）
/// - 変更行数（10-200が理想）
fn calculate_size_appropriateness(
    files_changed: usize,
    insertions: usize,
    deletions: usize,
) -> f64 {
    let mut score = 0.0;

    // ファイル数スコア（50%）
    let file_score = if files_changed == 0 {
        0.0
    } else if files_changed <= 5 {
        0.5
    } else if files_changed <= 10 {
        0.3
    } else if files_changed <= 20 {
        0.1
    } else {
        0.0
    };
    score += file_score;

    // 変更行数スコア（50%）
    let total_changes = insertions + deletions;
    let change_score = if total_changes == 0 {
        0.0
    } else if (10..=200).contains(&total_changes) {
        0.5
    } else if (1..=500).contains(&total_changes) {
        0.3
    } else if total_changes <= 1000 {
        0.1
    } else {
        0.0
    };
    score += change_score;

    score
}

/// テスト包含を計算 (0.0〜1.0)
///
/// 評価基準:
/// - ソースファイルとテストファイルの両方を含むか
fn calculate_test_presence(files: &[String]) -> f64 {
    if files.is_empty() {
        return 0.0;
    }

    let has_source = files.iter().any(|f| {
        let f_lower = f.to_lowercase();
        !f_lower.contains("test")
            && !f_lower.contains("spec")
            && (f_lower.ends_with(".rs")
                || f_lower.ends_with(".ts")
                || f_lower.ends_with(".js")
                || f_lower.ends_with(".py")
                || f_lower.ends_with(".go")
                || f_lower.ends_with(".java")
                || f_lower.ends_with(".rb")
                || f_lower.ends_with(".c")
                || f_lower.ends_with(".cpp")
                || f_lower.ends_with(".h"))
    });

    let has_test = files.iter().any(|f| {
        let f_lower = f.to_lowercase();
        f_lower.contains("test")
            || f_lower.contains("spec")
            || f_lower.contains("_test.")
            || f_lower.contains(".test.")
    });

    if has_source && has_test {
        1.0 // 両方あり
    } else if has_test {
        0.8 // テストのみ（テストコードの修正など）
    } else if has_source {
        0.3 // ソースのみ（テストなし）
    } else {
        0.5 // ドキュメントや設定ファイルのみ
    }
}

/// 原子性を計算 (0.0〜1.0)
///
/// 評価基準:
/// - 変更ファイルが同ディレクトリに集中しているか
/// - Change Couplingによる結合度
fn calculate_atomicity(files: &[String], coupling: &ChangeCouplingAnalysis) -> f64 {
    if files.is_empty() {
        return 0.0;
    }

    if files.len() == 1 {
        return 1.0; // 単一ファイルは完全に原子的
    }

    // ディレクトリ集中度（50%）
    let dirs: std::collections::HashSet<&str> =
        files.iter().filter_map(|f| f.rsplit('/').nth(1)).collect();
    let dir_score = if dirs.len() == 1 {
        0.5 // 全ファイルが同じディレクトリ
    } else if dirs.len() <= 2 {
        0.35
    } else if dirs.len() <= 3 {
        0.2
    } else {
        0.1
    };

    // 結合度スコア（50%）
    // ファイル間の結合度が高いほど、一緒に変更されることが多い → 原子的
    let mut coupling_sum = 0.0;
    let mut coupling_count = 0;

    for file in files {
        for other_file in files {
            if file != other_file {
                // coupling.couplingsからfileとother_fileのペアを探す
                if let Some(c) = coupling
                    .couplings
                    .iter()
                    .find(|c| &c.file == file && &c.coupled_file == other_file)
                {
                    coupling_sum += c.coupling_percent;
                    coupling_count += 1;
                }
            }
        }
    }

    let coupling_score = if coupling_count > 0 {
        (coupling_sum / coupling_count as f64) * 0.5
    } else {
        0.25 // 結合情報がない場合はデフォルト値
    };

    dir_score + coupling_score
}

/// Quality Scoreを計算
///
/// 計算式:
/// - メッセージ品質: 30%
/// - サイズ適切性: 25%
/// - テスト包含: 25%
/// - 原子性: 20%
pub fn calculate_quality_scores(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
    coupling: &ChangeCouplingAnalysis,
) -> CommitQualityAnalysis {
    let mut commits = Vec::new();
    let mut total_score = 0.0;
    let mut high_quality_count = 0;
    let mut low_quality_count = 0;

    for event in events {
        let files = get_files(&event.short_hash).unwrap_or_default();

        // 各スコア要素を計算
        let message_score = calculate_message_quality(&event.message) * 0.30;
        let size_score =
            calculate_size_appropriateness(files.len(), event.files_added, event.files_deleted)
                * 0.25;
        let test_score = calculate_test_presence(&files) * 0.25;
        let atomicity_score = calculate_atomicity(&files, coupling) * 0.20;

        // 総合スコア
        let score = message_score + size_score + test_score + atomicity_score;

        commits.push(CommitQualityScore {
            commit_hash: event.short_hash.clone(),
            commit_message: event.message.clone(),
            author: event.author.clone(),
            date: event.timestamp,
            files_changed: files.len(),
            insertions: event.files_added,
            deletions: event.files_deleted,
            score,
            message_score,
            size_score,
            test_score,
            atomicity_score,
        });

        total_score += score;
        if score >= 0.6 {
            high_quality_count += 1;
        }
        if score < 0.4 {
            low_quality_count += 1;
        }
    }

    // スコア降順でソート
    commits.sort_by(|a, b| {
        b.score
            .partial_cmp(&a.score)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    let total_commits = commits.len();
    let avg_score = if total_commits > 0 {
        total_score / total_commits as f64
    } else {
        0.0
    };

    CommitQualityAnalysis {
        commits,
        total_commits,
        avg_score,
        high_quality_count,
        low_quality_count,
    }
}

// =============================================================================
// Impact Score
// =============================================================================

/// コミットのImpact Score（影響度スコア）
#[derive(Debug, Clone)]
pub struct CommitImpactScore {
    /// コミットハッシュ
    pub commit_hash: String,
    /// コミットメッセージ
    pub commit_message: String,
    /// 著者
    pub author: String,
    /// 日付
    pub date: DateTime<Local>,
    /// 変更ファイル数
    pub files_changed: usize,
    /// 追加行数
    pub insertions: usize,
    /// 削除行数
    pub deletions: usize,
    /// 総合スコア (0.0〜1.0)
    pub score: f64,
    /// ファイル数要素 (0.0〜0.4)
    pub file_score: f64,
    /// 変更行数要素 (0.0〜0.4)
    pub change_score: f64,
    /// ファイル重要度要素 (0.0〜0.2)
    pub heat_score: f64,
}

impl CommitImpactScore {
    /// スコアに応じた色を取得
    pub fn score_color(&self) -> &'static str {
        if self.score >= 0.7 {
            "red" // High Impact
        } else if self.score >= 0.4 {
            "yellow" // Medium Impact
        } else {
            "green" // Low Impact
        }
    }

    /// スコアバーを生成（5段階）
    pub fn score_bar(&self) -> &'static str {
        if self.score >= 0.8 {
            "█████"
        } else if self.score >= 0.6 {
            "████ "
        } else if self.score >= 0.4 {
            "███  "
        } else if self.score >= 0.2 {
            "██   "
        } else {
            "█    "
        }
    }
}

/// Impact Score分析結果
#[derive(Debug, Clone, Default)]
pub struct CommitImpactAnalysis {
    /// コミット一覧（スコア降順）
    pub commits: Vec<CommitImpactScore>,
    /// 総コミット数
    pub total_commits: usize,
    /// 平均スコア
    pub avg_score: f64,
    /// 最大スコア
    pub max_score: f64,
    /// High Impact（スコア >= 0.7）のコミット数
    pub high_impact_count: usize,
}

impl CommitImpactAnalysis {
    /// コミット数を取得
    pub fn commit_count(&self) -> usize {
        self.commits.len()
    }
}

/// Impact Scoreを計算
///
/// 計算式:
/// - ファイル数要素: (files_changed / 50).min(1.0) * 0.4
/// - 変更行数要素: (total_changes / 500).min(1.0) * 0.4
/// - ファイル重要度要素: avg_file_heat * 0.2
pub fn calculate_impact_scores(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
    file_heatmap: &FileHeatmap,
) -> CommitImpactAnalysis {
    let mut commits = Vec::new();
    let mut total_score = 0.0;
    let mut max_score = 0.0f64;
    let mut high_impact_count = 0;

    // ファイルパスからヒート値を取得するためのマップを作成
    let heat_map: HashMap<&str, f64> = file_heatmap
        .files
        .iter()
        .map(|f| (f.path.as_str(), f.heat_level()))
        .collect();

    for event in events {
        let files = get_files(&event.short_hash).unwrap_or_default();
        let files_changed = files.len();
        let total_changes = event.files_added + event.files_deleted;

        // ファイル数要素 (40%)
        let file_score = (files_changed as f64 / 50.0).min(1.0) * 0.4;

        // 変更行数要素 (40%)
        let change_score = (total_changes as f64 / 500.0).min(1.0) * 0.4;

        // ファイル重要度要素 (20%)
        let avg_file_heat = if files.is_empty() {
            0.0
        } else {
            let total_heat: f64 = files
                .iter()
                .map(|f| heat_map.get(f.as_str()).copied().unwrap_or(0.0))
                .sum();
            total_heat / files.len() as f64
        };
        let heat_score = avg_file_heat * 0.2;

        // 総合スコア
        let score = file_score + change_score + heat_score;

        commits.push(CommitImpactScore {
            commit_hash: event.short_hash.clone(),
            commit_message: event.message.clone(),
            author: event.author.clone(),
            date: event.timestamp,
            files_changed,
            insertions: event.files_added,
            deletions: event.files_deleted,
            score,
            file_score,
            change_score,
            heat_score,
        });

        total_score += score;
        max_score = max_score.max(score);
        if score >= 0.7 {
            high_impact_count += 1;
        }
    }

    // スコア降順でソート
    commits.sort_by(|a, b| {
        b.score
            .partial_cmp(&a.score)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    let total_commits = commits.len();
    let avg_score = if total_commits > 0 {
        total_score / total_commits as f64
    } else {
        0.0
    };

    CommitImpactAnalysis {
        commits,
        total_commits,
        avg_score,
        max_score,
        high_impact_count,
    }
}

// =============================================================================
// Change Coupling
// =============================================================================

/// ファイル間の共変更関係（Change Coupling）
#[derive(Debug, Clone)]
pub struct FileCoupling {
    /// 対象ファイル
    pub file: String,
    /// 結合先ファイル
    pub coupled_file: String,
    /// 共変更回数
    pub co_change_count: usize,
    /// 対象ファイルの総変更回数
    pub file_change_count: usize,
    /// 結合度（0.0-1.0）
    pub coupling_percent: f64,
}

impl FileCoupling {
    /// 結合度バーを生成（10段階）
    pub fn coupling_bar(&self) -> String {
        let filled = (self.coupling_percent * 10.0).round() as usize;
        let empty = 10 - filled;
        format!("[{}{}]", "█".repeat(filled), "░".repeat(empty))
    }
}

/// Change Coupling分析結果
#[derive(Debug, Clone, Default)]
pub struct ChangeCouplingAnalysis {
    /// ファイル間の結合関係（結合度順）
    pub couplings: Vec<FileCoupling>,
    /// 高結合（70%以上）の数
    pub high_coupling_count: usize,
    /// 分析されたファイル数
    pub total_files_analyzed: usize,
}

impl ChangeCouplingAnalysis {
    /// 結合数を取得
    pub fn coupling_count(&self) -> usize {
        self.couplings.len()
    }

    /// ファイル別にグループ化された結合を取得
    pub fn grouped_by_file(&self) -> Vec<(&str, Vec<&FileCoupling>)> {
        use std::collections::HashMap;
        let mut groups: HashMap<&str, Vec<&FileCoupling>> = HashMap::new();
        for coupling in &self.couplings {
            groups.entry(&coupling.file).or_default().push(coupling);
        }
        let mut result: Vec<_> = groups.into_iter().collect();
        // ファイルの総変更回数でソート（降順）
        result.sort_by(|a, b| {
            let count_a = a.1.first().map(|c| c.file_change_count).unwrap_or(0);
            let count_b = b.1.first().map(|c| c.file_change_count).unwrap_or(0);
            count_b.cmp(&count_a)
        });
        result
    }
}

/// Change Coupling（共変更関係）を計算
///
/// # Arguments
/// * `events` - コミットイベント一覧
/// * `get_files` - コミットハッシュからファイル一覧を取得するクロージャ
/// * `min_commits` - 最低コミット数（これ未満のファイルは除外）
/// * `min_coupling` - 最低結合度（これ未満の結合は除外）
///
/// # Returns
/// Change Coupling分析結果
pub fn calculate_change_coupling(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
    min_commits: usize,
    min_coupling: f64,
) -> ChangeCouplingAnalysis {
    use std::collections::{HashMap, HashSet};

    // 1. 各ファイルの変更回数をカウント
    let mut file_change_counts: HashMap<String, usize> = HashMap::new();

    // 2. 各コミットのファイル一覧を収集
    let mut commit_files: Vec<HashSet<String>> = Vec::new();

    for event in events {
        if let Some(files) = get_files(&event.short_hash) {
            let file_set: HashSet<String> = files.iter().cloned().collect();
            for file in &file_set {
                *file_change_counts.entry(file.clone()).or_insert(0) += 1;
            }
            commit_files.push(file_set);
        }
    }

    // 3. ファイルペアごとの共変更回数をカウント
    let mut pair_counts: HashMap<(String, String), usize> = HashMap::new();

    for files in &commit_files {
        let files_vec: Vec<_> = files.iter().collect();
        for i in 0..files_vec.len() {
            for j in (i + 1)..files_vec.len() {
                let file_a = files_vec[i].clone();
                let file_b = files_vec[j].clone();
                // 両方向で記録（A→BとB→A）
                *pair_counts
                    .entry((file_a.clone(), file_b.clone()))
                    .or_insert(0) += 1;
                *pair_counts.entry((file_b, file_a)).or_insert(0) += 1;
            }
        }
    }

    // 4. 結合度を計算してフィルタリング
    let mut couplings: Vec<FileCoupling> = Vec::new();
    let mut high_coupling_count = 0;
    let mut analyzed_files: HashSet<String> = HashSet::new();

    for ((file, coupled_file), co_change_count) in &pair_counts {
        let file_change_count = *file_change_counts.get(file).unwrap_or(&0);

        // min_commits以上の変更があるファイルのみ対象
        if file_change_count < min_commits {
            continue;
        }

        let coupling_percent = *co_change_count as f64 / file_change_count as f64;

        // min_coupling以上の結合度のみ対象
        if coupling_percent < min_coupling {
            continue;
        }

        analyzed_files.insert(file.clone());

        if coupling_percent >= 0.7 {
            high_coupling_count += 1;
        }

        couplings.push(FileCoupling {
            file: file.clone(),
            coupled_file: coupled_file.clone(),
            co_change_count: *co_change_count,
            file_change_count,
            coupling_percent,
        });
    }

    // 5. 結合度の高い順にソート
    couplings.sort_by(|a, b| {
        b.coupling_percent
            .partial_cmp(&a.coupling_percent)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    // 高結合は重複カウントを避けるため2で割る（A→BとB→Aの両方がカウントされているため）
    high_coupling_count /= 2;

    ChangeCouplingAnalysis {
        couplings,
        high_coupling_count,
        total_files_analyzed: analyzed_files.len(),
    }
}

/// 著者別統計情報
#[derive(Debug, Clone)]
pub struct AuthorStats {
    /// 著者名
    pub name: String,
    /// コミット数
    pub commit_count: usize,
    /// 追加行数
    pub insertions: usize,
    /// 削除行数
    pub deletions: usize,
    /// 最終コミット日時
    pub last_commit: DateTime<Local>,
}

impl AuthorStats {
    /// コミット割合を計算（パーセント）
    pub fn commit_percentage(&self, total: usize) -> f64 {
        if total == 0 {
            0.0
        } else {
            (self.commit_count as f64 / total as f64) * 100.0
        }
    }
}

/// リポジトリ全体の統計情報
#[derive(Debug, Clone, Default)]
pub struct RepoStats {
    /// 著者別統計（コミット数降順）
    pub authors: Vec<AuthorStats>,
    /// 総コミット数
    pub total_commits: usize,
    /// 総追加行数
    pub total_insertions: usize,
    /// 総削除行数
    pub total_deletions: usize,
}

impl RepoStats {
    /// 著者数を取得
    pub fn author_count(&self) -> usize {
        self.authors.len()
    }
}

/// ファイル変更頻度のエントリ
#[derive(Debug, Clone)]
pub struct FileHeatmapEntry {
    /// ファイルパス
    pub path: String,
    /// 変更回数
    pub change_count: usize,
    /// 最大変更回数（正規化用）
    pub max_changes: usize,
}

impl FileHeatmapEntry {
    /// ヒートレベルを計算（0.0〜1.0）
    pub fn heat_level(&self) -> f64 {
        if self.max_changes == 0 {
            0.0
        } else {
            self.change_count as f64 / self.max_changes as f64
        }
    }

    /// ヒートバーを生成（5段階）
    pub fn heat_bar(&self) -> &'static str {
        let level = self.heat_level();
        if level >= 0.8 {
            "█████"
        } else if level >= 0.6 {
            "████ "
        } else if level >= 0.4 {
            "███  "
        } else if level >= 0.2 {
            "██   "
        } else {
            "█    "
        }
    }
}

/// 集約レベル（ヒートマップ表示用）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AggregationLevel {
    /// ファイル単位（デフォルト）
    #[default]
    Files,
    /// 浅い集約（2階層目まで、例: src/auth/）
    Shallow,
    /// 深い集約（1階層のみ、例: src/）
    Deep,
}

impl AggregationLevel {
    /// 次の集約レベルへ切り替え
    pub fn next(&self) -> Self {
        match self {
            AggregationLevel::Files => AggregationLevel::Shallow,
            AggregationLevel::Shallow => AggregationLevel::Deep,
            AggregationLevel::Deep => AggregationLevel::Files,
        }
    }

    /// 前の集約レベルへ切り替え
    pub fn prev(&self) -> Self {
        match self {
            AggregationLevel::Files => AggregationLevel::Deep,
            AggregationLevel::Shallow => AggregationLevel::Files,
            AggregationLevel::Deep => AggregationLevel::Shallow,
        }
    }

    /// 表示名を取得
    pub fn display_name(&self) -> &'static str {
        match self {
            AggregationLevel::Files => "Files",
            AggregationLevel::Shallow => "Directories (2 levels)",
            AggregationLevel::Deep => "Directories (top level)",
        }
    }
}

/// ファイル変更ヒートマップ
#[derive(Debug, Clone, Default)]
pub struct FileHeatmap {
    /// ファイル一覧（変更回数降順）
    pub files: Vec<FileHeatmapEntry>,
    /// 総ファイル数
    pub total_files: usize,
    /// 現在の集約レベル
    pub aggregation_level: AggregationLevel,
}

impl FileHeatmap {
    /// ファイル数を取得
    pub fn file_count(&self) -> usize {
        self.files.len()
    }

    /// 集約レベルを変更した新しいヒートマップを作成
    pub fn with_aggregation(&self, level: AggregationLevel) -> FileHeatmap {
        if level == AggregationLevel::Files {
            // ファイルレベルはそのまま返す
            return FileHeatmap {
                files: self.files.clone(),
                total_files: self.total_files,
                aggregation_level: level,
            };
        }

        // ディレクトリ単位で集約
        let mut dir_counts: HashMap<String, usize> = HashMap::new();

        for entry in &self.files {
            let dir = extract_directory(&entry.path, level);
            *dir_counts.entry(dir).or_insert(0) += entry.change_count;
        }

        let max_changes = dir_counts.values().copied().max().unwrap_or(0);

        let mut files: Vec<FileHeatmapEntry> = dir_counts
            .into_iter()
            .map(|(path, change_count)| FileHeatmapEntry {
                path,
                change_count,
                max_changes,
            })
            .collect();

        // 変更回数降順でソート
        files.sort_by(|a, b| b.change_count.cmp(&a.change_count));

        FileHeatmap {
            total_files: self.total_files,
            files,
            aggregation_level: level,
        }
    }
}

/// ディレクトリパスを抽出
fn extract_directory(path: &str, level: AggregationLevel) -> String {
    let parts: Vec<&str> = path.split('/').collect();
    match level {
        AggregationLevel::Files => path.to_string(),
        AggregationLevel::Shallow => {
            // src/auth/login.rs → src/auth/
            if parts.len() > 2 {
                format!("{}/{}/", parts[0], parts[1])
            } else if parts.len() == 2 {
                format!("{}/", parts[0])
            } else {
                path.to_string()
            }
        }
        AggregationLevel::Deep => {
            // src/auth/login.rs → src/
            if parts.len() > 1 {
                format!("{}/", parts[0])
            } else {
                path.to_string()
            }
        }
    }
}

/// イベント一覧からファイル変更ヒートマップを計算
pub fn calculate_file_heatmap(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
) -> FileHeatmap {
    let mut file_counts: HashMap<String, usize> = HashMap::new();

    for event in events {
        if let Some(files) = get_files(&event.short_hash) {
            for file in files {
                *file_counts.entry(file).or_insert(0) += 1;
            }
        }
    }

    let max_changes = file_counts.values().copied().max().unwrap_or(0);

    let mut files: Vec<FileHeatmapEntry> = file_counts
        .into_iter()
        .map(|(path, change_count)| FileHeatmapEntry {
            path,
            change_count,
            max_changes,
        })
        .collect();

    // 変更回数降順でソート
    files.sort_by(|a, b| b.change_count.cmp(&a.change_count));

    let total_files = files.len();
    FileHeatmap {
        files,
        total_files,
        aggregation_level: AggregationLevel::Files,
    }
}

/// 活動タイムライン（曜日×時間帯のヒートマップ）
#[derive(Debug, Clone, Default)]
pub struct ActivityTimeline {
    /// 7x24のグリッド（曜日 x 時間帯）
    /// grid[曜日][時間] = コミット数
    /// 曜日: 0=月, 1=火, 2=水, 3=木, 4=金, 5=土, 6=日
    pub grid: [[usize; 24]; 7],
    /// 総コミット数
    pub total_commits: usize,
    /// ピーク曜日（0-6）
    pub peak_day: usize,
    /// ピーク時間（0-23）
    pub peak_hour: usize,
    /// ピーク時のコミット数
    pub peak_count: usize,
    /// 最大コミット数（正規化用）
    pub max_count: usize,
}

impl ActivityTimeline {
    /// 曜日名を取得
    pub fn day_name(day: usize) -> &'static str {
        match day {
            0 => "Mon",
            1 => "Tue",
            2 => "Wed",
            3 => "Thu",
            4 => "Fri",
            5 => "Sat",
            6 => "Sun",
            _ => "???",
        }
    }

    /// ヒートレベルを計算（0.0〜1.0）
    pub fn heat_level(&self, day: usize, hour: usize) -> f64 {
        if self.max_count == 0 {
            0.0
        } else {
            self.grid[day][hour] as f64 / self.max_count as f64
        }
    }

    /// ヒートマップの文字を取得
    pub fn heat_char(level: f64) -> &'static str {
        if level >= 0.8 {
            "██"
        } else if level >= 0.6 {
            "▓▓"
        } else if level >= 0.4 {
            "▒▒"
        } else if level >= 0.2 {
            "░░"
        } else if level > 0.0 {
            "··"
        } else {
            "  "
        }
    }

    /// ピーク時間帯の文字列を取得
    pub fn peak_summary(&self) -> String {
        if self.peak_count == 0 {
            "No activity".to_string()
        } else {
            format!(
                "{} {:02}:00-{:02}:00 ({} commits)",
                Self::day_name(self.peak_day),
                self.peak_hour,
                (self.peak_hour + 1) % 24,
                self.peak_count
            )
        }
    }
}

/// イベント一覧から活動タイムラインを計算
pub fn calculate_activity_timeline(events: &[&GitEvent]) -> ActivityTimeline {
    use chrono::Datelike;
    use chrono::Timelike;

    let mut timeline = ActivityTimeline {
        total_commits: events.len(),
        ..Default::default()
    };

    for event in events {
        // chrono::Weekdayは月曜=0...日曜=6
        let day = event.timestamp.weekday().num_days_from_monday() as usize;
        let hour = event.timestamp.hour() as usize;

        timeline.grid[day][hour] += 1;
    }

    // ピークを計算
    let mut max_count = 0usize;
    for (day, hours) in timeline.grid.iter().enumerate() {
        for (hour, &count) in hours.iter().enumerate() {
            if count > max_count {
                max_count = count;
                timeline.peak_day = day;
                timeline.peak_hour = hour;
                timeline.peak_count = count;
            }
        }
    }
    timeline.max_count = max_count;

    timeline
}

/// コードオーナーシップのエントリ
#[derive(Debug, Clone)]
pub struct CodeOwnershipEntry {
    /// パス（ディレクトリまたはファイル）
    pub path: String,
    /// 主要著者
    pub primary_author: String,
    /// 主要著者のコミット数
    pub primary_commits: usize,
    /// 総コミット数
    pub total_commits: usize,
    /// 深さ（インデント用）
    pub depth: usize,
    /// ディレクトリかどうか
    pub is_directory: bool,
}

impl CodeOwnershipEntry {
    /// 主要著者の割合を計算（パーセント）
    pub fn ownership_percentage(&self) -> f64 {
        if self.total_commits == 0 {
            0.0
        } else {
            (self.primary_commits as f64 / self.total_commits as f64) * 100.0
        }
    }
}

/// コードオーナーシップ分析結果
#[derive(Debug, Clone, Default)]
pub struct CodeOwnership {
    /// エントリ一覧（階層順）
    pub entries: Vec<CodeOwnershipEntry>,
    /// 総ファイル数
    pub total_files: usize,
}

impl CodeOwnership {
    /// エントリ数を取得
    pub fn entry_count(&self) -> usize {
        self.entries.len()
    }
}

/// イベント一覧からコードオーナーシップを計算
pub fn calculate_ownership(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
) -> CodeOwnership {
    // ファイルごとの著者別コミット数を集計
    let mut file_author_counts: HashMap<String, HashMap<String, usize>> = HashMap::new();

    for event in events {
        if let Some(files) = get_files(&event.short_hash) {
            for file in files {
                let author_counts = file_author_counts.entry(file).or_default();
                *author_counts.entry(event.author.clone()).or_insert(0) += 1;
            }
        }
    }

    // ディレクトリごとの著者別コミット数を集計
    let mut dir_author_counts: HashMap<String, HashMap<String, usize>> = HashMap::new();

    for (file_path, author_counts) in &file_author_counts {
        // ファイルパスからディレクトリパスを抽出
        let parts: Vec<&str> = file_path.split('/').collect();
        for i in 1..parts.len() {
            let dir_path = parts[..i].join("/");
            let dir_counts = dir_author_counts.entry(dir_path).or_default();
            for (author, count) in author_counts {
                *dir_counts.entry(author.clone()).or_insert(0) += count;
            }
        }
    }

    // エントリを生成
    let mut entries = Vec::new();

    // ディレクトリを階層順にソート
    let mut dir_paths: Vec<String> = dir_author_counts.keys().cloned().collect();
    dir_paths.sort();

    for dir_path in dir_paths {
        let author_counts = &dir_author_counts[&dir_path];
        let (primary_author, primary_commits) = author_counts
            .iter()
            .max_by_key(|(_, c)| *c)
            .map(|(a, c)| (a.clone(), *c))
            .unwrap_or_default();
        let total_commits: usize = author_counts.values().sum();
        let depth = dir_path.matches('/').count();

        entries.push(CodeOwnershipEntry {
            path: dir_path,
            primary_author,
            primary_commits,
            total_commits,
            depth,
            is_directory: true,
        });
    }

    // ファイルも追加（ディレクトリの後に）
    let mut file_paths: Vec<String> = file_author_counts.keys().cloned().collect();
    file_paths.sort();

    for file_path in file_paths {
        let author_counts = &file_author_counts[&file_path];
        let (primary_author, primary_commits) = author_counts
            .iter()
            .max_by_key(|(_, c)| *c)
            .map(|(a, c)| (a.clone(), *c))
            .unwrap_or_default();
        let total_commits: usize = author_counts.values().sum();
        let depth = file_path.matches('/').count();

        entries.push(CodeOwnershipEntry {
            path: file_path,
            primary_author,
            primary_commits,
            total_commits,
            depth,
            is_directory: false,
        });
    }

    // ディレクトリとファイルを交互に表示するため、パスでソート
    entries.sort_by(|a, b| a.path.cmp(&b.path));

    let total_files = file_author_counts.len();
    CodeOwnership {
        entries,
        total_files,
    }
}

/// イベント一覧から統計情報を計算
pub fn calculate_stats(events: &[&GitEvent]) -> RepoStats {
    let mut author_map: HashMap<String, AuthorStats> = HashMap::new();
    let mut total_insertions = 0usize;
    let mut total_deletions = 0usize;

    for event in events {
        total_insertions += event.files_added;
        total_deletions += event.files_deleted;

        let entry = author_map
            .entry(event.author.clone())
            .or_insert(AuthorStats {
                name: event.author.clone(),
                commit_count: 0,
                insertions: 0,
                deletions: 0,
                last_commit: event.timestamp,
            });

        entry.commit_count += 1;
        entry.insertions += event.files_added;
        entry.deletions += event.files_deleted;

        // 最新のコミット日時を更新
        if event.timestamp > entry.last_commit {
            entry.last_commit = event.timestamp;
        }
    }

    // コミット数降順でソート
    let mut authors: Vec<AuthorStats> = author_map.into_values().collect();
    authors.sort_by(|a, b| b.commit_count.cmp(&a.commit_count));

    RepoStats {
        authors,
        total_commits: events.len(),
        total_insertions,
        total_deletions,
    }
}

// =============================================================================
// Bus Factor Analysis
// =============================================================================

/// バスファクターエントリ
#[derive(Debug, Clone)]
pub struct BusFactorEntry {
    /// パス（ディレクトリまたはファイル）
    pub path: String,
    /// バスファクター値（知識を持つ人数）
    pub bus_factor: usize,
    /// 主要な貢献者リスト（コミット数順）
    pub contributors: Vec<ContributorInfo>,
    /// 総コミット数
    pub total_commits: usize,
    /// リスクレベル
    pub risk_level: BusFactorRisk,
    /// ディレクトリかどうか
    pub is_directory: bool,
}

/// 貢献者情報
#[derive(Debug, Clone)]
pub struct ContributorInfo {
    /// 著者名
    pub name: String,
    /// コミット数
    pub commit_count: usize,
    /// 貢献割合（パーセント）
    pub contribution_percent: f64,
}

/// バスファクターリスクレベル
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BusFactorRisk {
    /// 高リスク（1人のみ）
    High,
    /// 中リスク（2人）
    Medium,
    /// 低リスク（3人以上）
    Low,
}

impl BusFactorRisk {
    /// リスクレベルの表示名
    pub fn display_name(&self) -> &'static str {
        match self {
            BusFactorRisk::High => "High Risk",
            BusFactorRisk::Medium => "Medium Risk",
            BusFactorRisk::Low => "Low Risk",
        }
    }

    /// リスクレベルの色
    pub fn color(&self) -> &'static str {
        match self {
            BusFactorRisk::High => "red",
            BusFactorRisk::Medium => "yellow",
            BusFactorRisk::Low => "green",
        }
    }
}

/// バスファクター分析結果
#[derive(Debug, Clone, Default)]
pub struct BusFactorAnalysis {
    /// エントリ一覧（リスク順）
    pub entries: Vec<BusFactorEntry>,
    /// 高リスク領域数
    pub high_risk_count: usize,
    /// 中リスク領域数
    pub medium_risk_count: usize,
    /// 分析されたパス数
    pub total_paths_analyzed: usize,
}

impl BusFactorAnalysis {
    /// エントリ数を取得
    pub fn entry_count(&self) -> usize {
        self.entries.len()
    }
}

/// バスファクターを計算
///
/// バスファクター = そのコード領域に関する知識を持つ人数
/// 「その人がいなくなったらプロジェクトが停止するリスク」を測定
///
/// 計算方法:
/// - 各パスについて、50%以上の貢献をしている人数をカウント
/// - 1人だけが50%以上なら bus_factor = 1（高リスク）
pub fn calculate_bus_factor(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
    min_commits: usize,
) -> BusFactorAnalysis {
    // ディレクトリごとの著者別コミット数を集計
    let mut dir_author_counts: HashMap<String, HashMap<String, usize>> = HashMap::new();

    for event in events {
        if let Some(files) = get_files(&event.short_hash) {
            for file in &files {
                // トップレベルディレクトリを抽出
                let parts: Vec<&str> = file.split('/').collect();
                if parts.len() > 1 {
                    let top_dir = parts[0].to_string();
                    let counts = dir_author_counts.entry(top_dir).or_default();
                    *counts.entry(event.author.clone()).or_insert(0) += 1;
                }
                // 2階層目のディレクトリも集計
                if parts.len() > 2 {
                    let two_level_dir = format!("{}/{}", parts[0], parts[1]);
                    let counts = dir_author_counts.entry(two_level_dir).or_default();
                    *counts.entry(event.author.clone()).or_insert(0) += 1;
                }
            }
        }
    }

    let mut entries = Vec::new();
    let mut high_risk_count = 0;
    let mut medium_risk_count = 0;

    for (path, author_counts) in &dir_author_counts {
        let total_commits: usize = author_counts.values().sum();

        // 最小コミット数に満たない場合はスキップ
        if total_commits < min_commits {
            continue;
        }

        // 貢献者情報を作成（コミット数順）
        let mut contributors: Vec<ContributorInfo> = author_counts
            .iter()
            .map(|(name, &count)| ContributorInfo {
                name: name.clone(),
                commit_count: count,
                contribution_percent: (count as f64 / total_commits as f64) * 100.0,
            })
            .collect();
        contributors.sort_by(|a, b| b.commit_count.cmp(&a.commit_count));

        // バスファクター計算: 累積貢献が50%を超えるまでに必要な人数
        let mut cumulative = 0.0;
        let mut bus_factor = 0;
        for contributor in &contributors {
            cumulative += contributor.contribution_percent;
            bus_factor += 1;
            if cumulative >= 50.0 {
                break;
            }
        }

        let risk_level = match bus_factor {
            1 => {
                high_risk_count += 1;
                BusFactorRisk::High
            }
            2 => {
                medium_risk_count += 1;
                BusFactorRisk::Medium
            }
            _ => BusFactorRisk::Low,
        };

        entries.push(BusFactorEntry {
            path: path.clone(),
            bus_factor,
            contributors: contributors.into_iter().take(5).collect(), // 上位5人のみ
            total_commits,
            risk_level,
            is_directory: true,
        });
    }

    // リスク順（高リスク→低リスク）、同じリスクならコミット数順でソート
    entries.sort_by(|a, b| match (&a.risk_level, &b.risk_level) {
        (BusFactorRisk::High, BusFactorRisk::High)
        | (BusFactorRisk::Medium, BusFactorRisk::Medium)
        | (BusFactorRisk::Low, BusFactorRisk::Low) => b.total_commits.cmp(&a.total_commits),
        (BusFactorRisk::High, _) => std::cmp::Ordering::Less,
        (_, BusFactorRisk::High) => std::cmp::Ordering::Greater,
        (BusFactorRisk::Medium, BusFactorRisk::Low) => std::cmp::Ordering::Less,
        (BusFactorRisk::Low, BusFactorRisk::Medium) => std::cmp::Ordering::Greater,
    });

    BusFactorAnalysis {
        total_paths_analyzed: entries.len(),
        entries,
        high_risk_count,
        medium_risk_count,
    }
}

// =============================================================================
// Technical Debt Score
// =============================================================================

/// 技術的負債エントリ
#[derive(Debug, Clone)]
pub struct TechDebtEntry {
    /// ファイルパス
    pub path: String,
    /// 技術的負債スコア (0.0〜1.0)
    pub score: f64,
    /// 変更頻度スコア (0.0〜1.0)
    pub churn_score: f64,
    /// 複雑度スコア (0.0〜1.0) - ファイルサイズベース
    pub complexity_score: f64,
    /// 年齢スコア (0.0〜1.0) - 最終変更からの経過
    pub age_score: f64,
    /// 変更回数
    pub change_count: usize,
    /// 総変更行数
    pub total_changes: usize,
    /// 負債レベル
    pub debt_level: TechDebtLevel,
}

/// 技術的負債レベル
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TechDebtLevel {
    /// 高負債（要対応）
    High,
    /// 中負債（注意）
    Medium,
    /// 低負債（良好）
    Low,
}

impl TechDebtLevel {
    /// 負債レベルの表示名
    pub fn display_name(&self) -> &'static str {
        match self {
            TechDebtLevel::High => "High Debt",
            TechDebtLevel::Medium => "Medium Debt",
            TechDebtLevel::Low => "Low Debt",
        }
    }

    /// 負債レベルの色
    pub fn color(&self) -> &'static str {
        match self {
            TechDebtLevel::High => "red",
            TechDebtLevel::Medium => "yellow",
            TechDebtLevel::Low => "green",
        }
    }
}

/// 技術的負債分析結果
#[derive(Debug, Clone, Default)]
pub struct TechDebtAnalysis {
    /// エントリ一覧（スコア降順）
    pub entries: Vec<TechDebtEntry>,
    /// 平均スコア
    pub avg_score: f64,
    /// 高負債ファイル数
    pub high_debt_count: usize,
    /// 分析されたファイル数
    pub total_files_analyzed: usize,
}

impl TechDebtAnalysis {
    /// エントリ数を取得
    pub fn entry_count(&self) -> usize {
        self.entries.len()
    }
}

/// 技術的負債スコアを計算
///
/// 技術的負債 = 変更頻度 × 複雑さ × 古さ
///
/// 計算式:
/// - 変更頻度スコア: (変更回数 / 最大変更回数)
/// - 複雑度スコア: (変更行数 / 最大変更行数)
/// - 年齢スコア: (経過日数 / 365) で上限1.0
pub fn calculate_tech_debt(
    events: &[&GitEvent],
    get_files: impl Fn(&str) -> Option<Vec<String>>,
    min_commits: usize,
) -> TechDebtAnalysis {
    use chrono::Local;

    // ファイルごとの統計を集計
    let mut file_stats: HashMap<String, (usize, usize, DateTime<Local>)> = HashMap::new();

    for event in events {
        if let Some(files) = get_files(&event.short_hash) {
            let changes_per_file = (event.files_added + event.files_deleted) / files.len().max(1);
            for file in files {
                let entry = file_stats.entry(file).or_insert((0, 0, event.timestamp));
                entry.0 += 1; // change_count
                entry.1 += changes_per_file; // total_changes
                                             // 最新の変更日時を保持
                if event.timestamp > entry.2 {
                    entry.2 = event.timestamp;
                }
            }
        }
    }

    // 最大値を計算（正規化用）
    let max_changes = file_stats.values().map(|(c, _, _)| *c).max().unwrap_or(1);
    let max_lines = file_stats.values().map(|(_, l, _)| *l).max().unwrap_or(1);
    let now = Local::now();

    let mut entries = Vec::new();
    let mut total_score = 0.0;
    let mut high_debt_count = 0;

    for (path, (change_count, total_changes, last_modified)) in &file_stats {
        if *change_count < min_commits {
            continue;
        }

        // 各スコアを計算
        let churn_score = *change_count as f64 / max_changes as f64;
        let complexity_score = *total_changes as f64 / max_lines as f64;

        // 年齢スコア: 最後の変更からの経過日数
        let days_since_change = (now - *last_modified).num_days().max(0) as f64;
        let age_score = (days_since_change / 365.0).min(1.0);

        // 総合スコア = 変更頻度(40%) + 複雑度(40%) + 年齢(20%)
        // ただし、年齢は「古くて頻繁に変更される」場合にリスクとなるため、
        // 年齢スコアは変更頻度と組み合わせて評価
        let score = churn_score * 0.5 + complexity_score * 0.4 + (churn_score * age_score) * 0.1;

        let debt_level = if score >= 0.6 {
            high_debt_count += 1;
            TechDebtLevel::High
        } else if score >= 0.3 {
            TechDebtLevel::Medium
        } else {
            TechDebtLevel::Low
        };

        entries.push(TechDebtEntry {
            path: path.clone(),
            score,
            churn_score,
            complexity_score,
            age_score,
            change_count: *change_count,
            total_changes: *total_changes,
            debt_level,
        });

        total_score += score;
    }

    // スコア降順でソート
    entries.sort_by(|a, b| {
        b.score
            .partial_cmp(&a.score)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    let total_files_analyzed = entries.len();
    let avg_score = if total_files_analyzed > 0 {
        total_score / total_files_analyzed as f64
    } else {
        0.0
    };

    TechDebtAnalysis {
        entries,
        avg_score,
        high_debt_count,
        total_files_analyzed,
    }
}

// =============================================================================
// Project Health Dashboard
// =============================================================================

/// アラートの深刻度
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum AlertSeverity {
    /// 情報（青）
    Info,
    /// 警告（黄）
    Warning,
    /// 重大（赤）
    Critical,
}

impl AlertSeverity {
    /// 色名を取得
    pub fn color(&self) -> &'static str {
        match self {
            AlertSeverity::Info => "blue",
            AlertSeverity::Warning => "yellow",
            AlertSeverity::Critical => "red",
        }
    }

    /// アイコンを取得
    pub fn icon(&self) -> &'static str {
        match self {
            AlertSeverity::Info => "ℹ",
            AlertSeverity::Warning => "⚠",
            AlertSeverity::Critical => "🔴",
        }
    }
}

/// ヘルスアラート
#[derive(Debug, Clone)]
pub struct HealthAlert {
    /// 深刻度
    pub severity: AlertSeverity,
    /// アラートメッセージ
    pub message: String,
    /// 詳細説明
    pub details: Option<String>,
}

impl HealthAlert {
    /// 新規アラートを作成
    pub fn new(severity: AlertSeverity, message: impl Into<String>) -> Self {
        Self {
            severity,
            message: message.into(),
            details: None,
        }
    }

    /// 詳細付きアラートを作成
    pub fn with_details(
        severity: AlertSeverity,
        message: impl Into<String>,
        details: impl Into<String>,
    ) -> Self {
        Self {
            severity,
            message: message.into(),
            details: Some(details.into()),
        }
    }
}

/// 個別スコアコンポーネント
#[derive(Debug, Clone, Default)]
pub struct HealthScoreComponent {
    /// スコア (0.0〜1.0)
    pub score: f64,
    /// 重み (スコア計算時の割合)
    pub weight: f64,
    /// 説明
    pub description: String,
}

/// プロジェクトヘルス分析結果
#[derive(Debug, Clone)]
pub struct ProjectHealth {
    /// 総合スコア (0〜100)
    pub overall_score: u8,
    /// 品質スコアコンポーネント (25%)
    pub quality: HealthScoreComponent,
    /// テスト健全性コンポーネント (25%)
    pub test_health: HealthScoreComponent,
    /// バスファクターリスクコンポーネント (25%)
    pub bus_factor_risk: HealthScoreComponent,
    /// 技術的負債コンポーネント (25%)
    pub tech_debt: HealthScoreComponent,
    /// アラート一覧（深刻度降順）
    pub alerts: Vec<HealthAlert>,
    /// 分析対象コミット数
    pub total_commits: usize,
    /// 分析対象著者数
    pub total_authors: usize,
    /// 分析期間（日数）
    pub analysis_period_days: u64,
}

impl Default for ProjectHealth {
    fn default() -> Self {
        Self {
            overall_score: 50,
            quality: HealthScoreComponent {
                score: 0.5,
                weight: 0.25,
                description: "Commit quality average".to_string(),
            },
            test_health: HealthScoreComponent {
                score: 0.5,
                weight: 0.25,
                description: "Test commit ratio".to_string(),
            },
            bus_factor_risk: HealthScoreComponent {
                score: 0.5,
                weight: 0.25,
                description: "Knowledge concentration (lower is better)".to_string(),
            },
            tech_debt: HealthScoreComponent {
                score: 0.5,
                weight: 0.25,
                description: "Technical debt (lower is better)".to_string(),
            },
            alerts: Vec::new(),
            total_commits: 0,
            total_authors: 0,
            analysis_period_days: 0,
        }
    }
}

impl ProjectHealth {
    /// 総合スコアのレベル文字列を取得
    pub fn level(&self) -> &'static str {
        if self.overall_score >= 80 {
            "Excellent"
        } else if self.overall_score >= 60 {
            "Good"
        } else if self.overall_score >= 40 {
            "Fair"
        } else {
            "Poor"
        }
    }

    /// スコア色を取得
    pub fn score_color(&self) -> &'static str {
        if self.overall_score >= 80 {
            "green"
        } else if self.overall_score >= 60 {
            "cyan"
        } else if self.overall_score >= 40 {
            "yellow"
        } else {
            "red"
        }
    }

    /// スコアバーを生成（10段階）
    pub fn score_bar(&self) -> String {
        let filled = (self.overall_score / 10) as usize;
        let empty = 10 - filled;
        format!("{}{}", "█".repeat(filled), "░".repeat(empty))
    }
}

/// プロジェクトヘルスを計算
///
/// # Arguments
/// * `events` - 分析対象のGitイベント
/// * `files_fn` - ハッシュからファイル一覧を取得する関数
/// * `quality_analysis` - 事前に計算されたQuality分析結果（Optionalで計算）
/// * `bus_factor` - 事前に計算されたバスファクター分析結果（Optionalで計算）
/// * `tech_debt` - 事前に計算されたテクニカルデット分析結果（Optionalで計算）
pub fn calculate_project_health<F>(
    events: &[&GitEvent],
    files_fn: F,
    quality_analysis: Option<&CommitQualityAnalysis>,
    bus_factor: Option<&BusFactorAnalysis>,
    tech_debt_analysis: Option<&TechDebtAnalysis>,
) -> ProjectHealth
where
    F: Fn(&str) -> Option<Vec<String>>,
{
    if events.is_empty() {
        return ProjectHealth::default();
    }

    let total_commits = events.len();
    let mut alerts = Vec::new();

    // 著者を収集
    let authors: std::collections::HashSet<&str> =
        events.iter().map(|e| e.author.as_str()).collect();
    let total_authors = authors.len();

    // 分析期間を計算
    let analysis_period_days = if events.len() >= 2 {
        let newest = events.first().map(|e| e.timestamp);
        let oldest = events.last().map(|e| e.timestamp);
        if let (Some(n), Some(o)) = (newest, oldest) {
            let duration = n.signed_duration_since(o);
            duration.num_days().unsigned_abs()
        } else {
            0
        }
    } else {
        0
    };

    // 1. 品質スコア (25%)
    let quality_score = if let Some(qa) = quality_analysis {
        qa.avg_score
    } else {
        // 簡易計算: Conventional Commitsプレフィックスの比率
        let conventional_count = events
            .iter()
            .filter(|e| {
                let msg = e.message.to_lowercase();
                msg.starts_with("feat:")
                    || msg.starts_with("fix:")
                    || msg.starts_with("docs:")
                    || msg.starts_with("style:")
                    || msg.starts_with("refactor:")
                    || msg.starts_with("test:")
                    || msg.starts_with("chore:")
                    || msg.starts_with("perf:")
            })
            .count();
        conventional_count as f64 / total_commits as f64
    };

    let quality = HealthScoreComponent {
        score: quality_score,
        weight: 0.25,
        description: format!(
            "Commit quality: {:.0}% conventional commits",
            quality_score * 100.0
        ),
    };

    if quality_score < 0.3 {
        alerts.push(HealthAlert::with_details(
            AlertSeverity::Warning,
            "Low commit quality",
            "Consider using conventional commit messages (feat:, fix:, etc.)",
        ));
    }

    // 2. テスト健全性 (25%)
    let test_commit_count = events
        .iter()
        .filter(|e| {
            let msg = e.message.to_lowercase();
            msg.starts_with("test:") || msg.contains("test") || msg.contains("spec")
        })
        .count();
    let test_file_commit_count = events
        .iter()
        .filter(|e| {
            if let Some(files) = files_fn(&e.short_hash) {
                files.iter().any(|f| {
                    f.contains("test")
                        || f.contains("spec")
                        || f.ends_with("_test.rs")
                        || f.ends_with(".test.")
                })
            } else {
                false
            }
        })
        .count();
    let test_ratio =
        (test_commit_count + test_file_commit_count) as f64 / (total_commits * 2) as f64;
    let test_score = test_ratio.min(1.0);

    let test_health = HealthScoreComponent {
        score: test_score,
        weight: 0.25,
        description: format!(
            "Test coverage: {:.0}% test-related commits",
            test_score * 100.0
        ),
    };

    if test_score < 0.1 {
        alerts.push(HealthAlert::with_details(
            AlertSeverity::Info,
            "Low test coverage in commits",
            "Consider adding more test commits or test-related changes",
        ));
    }

    // 3. バスファクターリスク (25%) - 低いほど良い
    let bus_factor_score = if let Some(bf) = bus_factor {
        // バスファクターが高リスクのパスが多いほどスコアを下げる
        let low_risk_count = bf
            .total_paths_analyzed
            .saturating_sub(bf.high_risk_count + bf.medium_risk_count);
        let risk_ratio = bf.high_risk_count as f64
            / (bf.high_risk_count + bf.medium_risk_count + low_risk_count).max(1) as f64;
        1.0 - risk_ratio
    } else {
        // 簡易計算: 著者の分散を見る
        let mut author_commits: HashMap<&str, usize> = HashMap::new();
        for e in events.iter() {
            *author_commits.entry(e.author.as_str()).or_insert(0) += 1;
        }
        // 上位1人が全体の何%を占めるか
        let max_commits = author_commits.values().max().copied().unwrap_or(0);
        let concentration = max_commits as f64 / total_commits as f64;
        1.0 - concentration
    };

    let bus_factor_risk = HealthScoreComponent {
        score: bus_factor_score,
        weight: 0.25,
        description: format!(
            "Knowledge distribution: {:.0}% (higher is better)",
            bus_factor_score * 100.0
        ),
    };

    if bus_factor_score < 0.3 {
        alerts.push(HealthAlert::with_details(
            AlertSeverity::Critical,
            "High bus factor risk",
            "Knowledge is concentrated in few contributors. Consider knowledge sharing.",
        ));
    } else if bus_factor_score < 0.5 {
        alerts.push(HealthAlert::with_details(
            AlertSeverity::Warning,
            "Moderate bus factor risk",
            "Consider improving knowledge distribution across team members.",
        ));
    }

    // 4. 技術的負債 (25%) - 低いほど良い
    let tech_debt_score = if let Some(td) = tech_debt_analysis {
        1.0 - td.avg_score.min(1.0)
    } else {
        // 簡易計算: 大きな変更の比率を見る
        let large_commits = events
            .iter()
            .filter(|e| e.files_added + e.files_deleted > 50)
            .count();
        let large_ratio = large_commits as f64 / total_commits as f64;
        1.0 - large_ratio.min(1.0)
    };

    let tech_debt = HealthScoreComponent {
        score: tech_debt_score,
        weight: 0.25,
        description: format!(
            "Technical debt: {:.0}% clean (higher is better)",
            tech_debt_score * 100.0
        ),
    };

    if tech_debt_score < 0.3 {
        alerts.push(HealthAlert::with_details(
            AlertSeverity::Warning,
            "High technical debt indicated",
            "Many large commits suggest accumulated technical debt.",
        ));
    }

    // 総合スコアを計算
    let overall = quality.score * quality.weight
        + test_health.score * test_health.weight
        + bus_factor_risk.score * bus_factor_risk.weight
        + tech_debt.score * tech_debt.weight;
    let overall_score = (overall * 100.0).round() as u8;

    // アラートを深刻度順にソート
    alerts.sort_by(|a, b| b.severity.cmp(&a.severity));

    ProjectHealth {
        overall_score,
        quality,
        test_health,
        bus_factor_risk,
        tech_debt,
        alerts,
        total_commits,
        total_authors,
        analysis_period_days,
    }
}

#[cfg(test)]
#[allow(clippy::useless_vec)]
mod tests {
    use super::*;
    use chrono::Local;

    fn create_test_event(author: &str, insertions: usize, deletions: usize) -> GitEvent {
        GitEvent::commit(
            "abc1234".to_string(),
            "test commit".to_string(),
            author.to_string(),
            Local::now(),
            insertions,
            deletions,
        )
    }

    #[test]
    fn test_calculate_stats_empty() {
        let stats = calculate_stats(&[]);
        assert_eq!(stats.total_commits, 0);
        assert_eq!(stats.authors.len(), 0);
    }

    #[test]
    fn test_calculate_stats_single_author() {
        let events = vec![
            create_test_event("Alice", 10, 5),
            create_test_event("Alice", 20, 10),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let stats = calculate_stats(&refs);

        assert_eq!(stats.total_commits, 2);
        assert_eq!(stats.authors.len(), 1);
        assert_eq!(stats.authors[0].name, "Alice");
        assert_eq!(stats.authors[0].commit_count, 2);
        assert_eq!(stats.authors[0].insertions, 30);
        assert_eq!(stats.authors[0].deletions, 15);
    }

    #[test]
    fn test_calculate_stats_multiple_authors() {
        let events = vec![
            create_test_event("Alice", 10, 5),
            create_test_event("Bob", 5, 2),
            create_test_event("Alice", 20, 10),
            create_test_event("Bob", 15, 8),
            create_test_event("Bob", 10, 5),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let stats = calculate_stats(&refs);

        assert_eq!(stats.total_commits, 5);
        assert_eq!(stats.authors.len(), 2);

        // Bobが3コミットで最多なので先頭
        assert_eq!(stats.authors[0].name, "Bob");
        assert_eq!(stats.authors[0].commit_count, 3);

        // Aliceが2コミット
        assert_eq!(stats.authors[1].name, "Alice");
        assert_eq!(stats.authors[1].commit_count, 2);
    }

    #[test]
    fn test_calculate_stats_totals() {
        let events = vec![
            create_test_event("Alice", 10, 5),
            create_test_event("Bob", 20, 10),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let stats = calculate_stats(&refs);

        assert_eq!(stats.total_insertions, 30);
        assert_eq!(stats.total_deletions, 15);
    }

    #[test]
    fn test_author_stats_commit_percentage() {
        let author = AuthorStats {
            name: "Alice".to_string(),
            commit_count: 25,
            insertions: 0,
            deletions: 0,
            last_commit: Local::now(),
        };

        assert!((author.commit_percentage(100) - 25.0).abs() < 0.01);
        assert!((author.commit_percentage(50) - 50.0).abs() < 0.01);
    }

    #[test]
    fn test_author_stats_commit_percentage_zero() {
        let author = AuthorStats {
            name: "Alice".to_string(),
            commit_count: 10,
            insertions: 0,
            deletions: 0,
            last_commit: Local::now(),
        };

        assert_eq!(author.commit_percentage(0), 0.0);
    }

    #[test]
    fn test_repo_stats_author_count() {
        let events = vec![
            create_test_event("Alice", 10, 5),
            create_test_event("Bob", 5, 2),
            create_test_event("Charlie", 15, 8),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let stats = calculate_stats(&refs);

        assert_eq!(stats.author_count(), 3);
    }

    // ===== ヒートマップのテスト =====

    fn create_test_event_with_hash(hash: &str) -> GitEvent {
        GitEvent::commit(
            hash.to_string(),
            "test commit".to_string(),
            "author".to_string(),
            Local::now(),
            10,
            5,
        )
    }

    #[test]
    fn test_calculate_file_heatmap_empty() {
        let events: Vec<&GitEvent> = vec![];
        let heatmap = calculate_file_heatmap(&events, |_| None);
        assert_eq!(heatmap.file_count(), 0);
    }

    #[test]
    fn test_calculate_file_heatmap_single_file() {
        let events = vec![
            create_test_event_with_hash("abc1234"),
            create_test_event_with_hash("def5678"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = calculate_file_heatmap(&refs, |_| Some(vec!["src/main.rs".to_string()]));

        assert_eq!(heatmap.file_count(), 1);
        assert_eq!(heatmap.files[0].path, "src/main.rs");
        assert_eq!(heatmap.files[0].change_count, 2);
    }

    #[test]
    fn test_calculate_file_heatmap_multiple_files() {
        let events = vec![
            create_test_event_with_hash("abc1234"),
            create_test_event_with_hash("def5678"),
            create_test_event_with_hash("ghi9012"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = calculate_file_heatmap(&refs, |hash| match hash {
            "abc1234" => Some(vec!["src/a.rs".to_string(), "src/b.rs".to_string()]),
            "def5678" => Some(vec!["src/a.rs".to_string()]),
            "ghi9012" => Some(vec!["src/a.rs".to_string(), "src/c.rs".to_string()]),
            _ => None,
        });

        assert_eq!(heatmap.file_count(), 3);
        // src/a.rsが3回で最多
        assert_eq!(heatmap.files[0].path, "src/a.rs");
        assert_eq!(heatmap.files[0].change_count, 3);
    }

    #[test]
    fn test_file_heatmap_entry_heat_level() {
        let entry = FileHeatmapEntry {
            path: "test.rs".to_string(),
            change_count: 5,
            max_changes: 10,
        };
        assert!((entry.heat_level() - 0.5).abs() < 0.01);
    }

    #[test]
    fn test_file_heatmap_entry_heat_bar() {
        let entry_high = FileHeatmapEntry {
            path: "test.rs".to_string(),
            change_count: 10,
            max_changes: 10,
        };
        assert_eq!(entry_high.heat_bar(), "█████");

        let entry_low = FileHeatmapEntry {
            path: "test.rs".to_string(),
            change_count: 1,
            max_changes: 10,
        };
        assert_eq!(entry_low.heat_bar(), "█    ");
    }

    // ===== AggregationLevel テスト =====

    #[test]
    fn test_aggregation_level_next() {
        assert_eq!(AggregationLevel::Files.next(), AggregationLevel::Shallow);
        assert_eq!(AggregationLevel::Shallow.next(), AggregationLevel::Deep);
        assert_eq!(AggregationLevel::Deep.next(), AggregationLevel::Files);
    }

    #[test]
    fn test_aggregation_level_prev() {
        assert_eq!(AggregationLevel::Files.prev(), AggregationLevel::Deep);
        assert_eq!(AggregationLevel::Shallow.prev(), AggregationLevel::Files);
        assert_eq!(AggregationLevel::Deep.prev(), AggregationLevel::Shallow);
    }

    #[test]
    fn test_aggregation_level_display_name() {
        assert_eq!(AggregationLevel::Files.display_name(), "Files");
        assert!(AggregationLevel::Shallow
            .display_name()
            .contains("2 levels"));
        assert!(AggregationLevel::Deep.display_name().contains("top level"));
    }

    #[test]
    fn test_heatmap_with_aggregation_shallow() {
        let heatmap = FileHeatmap {
            files: vec![
                FileHeatmapEntry {
                    path: "src/auth/login.rs".to_string(),
                    change_count: 10,
                    max_changes: 10,
                },
                FileHeatmapEntry {
                    path: "src/auth/token.rs".to_string(),
                    change_count: 5,
                    max_changes: 10,
                },
                FileHeatmapEntry {
                    path: "src/api/user.rs".to_string(),
                    change_count: 3,
                    max_changes: 10,
                },
            ],
            total_files: 3,
            aggregation_level: AggregationLevel::Files,
        };

        let aggregated = heatmap.with_aggregation(AggregationLevel::Shallow);
        assert_eq!(aggregated.aggregation_level, AggregationLevel::Shallow);
        assert_eq!(aggregated.files.len(), 2); // src/auth/ と src/api/

        // src/auth/が最多（10+5=15）
        assert_eq!(aggregated.files[0].path, "src/auth/");
        assert_eq!(aggregated.files[0].change_count, 15);
    }

    #[test]
    fn test_heatmap_with_aggregation_deep() {
        let heatmap = FileHeatmap {
            files: vec![
                FileHeatmapEntry {
                    path: "src/auth/login.rs".to_string(),
                    change_count: 10,
                    max_changes: 10,
                },
                FileHeatmapEntry {
                    path: "src/api/user.rs".to_string(),
                    change_count: 5,
                    max_changes: 10,
                },
                FileHeatmapEntry {
                    path: "tests/test.rs".to_string(),
                    change_count: 3,
                    max_changes: 10,
                },
            ],
            total_files: 3,
            aggregation_level: AggregationLevel::Files,
        };

        let aggregated = heatmap.with_aggregation(AggregationLevel::Deep);
        assert_eq!(aggregated.aggregation_level, AggregationLevel::Deep);
        assert_eq!(aggregated.files.len(), 2); // src/ と tests/

        // src/が最多（10+5=15）
        assert_eq!(aggregated.files[0].path, "src/");
        assert_eq!(aggregated.files[0].change_count, 15);
    }

    // ===== Impact Score テスト =====

    fn create_test_event_with_hash_changes(
        hash: &str,
        author: &str,
        insertions: usize,
        deletions: usize,
    ) -> GitEvent {
        GitEvent::commit(
            hash.to_string(),
            "test commit".to_string(),
            author.to_string(),
            Local::now(),
            insertions,
            deletions,
        )
    }

    #[test]
    fn test_calculate_impact_scores_empty() {
        let events: Vec<&GitEvent> = vec![];
        let heatmap = FileHeatmap::default();
        let analysis = calculate_impact_scores(&events, |_| None, &heatmap);
        assert_eq!(analysis.total_commits, 0);
        assert_eq!(analysis.commits.len(), 0);
        assert_eq!(analysis.avg_score, 0.0);
    }

    #[test]
    fn test_calculate_impact_scores_single_commit() {
        let events = vec![create_test_event_with_hash_changes(
            "abc1234", "Alice", 100, 50,
        )];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = FileHeatmap::default();

        let analysis =
            calculate_impact_scores(&refs, |_| Some(vec!["src/main.rs".to_string()]), &heatmap);

        assert_eq!(analysis.total_commits, 1);
        assert_eq!(analysis.commits.len(), 1);

        let commit = &analysis.commits[0];
        assert_eq!(commit.commit_hash, "abc1234");
        assert_eq!(commit.files_changed, 1);
        assert_eq!(commit.insertions, 100);
        assert_eq!(commit.deletions, 50);
    }

    #[test]
    fn test_calculate_impact_scores_file_score() {
        // 50ファイル変更 → file_score = 0.4
        let events = vec![create_test_event_with_hash_changes(
            "abc1234", "Alice", 10, 5,
        )];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = FileHeatmap::default();

        // 50ファイルを返す
        let files: Vec<String> = (0..50).map(|i| format!("file{}.rs", i)).collect();
        let analysis = calculate_impact_scores(&refs, |_| Some(files.clone()), &heatmap);

        let commit = &analysis.commits[0];
        assert!((commit.file_score - 0.4).abs() < 0.01);
    }

    #[test]
    fn test_calculate_impact_scores_change_score() {
        // 500行変更 → change_score = 0.4
        let events = vec![create_test_event_with_hash_changes(
            "abc1234", "Alice", 250, 250,
        )];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = FileHeatmap::default();

        let analysis =
            calculate_impact_scores(&refs, |_| Some(vec!["src/main.rs".to_string()]), &heatmap);

        let commit = &analysis.commits[0];
        assert!((commit.change_score - 0.4).abs() < 0.01);
    }

    #[test]
    fn test_calculate_impact_scores_sorted_by_score_desc() {
        let events = vec![
            create_test_event_with_hash_changes("low", "Alice", 10, 5), // 低スコア
            create_test_event_with_hash_changes("high", "Bob", 400, 100), // 高スコア
            create_test_event_with_hash_changes("medium", "Carol", 100, 50), // 中スコア
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = FileHeatmap::default();

        let analysis =
            calculate_impact_scores(&refs, |_| Some(vec!["src/main.rs".to_string()]), &heatmap);

        assert_eq!(analysis.commits.len(), 3);
        // スコア降順でソートされている
        assert_eq!(analysis.commits[0].commit_hash, "high");
        assert_eq!(analysis.commits[1].commit_hash, "medium");
        assert_eq!(analysis.commits[2].commit_hash, "low");
    }

    #[test]
    fn test_commit_impact_score_color_high() {
        let commit = CommitImpactScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "Alice".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.8,
            file_score: 0.0,
            change_score: 0.0,
            heat_score: 0.0,
        };
        assert_eq!(commit.score_color(), "red");
    }

    #[test]
    fn test_commit_impact_score_color_medium() {
        let commit = CommitImpactScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "Alice".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.5,
            file_score: 0.0,
            change_score: 0.0,
            heat_score: 0.0,
        };
        assert_eq!(commit.score_color(), "yellow");
    }

    #[test]
    fn test_commit_impact_score_color_low() {
        let commit = CommitImpactScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "Alice".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.2,
            file_score: 0.0,
            change_score: 0.0,
            heat_score: 0.0,
        };
        assert_eq!(commit.score_color(), "green");
    }

    #[test]
    fn test_commit_impact_score_bar() {
        let mut commit = CommitImpactScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "Alice".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.0,
            file_score: 0.0,
            change_score: 0.0,
            heat_score: 0.0,
        };

        commit.score = 0.9;
        assert_eq!(commit.score_bar(), "█████");

        commit.score = 0.7;
        assert_eq!(commit.score_bar(), "████ ");

        commit.score = 0.5;
        assert_eq!(commit.score_bar(), "███  ");

        commit.score = 0.3;
        assert_eq!(commit.score_bar(), "██   ");

        commit.score = 0.1;
        assert_eq!(commit.score_bar(), "█    ");
    }

    #[test]
    fn test_calculate_impact_scores_high_impact_count() {
        let events = vec![
            create_test_event_with_hash_changes("a", "Alice", 400, 100), // high (score >= 0.7)
            create_test_event_with_hash_changes("b", "Bob", 300, 100),   // medium
            create_test_event_with_hash_changes("c", "Carol", 10, 5),    // low
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let heatmap = FileHeatmap::default();

        // 多くのファイルを変更して高スコアに
        let analysis = calculate_impact_scores(
            &refs,
            |hash| {
                if hash == "a" {
                    Some((0..50).map(|i| format!("file{}.rs", i)).collect())
                } else {
                    Some(vec!["file.rs".to_string()])
                }
            },
            &heatmap,
        );

        assert!(analysis.high_impact_count >= 1);
    }

    // ===== Change Coupling テスト =====

    #[test]
    fn test_calculate_change_coupling_empty() {
        let events: Vec<&GitEvent> = vec![];
        let analysis = calculate_change_coupling(&events, |_| None, 5, 0.3);
        assert_eq!(analysis.coupling_count(), 0);
        assert_eq!(analysis.high_coupling_count, 0);
        assert_eq!(analysis.total_files_analyzed, 0);
    }

    #[test]
    fn test_calculate_change_coupling_single_file() {
        // 単一ファイルのコミットではペアが作れないので結合なし
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
            create_test_event_with_hash("commit4"),
            create_test_event_with_hash("commit5"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        let analysis =
            calculate_change_coupling(&refs, |_| Some(vec!["src/main.rs".to_string()]), 1, 0.0);
        assert_eq!(analysis.coupling_count(), 0);
    }

    #[test]
    fn test_calculate_change_coupling_pair() {
        // 2ファイルが常に一緒に変更される場合
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
            create_test_event_with_hash("commit4"),
            create_test_event_with_hash("commit5"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        let analysis = calculate_change_coupling(
            &refs,
            |_| Some(vec!["src/app.rs".to_string(), "src/ui.rs".to_string()]),
            5,
            0.3,
        );

        // A→B と B→A の両方が記録される
        assert_eq!(analysis.coupling_count(), 2);

        // 両方とも100%の結合度
        for coupling in &analysis.couplings {
            assert!((coupling.coupling_percent - 1.0).abs() < 0.01);
            assert_eq!(coupling.co_change_count, 5);
            assert_eq!(coupling.file_change_count, 5);
        }
    }

    #[test]
    fn test_calculate_change_coupling_partial() {
        // 部分的に一緒に変更されるファイル
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
            create_test_event_with_hash("commit4"),
            create_test_event_with_hash("commit5"),
            create_test_event_with_hash("commit6"),
            create_test_event_with_hash("commit7"),
            create_test_event_with_hash("commit8"),
            create_test_event_with_hash("commit9"),
            create_test_event_with_hash("commit10"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        let analysis = calculate_change_coupling(
            &refs,
            |hash| {
                // 最初の8コミットはapp.rsとui.rsを変更
                // 残り2コミットはapp.rsのみ変更
                if hash == "commit9" || hash == "commit10" {
                    Some(vec!["src/app.rs".to_string()])
                } else {
                    Some(vec!["src/app.rs".to_string(), "src/ui.rs".to_string()])
                }
            },
            5,
            0.3,
        );

        // app.rs→ui.rsの結合度は80%（8/10）
        let app_to_ui = analysis
            .couplings
            .iter()
            .find(|c| c.file == "src/app.rs" && c.coupled_file == "src/ui.rs");
        assert!(app_to_ui.is_some());
        let coupling = app_to_ui.unwrap();
        assert!((coupling.coupling_percent - 0.8).abs() < 0.01);

        // ui.rs→app.rsの結合度は100%（8/8）
        let ui_to_app = analysis
            .couplings
            .iter()
            .find(|c| c.file == "src/ui.rs" && c.coupled_file == "src/app.rs");
        assert!(ui_to_app.is_some());
        let coupling = ui_to_app.unwrap();
        assert!((coupling.coupling_percent - 1.0).abs() < 0.01);
    }

    #[test]
    fn test_calculate_change_coupling_min_commits_filter() {
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        // min_commits=5なので、3コミットのファイルは除外される
        let analysis = calculate_change_coupling(
            &refs,
            |_| Some(vec!["src/app.rs".to_string(), "src/ui.rs".to_string()]),
            5,
            0.3,
        );

        assert_eq!(analysis.coupling_count(), 0);
    }

    #[test]
    fn test_calculate_change_coupling_min_coupling_filter() {
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
            create_test_event_with_hash("commit4"),
            create_test_event_with_hash("commit5"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        let analysis = calculate_change_coupling(
            &refs,
            |hash| {
                // commit1だけapp.rsとui.rsを変更（20%の結合度）
                if hash == "commit1" {
                    Some(vec!["src/app.rs".to_string(), "src/ui.rs".to_string()])
                } else {
                    Some(vec!["src/app.rs".to_string()])
                }
            },
            1,
            0.3, // 30%未満は除外
        );

        // app.rs→ui.rsは20%なので除外される
        let app_to_ui = analysis
            .couplings
            .iter()
            .find(|c| c.file == "src/app.rs" && c.coupled_file == "src/ui.rs");
        assert!(app_to_ui.is_none());
    }

    #[test]
    fn test_calculate_change_coupling_high_coupling_count() {
        let events = vec![
            create_test_event_with_hash("commit1"),
            create_test_event_with_hash("commit2"),
            create_test_event_with_hash("commit3"),
            create_test_event_with_hash("commit4"),
            create_test_event_with_hash("commit5"),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        // 100%の結合度（高結合）
        let analysis = calculate_change_coupling(
            &refs,
            |_| Some(vec!["src/app.rs".to_string(), "src/ui.rs".to_string()]),
            5,
            0.3,
        );

        // A→BとB→Aで2つだが、重複を避けて1としてカウント
        assert_eq!(analysis.high_coupling_count, 1);
    }

    #[test]
    fn test_file_coupling_bar() {
        let coupling = FileCoupling {
            file: "src/app.rs".to_string(),
            coupled_file: "src/ui.rs".to_string(),
            co_change_count: 8,
            file_change_count: 10,
            coupling_percent: 0.8,
        };

        // 80%なので8個の█と2個の░
        assert_eq!(coupling.coupling_bar(), "[████████░░]");
    }

    #[test]
    fn test_change_coupling_grouped_by_file() {
        let analysis = ChangeCouplingAnalysis {
            couplings: vec![
                FileCoupling {
                    file: "src/app.rs".to_string(),
                    coupled_file: "src/ui.rs".to_string(),
                    co_change_count: 8,
                    file_change_count: 10,
                    coupling_percent: 0.8,
                },
                FileCoupling {
                    file: "src/app.rs".to_string(),
                    coupled_file: "src/main.rs".to_string(),
                    co_change_count: 5,
                    file_change_count: 10,
                    coupling_percent: 0.5,
                },
                FileCoupling {
                    file: "src/git.rs".to_string(),
                    coupled_file: "src/filter.rs".to_string(),
                    co_change_count: 3,
                    file_change_count: 5,
                    coupling_percent: 0.6,
                },
            ],
            high_coupling_count: 1,
            total_files_analyzed: 5,
        };

        let grouped = analysis.grouped_by_file();
        assert_eq!(grouped.len(), 2);

        // app.rs（10コミット）が先頭
        assert_eq!(grouped[0].0, "src/app.rs");
        assert_eq!(grouped[0].1.len(), 2);

        // git.rs（5コミット）が次
        assert_eq!(grouped[1].0, "src/git.rs");
        assert_eq!(grouped[1].1.len(), 1);
    }

    // ===== Quality Score テスト =====

    #[test]
    fn test_calculate_message_quality_conventional() {
        // Conventional Commit形式のメッセージ
        let score = calculate_message_quality("feat: add new feature for user authentication");
        assert!(score >= 0.7, "Expected >= 0.7, got {}", score);
    }

    #[test]
    fn test_calculate_message_quality_conventional_fix() {
        let score = calculate_message_quality("fix: resolve memory leak in connection pool");
        assert!(score >= 0.7, "Expected >= 0.7, got {}", score);
    }

    #[test]
    fn test_calculate_message_quality_non_conventional() {
        // Conventional形式でないが意味のあるメッセージ
        let score = calculate_message_quality("Add user authentication feature");
        assert!(
            (0.3..0.7).contains(&score),
            "Expected 0.3-0.7, got {}",
            score
        );
    }

    #[test]
    fn test_calculate_message_quality_short() {
        // 短すぎるメッセージ
        let score = calculate_message_quality("fix");
        assert!(score < 0.3, "Expected < 0.3, got {}", score);
    }

    #[test]
    fn test_calculate_message_quality_empty() {
        let score = calculate_message_quality("");
        assert_eq!(score, 0.0);
    }

    #[test]
    fn test_calculate_size_appropriateness_ideal() {
        // 理想的なサイズ（3ファイル、100行変更）
        let score = calculate_size_appropriateness(3, 60, 40);
        assert!(score >= 0.8, "Expected >= 0.8, got {}", score);
    }

    #[test]
    fn test_calculate_size_appropriateness_large() {
        // 大きすぎるコミット（20ファイル、1000行変更）
        let score = calculate_size_appropriateness(20, 800, 200);
        assert!(score <= 0.2, "Expected <= 0.2, got {}", score);
    }

    #[test]
    fn test_calculate_size_appropriateness_empty() {
        // 空のコミット
        let score = calculate_size_appropriateness(0, 0, 0);
        assert_eq!(score, 0.0);
    }

    #[test]
    fn test_calculate_test_presence_both() {
        // ソースとテスト両方
        let files = vec![
            "src/main.rs".to_string(),
            "src/lib.rs".to_string(),
            "tests/test_main.rs".to_string(),
        ];
        let score = calculate_test_presence(&files);
        assert_eq!(score, 1.0);
    }

    #[test]
    fn test_calculate_test_presence_source_only() {
        // ソースのみ
        let files = vec!["src/main.rs".to_string(), "src/lib.rs".to_string()];
        let score = calculate_test_presence(&files);
        assert!(score < 0.5, "Expected < 0.5, got {}", score);
    }

    #[test]
    fn test_calculate_test_presence_test_only() {
        // テストのみ
        let files = vec![
            "tests/test_main.rs".to_string(),
            "src/module_test.rs".to_string(),
        ];
        let score = calculate_test_presence(&files);
        assert!(score >= 0.7, "Expected >= 0.7, got {}", score);
    }

    #[test]
    fn test_calculate_test_presence_empty() {
        let score = calculate_test_presence(&[]);
        assert_eq!(score, 0.0);
    }

    #[test]
    fn test_calculate_atomicity_single_file() {
        let files = vec!["src/main.rs".to_string()];
        let coupling = ChangeCouplingAnalysis::default();
        let score = calculate_atomicity(&files, &coupling);
        assert_eq!(score, 1.0);
    }

    #[test]
    fn test_calculate_atomicity_same_directory() {
        let files = vec![
            "src/app.rs".to_string(),
            "src/lib.rs".to_string(),
            "src/main.rs".to_string(),
        ];
        let coupling = ChangeCouplingAnalysis::default();
        let score = calculate_atomicity(&files, &coupling);
        assert!(score >= 0.5, "Expected >= 0.5, got {}", score);
    }

    #[test]
    fn test_calculate_atomicity_scattered() {
        let files = vec![
            "src/app.rs".to_string(),
            "tests/test.rs".to_string(),
            "docs/readme.md".to_string(),
            "config/settings.toml".to_string(),
        ];
        let coupling = ChangeCouplingAnalysis::default();
        let score = calculate_atomicity(&files, &coupling);
        assert!(score < 0.5, "Expected < 0.5, got {}", score);
    }

    #[test]
    fn test_calculate_quality_scores_empty() {
        let events: Vec<&GitEvent> = vec![];
        let coupling = ChangeCouplingAnalysis::default();
        let analysis = calculate_quality_scores(&events, |_| None, &coupling);
        assert_eq!(analysis.total_commits, 0);
        assert_eq!(analysis.commits.len(), 0);
        assert_eq!(analysis.avg_score, 0.0);
    }

    fn create_test_event_for_quality(
        hash: &str,
        message: &str,
        insertions: usize,
        deletions: usize,
    ) -> GitEvent {
        GitEvent::commit(
            hash.to_string(),
            message.to_string(),
            "author".to_string(),
            Local::now(),
            insertions,
            deletions,
        )
    }

    #[test]
    fn test_calculate_quality_scores_single_commit() {
        let events = vec![create_test_event_for_quality(
            "abc1234",
            "feat: add authentication feature",
            50,
            10,
        )];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let coupling = ChangeCouplingAnalysis::default();

        let analysis = calculate_quality_scores(
            &refs,
            |_| {
                Some(vec![
                    "src/auth.rs".to_string(),
                    "tests/auth_test.rs".to_string(),
                ])
            },
            &coupling,
        );

        assert_eq!(analysis.total_commits, 1);
        assert_eq!(analysis.commits.len(), 1);

        let commit = &analysis.commits[0];
        assert_eq!(commit.commit_hash, "abc1234");
        assert!(commit.score > 0.0);
        assert!(commit.message_score > 0.0);
        assert!(commit.size_score > 0.0);
        assert!(commit.test_score > 0.0);
    }

    #[test]
    fn test_calculate_quality_scores_sorted_by_score() {
        let events = vec![
            create_test_event_for_quality("low", "wip", 500, 500), // 低品質
            create_test_event_for_quality("high", "feat: excellent commit with tests", 50, 20), // 高品質
            create_test_event_for_quality("medium", "update files", 100, 50), // 中品質
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let coupling = ChangeCouplingAnalysis::default();

        let analysis = calculate_quality_scores(
            &refs,
            |hash| {
                if hash == "high" {
                    Some(vec![
                        "src/feature.rs".to_string(),
                        "tests/feature_test.rs".to_string(),
                    ])
                } else {
                    Some(vec!["src/main.rs".to_string()])
                }
            },
            &coupling,
        );

        assert_eq!(analysis.commits.len(), 3);
        // スコア降順でソートされている
        assert!(analysis.commits[0].score >= analysis.commits[1].score);
        assert!(analysis.commits[1].score >= analysis.commits[2].score);
    }

    #[test]
    fn test_commit_quality_score_color() {
        let mut commit = CommitQualityScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "author".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.0,
            message_score: 0.0,
            size_score: 0.0,
            test_score: 0.0,
            atomicity_score: 0.0,
        };

        // >= 0.6 は green（Excellent/Good）
        commit.score = 0.9;
        assert_eq!(commit.score_color(), "green");

        commit.score = 0.7;
        assert_eq!(commit.score_color(), "green");

        commit.score = 0.6;
        assert_eq!(commit.score_color(), "green");

        // 0.4-0.6 は yellow（Fair）
        commit.score = 0.5;
        assert_eq!(commit.score_color(), "yellow");

        commit.score = 0.4;
        assert_eq!(commit.score_color(), "yellow");

        // < 0.4 は red（Poor）
        commit.score = 0.3;
        assert_eq!(commit.score_color(), "red");

        commit.score = 0.2;
        assert_eq!(commit.score_color(), "red");
    }

    #[test]
    fn test_commit_quality_score_bar() {
        let mut commit = CommitQualityScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "author".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.0,
            message_score: 0.0,
            size_score: 0.0,
            test_score: 0.0,
            atomicity_score: 0.0,
        };

        commit.score = 0.9;
        assert_eq!(commit.score_bar(), "█████");

        commit.score = 0.7;
        assert_eq!(commit.score_bar(), "████ ");

        commit.score = 0.5;
        assert_eq!(commit.score_bar(), "███  ");

        commit.score = 0.3;
        assert_eq!(commit.score_bar(), "██   ");

        commit.score = 0.1;
        assert_eq!(commit.score_bar(), "█    ");
    }

    #[test]
    fn test_commit_quality_score_quality_level() {
        let mut commit = CommitQualityScore {
            commit_hash: "abc".to_string(),
            commit_message: "test".to_string(),
            author: "author".to_string(),
            date: Local::now(),
            files_changed: 0,
            insertions: 0,
            deletions: 0,
            score: 0.0,
            message_score: 0.0,
            size_score: 0.0,
            test_score: 0.0,
            atomicity_score: 0.0,
        };

        commit.score = 0.9;
        assert_eq!(commit.quality_level(), "Excellent");

        commit.score = 0.7;
        assert_eq!(commit.quality_level(), "Good");

        commit.score = 0.5;
        assert_eq!(commit.quality_level(), "Fair");

        commit.score = 0.2;
        assert_eq!(commit.quality_level(), "Poor");
    }

    #[test]
    fn test_quality_analysis_high_low_counts() {
        let events = vec![
            create_test_event_for_quality("high1", "feat: great feature", 30, 10),
            create_test_event_for_quality("high2", "fix: important fix", 20, 5),
            create_test_event_for_quality("low1", "x", 1000, 1000),
            create_test_event_for_quality("low2", ".", 2000, 500),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();
        let coupling = ChangeCouplingAnalysis::default();

        let analysis = calculate_quality_scores(
            &refs,
            |hash| {
                if hash == "high1" || hash == "high2" {
                    Some(vec![
                        "src/feature.rs".to_string(),
                        "tests/feature_test.rs".to_string(),
                    ])
                } else {
                    Some((0..50).map(|i| format!("file{}.rs", i)).collect())
                }
            },
            &coupling,
        );

        assert_eq!(analysis.total_commits, 4);
        // 高品質と低品質がカウントされている
        assert!(analysis.high_quality_count > 0 || analysis.low_quality_count > 0);
    }

    // ===== Project Health テスト =====

    #[test]
    fn test_project_health_default() {
        let health = ProjectHealth::default();
        assert_eq!(health.overall_score, 50);
        assert_eq!(health.level(), "Fair");
    }

    #[test]
    fn test_project_health_level() {
        let health = ProjectHealth {
            overall_score: 90,
            ..Default::default()
        };
        assert_eq!(health.level(), "Excellent");

        let health = ProjectHealth {
            overall_score: 75,
            ..Default::default()
        };
        assert_eq!(health.level(), "Good");

        let health = ProjectHealth {
            overall_score: 50,
            ..Default::default()
        };
        assert_eq!(health.level(), "Fair");

        let health = ProjectHealth {
            overall_score: 20,
            ..Default::default()
        };
        assert_eq!(health.level(), "Poor");
    }

    #[test]
    fn test_project_health_score_bar() {
        let health = ProjectHealth {
            overall_score: 100,
            ..Default::default()
        };
        assert_eq!(health.score_bar(), "██████████");

        let health = ProjectHealth {
            overall_score: 50,
            ..Default::default()
        };
        assert_eq!(health.score_bar(), "█████░░░░░");

        let health = ProjectHealth {
            overall_score: 0,
            ..Default::default()
        };
        assert_eq!(health.score_bar(), "░░░░░░░░░░");
    }

    #[test]
    fn test_alert_severity_ordering() {
        assert!(AlertSeverity::Critical > AlertSeverity::Warning);
        assert!(AlertSeverity::Warning > AlertSeverity::Info);
    }

    #[test]
    fn test_calculate_project_health_empty() {
        let events: Vec<&GitEvent> = vec![];
        let health = calculate_project_health(&events, |_| None, None, None, None);
        assert_eq!(health.overall_score, 50);
        assert_eq!(health.total_commits, 0);
    }

    #[test]
    fn test_calculate_project_health_with_events() {
        let events = vec![
            create_test_event_for_quality("hash1", "feat: add new feature", 50, 10),
            create_test_event_for_quality("hash2", "fix: bug fix", 20, 5),
            create_test_event_for_quality("hash3", "test: add tests", 30, 0),
        ];
        let refs: Vec<&GitEvent> = events.iter().collect();

        let health = calculate_project_health(&refs, |_| None, None, None, None);

        assert_eq!(health.total_commits, 3);
        assert!(health.overall_score > 0);
        // Conventional commits なので品質スコアが高いはず
        assert!(health.quality.score > 0.5);
    }

    #[test]
    fn test_calculate_project_health_alerts() {
        // 1人の著者が全てのコミット → bus factor リスク
        let mut events = Vec::new();
        for i in 0..10 {
            let mut event = create_test_event("single_author", 10, 5);
            event.short_hash = format!("hash{}", i);
            events.push(event);
        }
        let refs: Vec<&GitEvent> = events.iter().collect();

        let health = calculate_project_health(&refs, |_| None, None, None, None);

        // 単一著者なのでbus factorアラートが発生するはず
        assert!(!health.alerts.is_empty());
        let has_bus_factor_alert = health
            .alerts
            .iter()
            .any(|a| a.message.contains("bus factor"));
        assert!(has_bus_factor_alert);
    }
}