smart-tree 8.0.1

//! Developer Persona Analysis for MEM8
//! Creates unique wave signatures for each developer based on their git history

use crate::mem8::{
    git_temporal::{GitCommit, GitTemporalAnalyzer},
    integration::SmartTreeMem8,
    wave::{FrequencyBand, MemoryWave},
};
use anyhow::Result;
use chrono::{DateTime, Datelike, Timelike, Utc};
use std::collections::HashMap;
use std::path::Path;

/// Developer persona with unique characteristics
#[derive(Debug, Clone)]
pub struct DeveloperPersona {
    /// Developer name/email
    pub identity: String,

    /// Coding style signature
    pub style_signature: CodingStyle,

    /// Temporal patterns (when they work)
    pub temporal_pattern: TemporalPattern,

    /// Emotional profile from commit messages
    pub emotional_profile: EmotionalProfile,

    /// Collaboration patterns
    pub collaboration: CollaborationPattern,

    /// Expertise areas (files/directories they work on)
    pub expertise_map: HashMap<String, f32>,

    /// Overall contribution metrics
    pub metrics: ContributionMetrics,
}

#[derive(Debug, Clone)]
pub struct CodingStyle {
    /// Average commit size (lines changed)
    pub avg_commit_size: f32,

    /// Preference for large refactors vs small changes
    pub refactor_tendency: f32, // 0.0 = small changes, 1.0 = large refactors

    /// Bug fix ratio
    pub bugfix_ratio: f32,

    /// Feature development ratio
    pub feature_ratio: f32,

    /// Documentation contribution ratio
    pub documentation_ratio: f32,

    /// Test writing ratio
    pub test_ratio: f32,
}

#[derive(Debug, Clone)]
pub struct TemporalPattern {
    /// Preferred hours of day (0-23)
    pub active_hours: [f32; 24],

    /// Preferred days of week (0=Monday, 6=Sunday)
    pub active_days: [f32; 7],

    /// Night owl vs early bird (-1.0 = night owl, 1.0 = early bird)
    pub chronotype: f32,

    /// Weekend warrior score (0.0 = weekday only, 1.0 = weekend heavy)
    pub weekend_warrior: f32,

    /// Consistency score (0.0 = sporadic, 1.0 = very regular)
    pub consistency: f32,
}

#[derive(Debug, Clone)]
pub struct EmotionalProfile {
    /// Overall positivity in commit messages
    pub positivity: f32,

    /// Excitement level (exclamation marks, enthusiastic words)
    pub excitement: f32,

    /// Frustration level (curse words, "fix", "bug", "broken")
    pub frustration: f32,

    /// Professionalism (formal vs casual language)
    pub professionalism: f32,

    /// Humor level (jokes, puns, emojis)
    pub humor: f32,
}

#[derive(Debug, Clone)]
pub struct CollaborationPattern {
    /// Solo vs team player (0.0 = solo, 1.0 = highly collaborative)
    pub collaboration_score: f32,

    /// Developers they frequently work with
    pub frequent_collaborators: HashMap<String, f32>,

    /// Response time to others' changes
    pub responsiveness: f32,

    /// Code review participation
    pub review_participation: f32,
}

#[derive(Debug, Clone)]
pub struct ContributionMetrics {
    pub total_commits: usize,
    pub total_additions: usize,
    pub total_deletions: usize,
    pub files_touched: usize,
    pub first_commit: DateTime<Utc>,
    pub last_commit: DateTime<Utc>,
    pub active_days: usize,
}

/// Persona analyzer for git repositories
pub struct PersonaAnalyzer {
    analyzer: GitTemporalAnalyzer,
}

impl PersonaAnalyzer {
    pub fn new(repo_path: impl AsRef<Path>) -> Result<Self> {
        Ok(Self {
            analyzer: GitTemporalAnalyzer::new(repo_path)?,
        })
    }

    /// Analyze all developers in the repository
    pub fn analyze_all_developers(&self) -> Result<HashMap<String, DeveloperPersona>> {
        let commits = self.analyzer.get_project_timeline()?;

        // Group commits by author
        let mut author_commits: HashMap<String, Vec<GitCommit>> = HashMap::new();
        for commit in commits {
            author_commits
                .entry(commit.author.clone())
                .or_default()
                .push(commit);
        }

        // Analyze each developer
        let mut personas = HashMap::new();
        for (author, commits) in author_commits {
            if commits.len() >= 5 {
                // Need at least 5 commits for meaningful analysis
                let persona = self.analyze_developer(&author, commits)?;
                personas.insert(author, persona);
            }
        }

        Ok(personas)
    }

    /// Analyze a specific developer
    fn analyze_developer(
        &self,
        identity: &str,
        commits: Vec<GitCommit>,
    ) -> Result<DeveloperPersona> {
        let style = self.analyze_coding_style(&commits);
        let temporal = self.analyze_temporal_pattern(&commits);
        let emotional = self.analyze_emotional_profile(&commits);
        let collaboration = self.analyze_collaboration(&commits);
        let expertise = self.analyze_expertise(&commits);
        let metrics = self.calculate_metrics(&commits);

        Ok(DeveloperPersona {
            identity: identity.to_string(),
            style_signature: style,
            temporal_pattern: temporal,
            emotional_profile: emotional,
            collaboration,
            expertise_map: expertise,
            metrics,
        })
    }

    fn analyze_coding_style(&self, commits: &[GitCommit]) -> CodingStyle {
        let total = commits.len() as f32;

        // Calculate average commit size
        let avg_changes: f32 = commits
            .iter()
            .map(|c| (c.additions + c.deletions) as f32)
            .sum::<f32>()
            / total;

        // Categorize commits
        let mut bugfixes = 0;
        let mut features = 0;
        let mut docs = 0;
        let mut tests = 0;
        let mut large_commits = 0;

        for commit in commits {
            let msg = commit.message.to_lowercase();
            if msg.contains("fix") || msg.contains("bug") {
                bugfixes += 1;
            }
            if msg.contains("feat") || msg.contains("add") || msg.contains("implement") {
                features += 1;
            }
            if msg.contains("doc") || msg.contains("readme") {
                docs += 1;
            }
            if msg.contains("test") || msg.contains("spec") {
                tests += 1;
            }
            if commit.additions + commit.deletions > 500 {
                large_commits += 1;
            }
        }

        CodingStyle {
            avg_commit_size: avg_changes,
            refactor_tendency: (large_commits as f32 / total).min(1.0),
            bugfix_ratio: (bugfixes as f32 / total).min(1.0),
            feature_ratio: (features as f32 / total).min(1.0),
            documentation_ratio: (docs as f32 / total).min(1.0),
            test_ratio: (tests as f32 / total).min(1.0),
        }
    }

    fn analyze_temporal_pattern(&self, commits: &[GitCommit]) -> TemporalPattern {
        let mut hour_counts = [0f32; 24];
        let mut day_counts = [0f32; 7];
        let mut morning_commits = 0;
        let mut evening_commits = 0;
        let mut weekend_commits = 0;

        for commit in commits {
            let hour = commit.timestamp.hour() as usize;
            let day = commit.timestamp.weekday().num_days_from_monday() as usize;

            hour_counts[hour] += 1.0;
            day_counts[day] += 1.0;

            if (5..12).contains(&hour) {
                morning_commits += 1;
            } else if !(5..20).contains(&hour) {
                evening_commits += 1;
            }

            if day >= 5 {
                // Saturday or Sunday
                weekend_commits += 1;
            }
        }

        // Normalize
        let max_hour = hour_counts.iter().fold(0.0f32, |a, &b| a.max(b)).max(1.0);
        let max_day = day_counts.iter().fold(0.0f32, |a, &b| a.max(b)).max(1.0);

        for h in &mut hour_counts {
            *h /= max_hour;
        }
        for d in &mut day_counts {
            *d /= max_day;
        }

        // Calculate chronotype
        let chronotype = if evening_commits > morning_commits {
            -((evening_commits as f32) / (evening_commits + morning_commits) as f32)
        } else {
            (morning_commits as f32) / (evening_commits + morning_commits).max(1) as f32
        };

        // Calculate consistency (standard deviation of commit times)
        let commit_intervals = Self::calculate_commit_intervals(commits);
        let consistency = 1.0 / (1.0 + commit_intervals);

        TemporalPattern {
            active_hours: hour_counts,
            active_days: day_counts,
            chronotype,
            weekend_warrior: weekend_commits as f32 / commits.len() as f32,
            consistency,
        }
    }

    fn analyze_emotional_profile(&self, commits: &[GitCommit]) -> EmotionalProfile {
        let mut positivity = 0.0;
        let mut excitement = 0.0;
        let mut frustration = 0.0;
        let mut professionalism = 0.0;
        let mut humor = 0.0;

        for commit in commits {
            let msg = &commit.message;

            // Positivity indicators
            if msg.contains("awesome") || msg.contains("great") || msg.contains("excellent") {
                positivity += 1.0;
            }

            // Excitement indicators
            excitement += msg.matches('!').count() as f32;
            if msg.contains("finally") || msg.contains("yay") {
                excitement += 1.0;
            }

            // Frustration indicators
            if msg.contains("fix") || msg.contains("bug") || msg.contains("broken") {
                frustration += 1.0;
            }
            if msg.contains("damn") || msg.contains("crap") || msg.contains("wtf") {
                frustration += 2.0;
            }

            // Professionalism (longer, structured messages)
            if msg.len() > 50 && msg.contains(':') {
                professionalism += 1.0;
            }

            // Humor indicators
            if msg.contains("🤣") || msg.contains("😂") || msg.contains("lol") {
                humor += 1.0;
            }
        }

        let total = commits.len() as f32;
        EmotionalProfile {
            positivity: (positivity / total).min(1.0),
            excitement: (excitement / (total * 2.0)).min(1.0),
            frustration: (frustration / total).min(1.0),
            professionalism: (professionalism / total).min(1.0),
            humor: (humor / total).min(1.0),
        }
    }

    fn analyze_collaboration(&self, _commits: &[GitCommit]) -> CollaborationPattern {
        // Simplified collaboration analysis
        // In a real implementation, we'd analyze co-authored commits,
        // PR reviews, and response times

        CollaborationPattern {
            collaboration_score: 0.5, // Default middle ground
            frequent_collaborators: HashMap::new(),
            responsiveness: 0.5,
            review_participation: 0.5,
        }
    }

    fn analyze_expertise(&self, commits: &[GitCommit]) -> HashMap<String, f32> {
        let mut file_counts: HashMap<String, usize> = HashMap::new();

        for commit in commits {
            for file in &commit.files_changed {
                // Extract directory or file type as expertise area
                let expertise_key = if let Some(dir_end) = file.find('/') {
                    file[..dir_end].to_string()
                } else if let Some(ext_start) = file.rfind('.') {
                    format!("*.{}", &file[ext_start + 1..])
                } else {
                    file.clone()
                };

                *file_counts.entry(expertise_key).or_insert(0) += 1;
            }
        }

        // Normalize to 0-1 range
        let max_count = file_counts.values().max().copied().unwrap_or(1) as f32;
        file_counts
            .into_iter()
            .map(|(k, v)| (k, v as f32 / max_count))
            .collect()
    }

    fn calculate_metrics(&self, commits: &[GitCommit]) -> ContributionMetrics {
        let total_additions: usize = commits.iter().map(|c| c.additions).sum();
        let total_deletions: usize = commits.iter().map(|c| c.deletions).sum();

        let mut unique_files = std::collections::HashSet::new();
        for commit in commits {
            for file in &commit.files_changed {
                unique_files.insert(file.clone());
            }
        }

        ContributionMetrics {
            total_commits: commits.len(),
            total_additions,
            total_deletions,
            files_touched: unique_files.len(),
            first_commit: commits.last().map(|c| c.timestamp).unwrap_or_else(Utc::now),
            last_commit: commits
                .first()
                .map(|c| c.timestamp)
                .unwrap_or_else(Utc::now),
            active_days: Self::count_active_days(commits),
        }
    }

    fn calculate_commit_intervals(commits: &[GitCommit]) -> f32 {
        if commits.len() < 2 {
            return 0.0;
        }

        let mut intervals = Vec::new();
        for i in 1..commits.len() {
            let interval = (commits[i - 1].timestamp - commits[i].timestamp).num_hours() as f32;
            intervals.push(interval);
        }

        // Calculate standard deviation
        let mean = intervals.iter().sum::<f32>() / intervals.len() as f32;
        let variance =
            intervals.iter().map(|&x| (x - mean).powi(2)).sum::<f32>() / intervals.len() as f32;

        variance.sqrt() / (mean + 1.0) // Normalized by mean
    }

    fn count_active_days(commits: &[GitCommit]) -> usize {
        let mut active_days = std::collections::HashSet::new();
        for commit in commits {
            active_days.insert(commit.timestamp.date_naive());
        }
        active_days.len()
    }
}

/// Extension for MEM8 to create developer-specific wave patterns
impl SmartTreeMem8 {
    /// Import developer personas as unique wave signatures
    pub fn import_developer_personas(&mut self, repo_path: impl AsRef<Path>) -> Result<()> {
        let analyzer = PersonaAnalyzer::new(repo_path)?;
        let personas = analyzer.analyze_all_developers()?;

        println!("Found {} developer personas", personas.len());

        for (developer, persona) in personas {
            println!("\nCreating wave signature for: {}", developer);

            // Create base frequency from coding style
            let base_freq = if persona.style_signature.refactor_tendency > 0.5 {
                FrequencyBand::DeepStructural.frequency(0.7) // Architects
            } else if persona.style_signature.bugfix_ratio > 0.5 {
                FrequencyBand::Technical.frequency(0.8) // Fixers
            } else if persona.style_signature.feature_ratio > 0.5 {
                FrequencyBand::Implementation.frequency(0.6) // Builders
            } else {
                FrequencyBand::Conversational.frequency(0.5) // Generalists
            };

            // Create temporal rhythm from work patterns
            for (hour, &intensity) in persona.temporal_pattern.active_hours.iter().enumerate() {
                if intensity > 0.2 {
                    let mut wave = MemoryWave::new(
                        base_freq + (hour as f32 * 10.0), // Slight frequency shift per hour
                        intensity * 0.8,
                    );

                    // Emotional modulation
                    wave.valence = persona.emotional_profile.positivity
                        - persona.emotional_profile.frustration;
                    wave.arousal = persona.emotional_profile.excitement;
                    wave.decay_tau = None; // Persistent persona pattern

                    // Store in persona layer (high Z values)
                    let x = (self.simple_hash(&developer) & 0xFF) as u8;
                    let y = (hour * 10) as u8;
                    let z = 64000
                        + (self.simple_hash(&format!("{}-{}", developer, hour)) & 0x3FF) as u16;

                    self.store_wave_at_coordinates(x, y, z, wave)?;
                }
            }

            // Create expertise signatures
            for (area, expertise) in persona.expertise_map {
                if expertise > 0.3 {
                    let mut wave = MemoryWave::new(
                        base_freq + 100.0, // Expertise frequency band
                        expertise,
                    );

                    wave.valence = 0.7; // Positive association with expertise
                    wave.decay_tau = None; // Persistent

                    let (x, y) = self.string_to_coordinates(&format!("{}-{}", developer, area));
                    let z = 63000;

                    self.store_wave_at_coordinates(x, y, z, wave)?;
                }
            }

            // Print persona summary
            println!(
                "  Style: {:.0}% features, {:.0}% bugfixes, {:.0}% refactoring",
                persona.style_signature.feature_ratio * 100.0,
                persona.style_signature.bugfix_ratio * 100.0,
                persona.style_signature.refactor_tendency * 100.0
            );
            println!(
                "  Chronotype: {} ({:.1})",
                if persona.temporal_pattern.chronotype < -0.3 {
                    "Night Owl 🦉"
                } else if persona.temporal_pattern.chronotype > 0.3 {
                    "Early Bird 🐦"
                } else {
                    "Flexible ⏰"
                },
                persona.temporal_pattern.chronotype
            );
            println!(
                "  Emotional: {:.0}% positive, {:.0}% excited",
                persona.emotional_profile.positivity * 100.0,
                persona.emotional_profile.excitement * 100.0
            );
            println!(
                "  Contributions: {} commits, {} files touched",
                persona.metrics.total_commits, persona.metrics.files_touched
            );
        }

        Ok(())
    }

    /// Query memories specific to a developer
    pub fn query_developer_memories(&self, _developer_name: &str) -> Vec<(MemoryWave, String)> {
        // Implementation would search for waves in the developer's frequency/spatial range
        // For now, return empty vec as placeholder
        Vec::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_persona_analysis() {
        // Test would run on a real git repo
        if let Ok(analyzer) = PersonaAnalyzer::new(".") {
            if let Ok(personas) = analyzer.analyze_all_developers() {
                for (dev, persona) in personas {
                    println!(
                        "Developer: {} - {} commits",
                        dev, persona.metrics.total_commits
                    );
                }
            }
        }
    }
}