gitstack/

stats.rs

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

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

use crate::event::GitEvent;

// =============================================================================
// 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,
    }
}

#[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);
    }
}