{
  "technologies": {
    "PostgreSQL": {
      "category_scores": {
        "performance": 85.0,
        "scalability": 90.0,
        "developer_experience": 75.0,
        "ecosystem": 95.0,
        "learning_curve": 70.0,
        "documentation": 90.0,
        "community_support": 95.0,
        "enterprise_readiness": 95.0
      },
      "weighted_total": 85.5,
      "strengths": ["scalability", "ecosystem", "documentation", "community_support", "enterprise_readiness"],
      "weaknesses": ["learning_curve"]
    },
    "MongoDB": {
      "category_scores": {
        "performance": 80.0,
        "scalability": 95.0,
        "developer_experience": 85.0,
        "ecosystem": 85.0,
        "learning_curve": 80.0,
        "documentation": 85.0,
        "community_support": 85.0,
        "enterprise_readiness": 75.0
      },
      "weighted_total": 84.5,
      "strengths": ["scalability", "developer_experience", "learning_curve"],
      "weaknesses": []
    }
  },
  "recommendation": "PostgreSQL",
  "confidence": 52.0,
  "decision_factors": [
    {
      "category": "performance",
      "importance": "20.0%",
      "best_performer": "PostgreSQL",
      "score": 85.0
    },
    {
      "category": "scalability",
      "importance": "20.0%",
      "best_performer": "MongoDB",
      "score": 95.0
    },
    {
      "category": "developer_experience",
      "importance": "15.0%",
      "best_performer": "MongoDB",
      "score": 85.0
    }
  ],
  "comparison_matrix": [
    {
      "category": "Performance",
      "weight": "20.0%",
      "scores": {
        "PostgreSQL": "85.0",
        "MongoDB": "80.0"
      }
    },
    {
      "category": "Scalability",
      "weight": "20.0%",
      "scores": {
        "PostgreSQL": "90.0",
        "MongoDB": "95.0"
      }
    },
    {
      "category": "WEIGHTED TOTAL",
      "weight": "100%",
      "scores": {
        "PostgreSQL": "85.5",
        "MongoDB": "84.5"
      }
    }
  ]
}

{
  "comparison": {
    "technologies": [
      {
        "name": "PostgreSQL",
        "performance": {"score": 85},
        "scalability": {"score": 90},
        "developer_experience": {"score": 75},
        "ecosystem": {"score": 95},
        "learning_curve": {"score": 70},
        "documentation": {"score": 90},
        "community_support": {"score": 95},
        "enterprise_readiness": {"score": 95}
      },
      {
        "name": "MongoDB",
        "performance": {"score": 80},
        "scalability": {"score": 95},
        "developer_experience": {"score": 85},
        "ecosystem": {"score": 85},
        "learning_curve": {"score": 80},
        "documentation": {"score": 85},
        "community_support": {"score": 85},
        "enterprise_readiness": {"score": 75}
      }
    ],
    "use_case": "SaaS application with complex queries",
    "weights": {
      "performance": 20,
      "scalability": 20,
      "developer_experience": 15,
      "ecosystem": 15,
      "learning_curve": 10,
      "documentation": 10,
      "community_support": 5,
      "enterprise_readiness": 5
    }
  }
}

{
  "tco_analysis": {
    "technology": "AWS",
    "team_size": 10,
    "timeline_years": 5,
    "initial_costs": {
      "licensing": 0,
      "training_hours_per_dev": 40,
      "developer_hourly_rate": 100,
      "training_materials": 1000,
      "migration": 50000,
      "setup": 10000,
      "tooling": 5000
    },
    "operational_costs": {
      "annual_licensing": 0,
      "monthly_hosting": 5000,
      "annual_support": 20000,
      "maintenance_hours_per_dev_monthly": 20
    },
    "scaling_params": {
      "initial_users": 5000,
      "annual_growth_rate": 0.30,
      "initial_servers": 10,
      "cost_per_server_monthly": 300
    },
    "productivity_factors": {
      "productivity_multiplier": 1.2,
      "time_to_market_reduction_days": 15,
      "avg_feature_time_days": 45,
      "avg_feature_value": 15000,
      "technical_debt_percentage": 0.12,
      "vendor_lock_in_risk": "medium",
      "security_incidents_per_year": 0.3,
      "avg_security_incident_cost": 30000,
      "downtime_hours_per_year": 4,
      "downtime_cost_per_hour": 8000,
      "annual_turnover_rate": 0.12,
      "cost_per_new_hire": 35000
    }
  }
}

{
  "format": "text",
  "input": "Compare React vs Vue for building a SaaS dashboard with real-time collaboration features. Our team has 8 developers, and we need to consider developer experience, ecosystem maturity, and performance."
}

"""
Ecosystem Health Analyzer.

Analyzes technology ecosystem health including community size, maintenance status,
GitHub metrics, npm downloads, and long-term viability assessment.
"""

from typing import Dict, List, Any, Optional
from datetime import datetime, timedelta


class EcosystemAnalyzer:
    """Analyze technology ecosystem health and viability."""

    def __init__(self, ecosystem_data: Dict[str, Any]):
        """
        Initialize analyzer with ecosystem data.

        Args:
            ecosystem_data: Dictionary containing GitHub, npm, and community metrics
        """
        self.technology = ecosystem_data.get('technology', 'Unknown')
        self.github_data = ecosystem_data.get('github', {})
        self.npm_data = ecosystem_data.get('npm', {})
        self.community_data = ecosystem_data.get('community', {})
        self.corporate_backing = ecosystem_data.get('corporate_backing', {})

    def calculate_health_score(self) -> Dict[str, float]:
        """
        Calculate overall ecosystem health score (0-100).

        Returns:
            Dictionary of health score components
        """
        scores = {
            'github_health': self._score_github_health(),
            'npm_health': self._score_npm_health(),
            'community_health': self._score_community_health(),
            'corporate_backing': self._score_corporate_backing(),
            'maintenance_health': self._score_maintenance_health()
        }

        # Calculate weighted average
        weights = {
            'github_health': 0.25,
            'npm_health': 0.20,
            'community_health': 0.20,
            'corporate_backing': 0.15,
            'maintenance_health': 0.20
        }

        overall = sum(scores[k] * weights[k] for k in scores.keys())
        scores['overall_health'] = overall

        return scores

    def _score_github_health(self) -> float:
        """
        Score GitHub repository health.

        Returns:
            GitHub health score (0-100)
        """
        score = 0.0

        # Stars (0-30 points)
        stars = self.github_data.get('stars', 0)
        if stars >= 50000:
            score += 30
        elif stars >= 20000:
            score += 25
        elif stars >= 10000:
            score += 20
        elif stars >= 5000:
            score += 15
        elif stars >= 1000:
            score += 10
        else:
            score += max(0, stars / 100)  # 1 point per 100 stars

        # Forks (0-20 points)
        forks = self.github_data.get('forks', 0)
        if forks >= 10000:
            score += 20
        elif forks >= 5000:
            score += 15
        elif forks >= 2000:
            score += 12
        elif forks >= 1000:
            score += 10
        else:
            score += max(0, forks / 100)

        # Contributors (0-20 points)
        contributors = self.github_data.get('contributors', 0)
        if contributors >= 500:
            score += 20
        elif contributors >= 200:
            score += 15
        elif contributors >= 100:
            score += 12
        elif contributors >= 50:
            score += 10
        else:
            score += max(0, contributors / 5)

        # Commit frequency (0-30 points)
        commits_last_month = self.github_data.get('commits_last_month', 0)
        if commits_last_month >= 100:
            score += 30
        elif commits_last_month >= 50:
            score += 25
        elif commits_last_month >= 25:
            score += 20
        elif commits_last_month >= 10:
            score += 15
        else:
            score += max(0, commits_last_month * 1.5)

        return min(100.0, score)

    def _score_npm_health(self) -> float:
        """
        Score npm package health (if applicable).

        Returns:
            npm health score (0-100)
        """
        if not self.npm_data:
            return 50.0  # Neutral score if not applicable

        score = 0.0

        # Weekly downloads (0-40 points)
        weekly_downloads = self.npm_data.get('weekly_downloads', 0)
        if weekly_downloads >= 1000000:
            score += 40
        elif weekly_downloads >= 500000:
            score += 35
        elif weekly_downloads >= 100000:
            score += 30
        elif weekly_downloads >= 50000:
            score += 25
        elif weekly_downloads >= 10000:
            score += 20
        else:
            score += max(0, weekly_downloads / 500)

        # Version stability (0-20 points)
        version = self.npm_data.get('version', '0.0.1')
        major_version = int(version.split('.')[0]) if version else 0

        if major_version >= 5:
            score += 20
        elif major_version >= 3:
            score += 15
        elif major_version >= 1:
            score += 10
        else:
            score += 5

        # Dependencies count (0-20 points, fewer is better)
        dependencies = self.npm_data.get('dependencies_count', 50)
        if dependencies <= 10:
            score += 20
        elif dependencies <= 25:
            score += 15
        elif dependencies <= 50:
            score += 10
        else:
            score += max(0, 20 - (dependencies - 50) / 10)

        # Last publish date (0-20 points)
        days_since_publish = self.npm_data.get('days_since_last_publish', 365)
        if days_since_publish <= 30:
            score += 20
        elif days_since_publish <= 90:
            score += 15
        elif days_since_publish <= 180:
            score += 10
        elif days_since_publish <= 365:
            score += 5
        else:
            score += 0

        return min(100.0, score)

    def _score_community_health(self) -> float:
        """
        Score community health and engagement.

        Returns:
            Community health score (0-100)
        """
        score = 0.0

        # Stack Overflow questions (0-25 points)
        so_questions = self.community_data.get('stackoverflow_questions', 0)
        if so_questions >= 50000:
            score += 25
        elif so_questions >= 20000:
            score += 20
        elif so_questions >= 10000:
            score += 15
        elif so_questions >= 5000:
            score += 10
        else:
            score += max(0, so_questions / 500)

        # Job postings (0-25 points)
        job_postings = self.community_data.get('job_postings', 0)
        if job_postings >= 5000:
            score += 25
        elif job_postings >= 2000:
            score += 20
        elif job_postings >= 1000:
            score += 15
        elif job_postings >= 500:
            score += 10
        else:
            score += max(0, job_postings / 50)

        # Tutorials and resources (0-25 points)
        tutorials = self.community_data.get('tutorials_count', 0)
        if tutorials >= 1000:
            score += 25
        elif tutorials >= 500:
            score += 20
        elif tutorials >= 200:
            score += 15
        elif tutorials >= 100:
            score += 10
        else:
            score += max(0, tutorials / 10)

        # Active forums/Discord (0-25 points)
        forum_members = self.community_data.get('forum_members', 0)
        if forum_members >= 50000:
            score += 25
        elif forum_members >= 20000:
            score += 20
        elif forum_members >= 10000:
            score += 15
        elif forum_members >= 5000:
            score += 10
        else:
            score += max(0, forum_members / 500)

        return min(100.0, score)

    def _score_corporate_backing(self) -> float:
        """
        Score corporate backing strength.

        Returns:
            Corporate backing score (0-100)
        """
        backing_type = self.corporate_backing.get('type', 'none')

        scores = {
            'major_tech_company': 100,  # Google, Microsoft, Meta, etc.
            'established_company': 80,   # Dedicated company (Vercel, HashiCorp)
            'startup_backed': 60,        # Funded startup
            'community_led': 40,         # Strong community, no corporate backing
            'none': 20                   # Individual maintainers
        }

        base_score = scores.get(backing_type, 40)

        # Adjust for funding
        funding = self.corporate_backing.get('funding_millions', 0)
        if funding >= 100:
            base_score = min(100, base_score + 20)
        elif funding >= 50:
            base_score = min(100, base_score + 10)
        elif funding >= 10:
            base_score = min(100, base_score + 5)

        return base_score

    def _score_maintenance_health(self) -> float:
        """
        Score maintenance activity and responsiveness.

        Returns:
            Maintenance health score (0-100)
        """
        score = 0.0

        # Issue response time (0-30 points)
        avg_response_hours = self.github_data.get('avg_issue_response_hours', 168)  # 7 days default
        if avg_response_hours <= 24:
            score += 30
        elif avg_response_hours <= 48:
            score += 25
        elif avg_response_hours <= 168:  # 1 week
            score += 20
        elif avg_response_hours <= 336:  # 2 weeks
            score += 10
        else:
            score += 5

        # Issue resolution rate (0-30 points)
        resolution_rate = self.github_data.get('issue_resolution_rate', 0.5)
        score += resolution_rate * 30

        # Release frequency (0-20 points)
        releases_per_year = self.github_data.get('releases_per_year', 4)
        if releases_per_year >= 12:
            score += 20
        elif releases_per_year >= 6:
            score += 15
        elif releases_per_year >= 4:
            score += 10
        elif releases_per_year >= 2:
            score += 5
        else:
            score += 0

        # Active maintainers (0-20 points)
        active_maintainers = self.github_data.get('active_maintainers', 1)
        if active_maintainers >= 10:
            score += 20
        elif active_maintainers >= 5:
            score += 15
        elif active_maintainers >= 3:
            score += 10
        elif active_maintainers >= 1:
            score += 5
        else:
            score += 0

        return min(100.0, score)

    def assess_viability(self) -> Dict[str, Any]:
        """
        Assess long-term viability of technology.

        Returns:
            Viability assessment with risk factors
        """
        health = self.calculate_health_score()
        overall_health = health['overall_health']

        # Determine viability level
        if overall_health >= 80:
            viability = "Excellent - Strong long-term viability"
            risk_level = "Low"
        elif overall_health >= 65:
            viability = "Good - Solid viability with minor concerns"
            risk_level = "Low-Medium"
        elif overall_health >= 50:
            viability = "Moderate - Viable but with notable risks"
            risk_level = "Medium"
        elif overall_health >= 35:
            viability = "Concerning - Significant viability risks"
            risk_level = "Medium-High"
        else:
            viability = "Poor - High risk of abandonment"
            risk_level = "High"

        # Identify specific risks
        risks = self._identify_viability_risks(health)

        # Identify strengths
        strengths = self._identify_viability_strengths(health)

        return {
            'overall_viability': viability,
            'risk_level': risk_level,
            'health_score': overall_health,
            'risks': risks,
            'strengths': strengths,
            'recommendation': self._generate_viability_recommendation(overall_health, risks)
        }

    def _identify_viability_risks(self, health: Dict[str, float]) -> List[str]:
        """
        Identify viability risks from health scores.

        Args:
            health: Health score components

        Returns:
            List of identified risks
        """
        risks = []

        if health['maintenance_health'] < 50:
            risks.append("Low maintenance activity - slow issue resolution")

        if health['github_health'] < 50:
            risks.append("Limited GitHub activity - smaller community")

        if health['corporate_backing'] < 40:
            risks.append("Weak corporate backing - sustainability concerns")

        if health['npm_health'] < 50 and self.npm_data:
            risks.append("Low npm adoption - limited ecosystem")

        if health['community_health'] < 50:
            risks.append("Small community - limited resources and support")

        return risks if risks else ["No significant risks identified"]

    def _identify_viability_strengths(self, health: Dict[str, float]) -> List[str]:
        """
        Identify viability strengths from health scores.

        Args:
            health: Health score components

        Returns:
            List of identified strengths
        """
        strengths = []

        if health['maintenance_health'] >= 70:
            strengths.append("Active maintenance with responsive issue resolution")

        if health['github_health'] >= 70:
            strengths.append("Strong GitHub presence with active community")

        if health['corporate_backing'] >= 70:
            strengths.append("Strong corporate backing ensures sustainability")

        if health['npm_health'] >= 70 and self.npm_data:
            strengths.append("High npm adoption with stable releases")

        if health['community_health'] >= 70:
            strengths.append("Large, active community with extensive resources")

        return strengths if strengths else ["Baseline viability maintained"]

    def _generate_viability_recommendation(self, health_score: float, risks: List[str]) -> str:
        """
        Generate viability recommendation.

        Args:
            health_score: Overall health score
            risks: List of identified risks

        Returns:
            Recommendation string
        """
        if health_score >= 80:
            return "Recommended for long-term adoption - strong ecosystem support"
        elif health_score >= 65:
            return "Suitable for adoption - monitor identified risks"
        elif health_score >= 50:
            return "Proceed with caution - have contingency plans"
        else:
            return "Not recommended - consider alternatives with stronger ecosystems"

    def generate_ecosystem_report(self) -> Dict[str, Any]:
        """
        Generate comprehensive ecosystem report.

        Returns:
            Complete ecosystem analysis
        """
        health = self.calculate_health_score()
        viability = self.assess_viability()

        return {
            'technology': self.technology,
            'health_scores': health,
            'viability_assessment': viability,
            'github_metrics': self._format_github_metrics(),
            'npm_metrics': self._format_npm_metrics() if self.npm_data else None,
            'community_metrics': self._format_community_metrics()
        }

    def _format_github_metrics(self) -> Dict[str, Any]:
        """Format GitHub metrics for reporting."""
        return {
            'stars': f"{self.github_data.get('stars', 0):,}",
            'forks': f"{self.github_data.get('forks', 0):,}",
            'contributors': f"{self.github_data.get('contributors', 0):,}",
            'commits_last_month': self.github_data.get('commits_last_month', 0),
            'open_issues': self.github_data.get('open_issues', 0),
            'issue_resolution_rate': f"{self.github_data.get('issue_resolution_rate', 0) * 100:.1f}%"
        }

    def _format_npm_metrics(self) -> Dict[str, Any]:
        """Format npm metrics for reporting."""
        return {
            'weekly_downloads': f"{self.npm_data.get('weekly_downloads', 0):,}",
            'version': self.npm_data.get('version', 'N/A'),
            'dependencies': self.npm_data.get('dependencies_count', 0),
            'days_since_publish': self.npm_data.get('days_since_last_publish', 0)
        }

    def _format_community_metrics(self) -> Dict[str, Any]:
        """Format community metrics for reporting."""
        return {
            'stackoverflow_questions': f"{self.community_data.get('stackoverflow_questions', 0):,}",
            'job_postings': f"{self.community_data.get('job_postings', 0):,}",
            'tutorials': self.community_data.get('tutorials_count', 0),
            'forum_members': f"{self.community_data.get('forum_members', 0):,}"
        }

"""
Input Format Detector.

Automatically detects input format (text, YAML, JSON, URLs) and parses
accordingly for technology stack evaluation requests.
"""

from typing import Dict, Any, Optional, Tuple
import json
import re


class FormatDetector:
    """Detect and parse various input formats for stack evaluation."""

    def __init__(self, input_data: str):
        """
        Initialize format detector with raw input.

        Args:
            input_data: Raw input string from user
        """
        self.raw_input = input_data.strip()
        self.detected_format = None
        self.parsed_data = None

    def detect_format(self) -> str:
        """
        Detect the input format.

        Returns:
            Format type: 'json', 'yaml', 'url', 'text'
        """
        # Try JSON first
        if self._is_json():
            self.detected_format = 'json'
            return 'json'

        # Try YAML
        if self._is_yaml():
            self.detected_format = 'yaml'
            return 'yaml'

        # Check for URLs
        if self._contains_urls():
            self.detected_format = 'url'
            return 'url'

        # Default to conversational text
        self.detected_format = 'text'
        return 'text'

    def _is_json(self) -> bool:
        """Check if input is valid JSON."""
        try:
            json.loads(self.raw_input)
            return True
        except (json.JSONDecodeError, ValueError):
            return False

    def _is_yaml(self) -> bool:
        """
        Check if input looks like YAML.

        Returns:
            True if input appears to be YAML format
        """
        # YAML indicators
        yaml_patterns = [
            r'^\s*[\w\-]+\s*:',  # Key-value pairs
            r'^\s*-\s+',  # List items
            r':\s*$',  # Trailing colons
        ]

        # Must not be JSON
        if self._is_json():
            return False

        # Check for YAML patterns
        lines = self.raw_input.split('\n')
        yaml_line_count = 0

        for line in lines:
            for pattern in yaml_patterns:
                if re.match(pattern, line):
                    yaml_line_count += 1
                    break

        # If >50% of lines match YAML patterns, consider it YAML
        if len(lines) > 0 and yaml_line_count / len(lines) > 0.5:
            return True

        return False

    def _contains_urls(self) -> bool:
        """Check if input contains URLs."""
        url_pattern = r'https?://[^\s]+'
        return bool(re.search(url_pattern, self.raw_input))

    def parse(self) -> Dict[str, Any]:
        """
        Parse input based on detected format.

        Returns:
            Parsed data dictionary
        """
        if self.detected_format is None:
            self.detect_format()

        if self.detected_format == 'json':
            self.parsed_data = self._parse_json()
        elif self.detected_format == 'yaml':
            self.parsed_data = self._parse_yaml()
        elif self.detected_format == 'url':
            self.parsed_data = self._parse_urls()
        else:  # text
            self.parsed_data = self._parse_text()

        return self.parsed_data

    def _parse_json(self) -> Dict[str, Any]:
        """Parse JSON input."""
        try:
            data = json.loads(self.raw_input)
            return self._normalize_structure(data)
        except json.JSONDecodeError:
            return {'error': 'Invalid JSON', 'raw': self.raw_input}

    def _parse_yaml(self) -> Dict[str, Any]:
        """
        Parse YAML-like input (simplified, no external dependencies).

        Returns:
            Parsed dictionary
        """
        result = {}
        current_section = None
        current_list = None

        lines = self.raw_input.split('\n')

        for line in lines:
            stripped = line.strip()
            if not stripped or stripped.startswith('#'):
                continue

            # Key-value pair
            if ':' in stripped:
                key, value = stripped.split(':', 1)
                key = key.strip()
                value = value.strip()

                # Empty value might indicate nested structure
                if not value:
                    current_section = key
                    result[current_section] = {}
                    current_list = None
                else:
                    if current_section:
                        result[current_section][key] = self._parse_value(value)
                    else:
                        result[key] = self._parse_value(value)

            # List item
            elif stripped.startswith('-'):
                item = stripped[1:].strip()
                if current_section:
                    if current_list is None:
                        current_list = []
                        result[current_section] = current_list
                    current_list.append(self._parse_value(item))

        return self._normalize_structure(result)

    def _parse_value(self, value: str) -> Any:
        """
        Parse a value string to appropriate type.

        Args:
            value: Value string

        Returns:
            Parsed value (str, int, float, bool)
        """
        value = value.strip()

        # Boolean
        if value.lower() in ['true', 'yes']:
            return True
        if value.lower() in ['false', 'no']:
            return False

        # Number
        try:
            if '.' in value:
                return float(value)
            else:
                return int(value)
        except ValueError:
            pass

        # String (remove quotes if present)
        if value.startswith('"') and value.endswith('"'):
            return value[1:-1]
        if value.startswith("'") and value.endswith("'"):
            return value[1:-1]

        return value

    def _parse_urls(self) -> Dict[str, Any]:
        """Parse URLs from input."""
        url_pattern = r'https?://[^\s]+'
        urls = re.findall(url_pattern, self.raw_input)

        # Categorize URLs
        github_urls = [u for u in urls if 'github.com' in u]
        npm_urls = [u for u in urls if 'npmjs.com' in u or 'npm.io' in u]
        other_urls = [u for u in urls if u not in github_urls and u not in npm_urls]

        # Also extract any text context
        text_without_urls = re.sub(url_pattern, '', self.raw_input).strip()

        result = {
            'format': 'url',
            'urls': {
                'github': github_urls,
                'npm': npm_urls,
                'other': other_urls
            },
            'context': text_without_urls
        }

        return self._normalize_structure(result)

    def _parse_text(self) -> Dict[str, Any]:
        """Parse conversational text input."""
        text = self.raw_input.lower()

        # Extract technologies being compared
        technologies = self._extract_technologies(text)

        # Extract use case
        use_case = self._extract_use_case(text)

        # Extract priorities
        priorities = self._extract_priorities(text)

        # Detect analysis type
        analysis_type = self._detect_analysis_type(text)

        result = {
            'format': 'text',
            'technologies': technologies,
            'use_case': use_case,
            'priorities': priorities,
            'analysis_type': analysis_type,
            'raw_text': self.raw_input
        }

        return self._normalize_structure(result)

    def _extract_technologies(self, text: str) -> list:
        """
        Extract technology names from text.

        Args:
            text: Lowercase text

        Returns:
            List of identified technologies
        """
        # Common technologies pattern
        tech_keywords = [
            'react', 'vue', 'angular', 'svelte', 'next.js', 'nuxt.js',
            'node.js', 'python', 'java', 'go', 'rust', 'ruby',
            'postgresql', 'postgres', 'mysql', 'mongodb', 'redis',
            'aws', 'azure', 'gcp', 'google cloud',
            'docker', 'kubernetes', 'k8s',
            'express', 'fastapi', 'django', 'flask', 'spring boot'
        ]

        found = []
        for tech in tech_keywords:
            if tech in text:
                # Normalize names
                normalized = {
                    'postgres': 'PostgreSQL',
                    'next.js': 'Next.js',
                    'nuxt.js': 'Nuxt.js',
                    'node.js': 'Node.js',
                    'k8s': 'Kubernetes',
                    'gcp': 'Google Cloud Platform'
                }.get(tech, tech.title())

                if normalized not in found:
                    found.append(normalized)

        return found if found else ['Unknown']

    def _extract_use_case(self, text: str) -> str:
        """
        Extract use case description from text.

        Args:
            text: Lowercase text

        Returns:
            Use case description
        """
        use_case_keywords = {
            'real-time': 'Real-time application',
            'collaboration': 'Collaboration platform',
            'saas': 'SaaS application',
            'dashboard': 'Dashboard application',
            'api': 'API-heavy application',
            'data-intensive': 'Data-intensive application',
            'e-commerce': 'E-commerce platform',
            'enterprise': 'Enterprise application'
        }

        for keyword, description in use_case_keywords.items():
            if keyword in text:
                return description

        return 'General purpose application'

    def _extract_priorities(self, text: str) -> list:
        """
        Extract priority criteria from text.

        Args:
            text: Lowercase text

        Returns:
            List of priorities
        """
        priority_keywords = {
            'performance': 'Performance',
            'scalability': 'Scalability',
            'developer experience': 'Developer experience',
            'ecosystem': 'Ecosystem',
            'learning curve': 'Learning curve',
            'cost': 'Cost',
            'security': 'Security',
            'compliance': 'Compliance'
        }

        priorities = []
        for keyword, priority in priority_keywords.items():
            if keyword in text:
                priorities.append(priority)

        return priorities if priorities else ['Developer experience', 'Performance']

    def _detect_analysis_type(self, text: str) -> str:
        """
        Detect type of analysis requested.

        Args:
            text: Lowercase text

        Returns:
            Analysis type
        """
        type_keywords = {
            'migration': 'migration_analysis',
            'migrate': 'migration_analysis',
            'tco': 'tco_analysis',
            'total cost': 'tco_analysis',
            'security': 'security_analysis',
            'compliance': 'security_analysis',
            'compare': 'comparison',
            'vs': 'comparison',
            'evaluate': 'evaluation'
        }

        for keyword, analysis_type in type_keywords.items():
            if keyword in text:
                return analysis_type

        return 'comparison'  # Default

    def _normalize_structure(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """
        Normalize parsed data to standard structure.

        Args:
            data: Parsed data dictionary

        Returns:
            Normalized data structure
        """
        # Ensure standard keys exist
        standard_keys = [
            'technologies',
            'use_case',
            'priorities',
            'analysis_type',
            'format'
        ]

        normalized = data.copy()

        for key in standard_keys:
            if key not in normalized:
                # Set defaults
                defaults = {
                    'technologies': [],
                    'use_case': 'general',
                    'priorities': [],
                    'analysis_type': 'comparison',
                    'format': self.detected_format or 'unknown'
                }
                normalized[key] = defaults.get(key)

        return normalized

    def get_format_info(self) -> Dict[str, Any]:
        """
        Get information about detected format.

        Returns:
            Format detection metadata
        """
        return {
            'detected_format': self.detected_format,
            'input_length': len(self.raw_input),
            'line_count': len(self.raw_input.split('\n')),
            'parsing_successful': self.parsed_data is not None
        }

"""
Migration Path Analyzer.

Analyzes migration complexity, risks, timelines, and strategies for moving
from legacy technology stacks to modern alternatives.
"""

from typing import Dict, List, Any, Optional, Tuple


class MigrationAnalyzer:
    """Analyze migration paths and complexity for technology stack changes."""

    # Migration complexity factors
    COMPLEXITY_FACTORS = [
        'code_volume',
        'architecture_changes',
        'data_migration',
        'api_compatibility',
        'dependency_changes',
        'testing_requirements'
    ]

    def __init__(self, migration_data: Dict[str, Any]):
        """
        Initialize migration analyzer with migration parameters.

        Args:
            migration_data: Dictionary containing source/target technologies and constraints
        """
        self.source_tech = migration_data.get('source_technology', 'Unknown')
        self.target_tech = migration_data.get('target_technology', 'Unknown')
        self.codebase_stats = migration_data.get('codebase_stats', {})
        self.constraints = migration_data.get('constraints', {})
        self.team_info = migration_data.get('team', {})

    def calculate_complexity_score(self) -> Dict[str, Any]:
        """
        Calculate overall migration complexity (1-10 scale).

        Returns:
            Dictionary with complexity scores by factor
        """
        scores = {
            'code_volume': self._score_code_volume(),
            'architecture_changes': self._score_architecture_changes(),
            'data_migration': self._score_data_migration(),
            'api_compatibility': self._score_api_compatibility(),
            'dependency_changes': self._score_dependency_changes(),
            'testing_requirements': self._score_testing_requirements()
        }

        # Calculate weighted average
        weights = {
            'code_volume': 0.20,
            'architecture_changes': 0.25,
            'data_migration': 0.20,
            'api_compatibility': 0.15,
            'dependency_changes': 0.10,
            'testing_requirements': 0.10
        }

        overall = sum(scores[k] * weights[k] for k in scores.keys())
        scores['overall_complexity'] = overall

        return scores

    def _score_code_volume(self) -> float:
        """
        Score complexity based on codebase size.

        Returns:
            Code volume complexity score (1-10)
        """
        lines_of_code = self.codebase_stats.get('lines_of_code', 10000)
        num_files = self.codebase_stats.get('num_files', 100)
        num_components = self.codebase_stats.get('num_components', 50)

        # Score based on lines of code (primary factor)
        if lines_of_code < 5000:
            base_score = 2
        elif lines_of_code < 20000:
            base_score = 4
        elif lines_of_code < 50000:
            base_score = 6
        elif lines_of_code < 100000:
            base_score = 8
        else:
            base_score = 10

        # Adjust for component count
        if num_components > 200:
            base_score = min(10, base_score + 1)
        elif num_components > 500:
            base_score = min(10, base_score + 2)

        return float(base_score)

    def _score_architecture_changes(self) -> float:
        """
        Score complexity based on architectural changes.

        Returns:
            Architecture complexity score (1-10)
        """
        arch_change_level = self.codebase_stats.get('architecture_change_level', 'moderate')

        scores = {
            'minimal': 2,      # Same patterns, just different framework
            'moderate': 5,     # Some pattern changes, similar concepts
            'significant': 7,  # Different patterns, major refactoring
            'complete': 10     # Complete rewrite, different paradigm
        }

        return float(scores.get(arch_change_level, 5))

    def _score_data_migration(self) -> float:
        """
        Score complexity based on data migration requirements.

        Returns:
            Data migration complexity score (1-10)
        """
        has_database = self.codebase_stats.get('has_database', True)
        if not has_database:
            return 1.0

        database_size_gb = self.codebase_stats.get('database_size_gb', 10)
        schema_changes = self.codebase_stats.get('schema_changes_required', 'minimal')
        data_transformation = self.codebase_stats.get('data_transformation_required', False)

        # Base score from database size
        if database_size_gb < 1:
            score = 2
        elif database_size_gb < 10:
            score = 3
        elif database_size_gb < 100:
            score = 5
        elif database_size_gb < 1000:
            score = 7
        else:
            score = 9

        # Adjust for schema changes
        schema_adjustments = {
            'none': 0,
            'minimal': 1,
            'moderate': 2,
            'significant': 3
        }
        score += schema_adjustments.get(schema_changes, 1)

        # Adjust for data transformation
        if data_transformation:
            score += 2

        return min(10.0, float(score))

    def _score_api_compatibility(self) -> float:
        """
        Score complexity based on API compatibility.

        Returns:
            API compatibility complexity score (1-10)
        """
        breaking_api_changes = self.codebase_stats.get('breaking_api_changes', 'some')

        scores = {
            'none': 1,         # Fully compatible
            'minimal': 3,      # Few breaking changes
            'some': 5,         # Moderate breaking changes
            'many': 7,         # Significant breaking changes
            'complete': 10     # Complete API rewrite
        }

        return float(scores.get(breaking_api_changes, 5))

    def _score_dependency_changes(self) -> float:
        """
        Score complexity based on dependency changes.

        Returns:
            Dependency complexity score (1-10)
        """
        num_dependencies = self.codebase_stats.get('num_dependencies', 20)
        dependencies_to_replace = self.codebase_stats.get('dependencies_to_replace', 5)

        # Score based on replacement percentage
        if num_dependencies == 0:
            return 1.0

        replacement_pct = (dependencies_to_replace / num_dependencies) * 100

        if replacement_pct < 10:
            return 2.0
        elif replacement_pct < 25:
            return 4.0
        elif replacement_pct < 50:
            return 6.0
        elif replacement_pct < 75:
            return 8.0
        else:
            return 10.0

    def _score_testing_requirements(self) -> float:
        """
        Score complexity based on testing requirements.

        Returns:
            Testing complexity score (1-10)
        """
        test_coverage = self.codebase_stats.get('current_test_coverage', 0.5)  # 0-1 scale
        num_tests = self.codebase_stats.get('num_tests', 100)

        # If good test coverage, easier migration (can verify)
        if test_coverage >= 0.8:
            base_score = 3
        elif test_coverage >= 0.6:
            base_score = 5
        elif test_coverage >= 0.4:
            base_score = 7
        else:
            base_score = 9  # Poor coverage = hard to verify migration

        # Large test suites need updates
        if num_tests > 500:
            base_score = min(10, base_score + 1)

        return float(base_score)

    def estimate_effort(self) -> Dict[str, Any]:
        """
        Estimate migration effort in person-hours and timeline.

        Returns:
            Dictionary with effort estimates
        """
        complexity = self.calculate_complexity_score()
        overall_complexity = complexity['overall_complexity']

        # Base hours estimation
        lines_of_code = self.codebase_stats.get('lines_of_code', 10000)
        base_hours = lines_of_code / 50  # 50 lines per hour baseline

        # Complexity multiplier
        complexity_multiplier = 1 + (overall_complexity / 10)
        estimated_hours = base_hours * complexity_multiplier

        # Break down by phase
        phases = self._calculate_phase_breakdown(estimated_hours)

        # Calculate timeline
        team_size = self.team_info.get('team_size', 3)
        hours_per_week_per_dev = self.team_info.get('hours_per_week', 30)  # Account for other work

        total_dev_weeks = estimated_hours / (team_size * hours_per_week_per_dev)
        total_calendar_weeks = total_dev_weeks * 1.2  # Buffer for blockers

        return {
            'total_hours': estimated_hours,
            'total_person_months': estimated_hours / 160,  # 160 hours per person-month
            'phases': phases,
            'estimated_timeline': {
                'dev_weeks': total_dev_weeks,
                'calendar_weeks': total_calendar_weeks,
                'calendar_months': total_calendar_weeks / 4.33
            },
            'team_assumptions': {
                'team_size': team_size,
                'hours_per_week_per_dev': hours_per_week_per_dev
            }
        }

    def _calculate_phase_breakdown(self, total_hours: float) -> Dict[str, Dict[str, float]]:
        """
        Calculate effort breakdown by migration phase.

        Args:
            total_hours: Total estimated hours

        Returns:
            Hours breakdown by phase
        """
        # Standard phase percentages
        phase_percentages = {
            'planning_and_prototyping': 0.15,
            'core_migration': 0.45,
            'testing_and_validation': 0.25,
            'deployment_and_monitoring': 0.10,
            'buffer_and_contingency': 0.05
        }

        phases = {}
        for phase, percentage in phase_percentages.items():
            hours = total_hours * percentage
            phases[phase] = {
                'hours': hours,
                'person_weeks': hours / 40,
                'percentage': f"{percentage * 100:.0f}%"
            }

        return phases

    def assess_risks(self) -> Dict[str, List[Dict[str, str]]]:
        """
        Identify and assess migration risks.

        Returns:
            Categorized risks with mitigation strategies
        """
        complexity = self.calculate_complexity_score()

        risks = {
            'technical_risks': self._identify_technical_risks(complexity),
            'business_risks': self._identify_business_risks(),
            'team_risks': self._identify_team_risks()
        }

        return risks

    def _identify_technical_risks(self, complexity: Dict[str, float]) -> List[Dict[str, str]]:
        """
        Identify technical risks.

        Args:
            complexity: Complexity scores

        Returns:
            List of technical risks with mitigations
        """
        risks = []

        # API compatibility risks
        if complexity['api_compatibility'] >= 7:
            risks.append({
                'risk': 'Breaking API changes may cause integration failures',
                'severity': 'High',
                'mitigation': 'Create compatibility layer; implement feature flags for gradual rollout'
            })

        # Data migration risks
        if complexity['data_migration'] >= 7:
            risks.append({
                'risk': 'Data migration could cause data loss or corruption',
                'severity': 'Critical',
                'mitigation': 'Implement robust backup strategy; run parallel systems during migration; extensive validation'
            })

        # Architecture risks
        if complexity['architecture_changes'] >= 8:
            risks.append({
                'risk': 'Major architectural changes increase risk of performance regression',
                'severity': 'High',
                'mitigation': 'Extensive performance testing; staged rollout; monitoring and alerting'
            })

        # Testing risks
        if complexity['testing_requirements'] >= 7:
            risks.append({
                'risk': 'Inadequate test coverage may miss critical bugs',
                'severity': 'Medium',
                'mitigation': 'Improve test coverage before migration; automated regression testing; user acceptance testing'
            })

        if not risks:
            risks.append({
                'risk': 'Standard technical risks (bugs, edge cases)',
                'severity': 'Low',
                'mitigation': 'Standard QA processes and staged rollout'
            })

        return risks

    def _identify_business_risks(self) -> List[Dict[str, str]]:
        """
        Identify business risks.

        Returns:
            List of business risks with mitigations
        """
        risks = []

        # Downtime risk
        downtime_tolerance = self.constraints.get('downtime_tolerance', 'low')
        if downtime_tolerance == 'none':
            risks.append({
                'risk': 'Zero-downtime migration increases complexity and risk',
                'severity': 'High',
                'mitigation': 'Blue-green deployment; feature flags; gradual traffic migration'
            })

        # Feature parity risk
        risks.append({
            'risk': 'New implementation may lack feature parity',
            'severity': 'Medium',
            'mitigation': 'Comprehensive feature audit; prioritized feature list; clear communication'
        })

        # Timeline risk
        risks.append({
            'risk': 'Migration may take longer than estimated',
            'severity': 'Medium',
            'mitigation': 'Build in 20% buffer; regular progress reviews; scope management'
        })

        return risks

    def _identify_team_risks(self) -> List[Dict[str, str]]:
        """
        Identify team-related risks.

        Returns:
            List of team risks with mitigations
        """
        risks = []

        # Learning curve
        team_experience = self.team_info.get('target_tech_experience', 'low')
        if team_experience in ['low', 'none']:
            risks.append({
                'risk': 'Team lacks experience with target technology',
                'severity': 'High',
                'mitigation': 'Training program; hire experienced developers; external consulting'
            })

        # Team size
        team_size = self.team_info.get('team_size', 3)
        if team_size < 3:
            risks.append({
                'risk': 'Small team size may extend timeline',
                'severity': 'Medium',
                'mitigation': 'Consider augmenting team; reduce scope; extend timeline'
            })

        # Knowledge retention
        risks.append({
            'risk': 'Loss of institutional knowledge during migration',
            'severity': 'Medium',
            'mitigation': 'Comprehensive documentation; knowledge sharing sessions; pair programming'
        })

        return risks

    def generate_migration_plan(self) -> Dict[str, Any]:
        """
        Generate comprehensive migration plan.

        Returns:
            Complete migration plan with timeline and recommendations
        """
        complexity = self.calculate_complexity_score()
        effort = self.estimate_effort()
        risks = self.assess_risks()

        # Generate phased approach
        approach = self._recommend_migration_approach(complexity['overall_complexity'])

        # Generate recommendation
        recommendation = self._generate_migration_recommendation(complexity, effort, risks)

        return {
            'source_technology': self.source_tech,
            'target_technology': self.target_tech,
            'complexity_analysis': complexity,
            'effort_estimation': effort,
            'risk_assessment': risks,
            'recommended_approach': approach,
            'overall_recommendation': recommendation,
            'success_criteria': self._define_success_criteria()
        }

    def _recommend_migration_approach(self, complexity_score: float) -> Dict[str, Any]:
        """
        Recommend migration approach based on complexity.

        Args:
            complexity_score: Overall complexity score

        Returns:
            Recommended approach details
        """
        if complexity_score <= 3:
            approach = 'direct_migration'
            description = 'Direct migration - low complexity allows straightforward migration'
            timeline_multiplier = 1.0
        elif complexity_score <= 6:
            approach = 'phased_migration'
            description = 'Phased migration - migrate components incrementally to manage risk'
            timeline_multiplier = 1.3
        else:
            approach = 'strangler_pattern'
            description = 'Strangler pattern - gradually replace old system while running in parallel'
            timeline_multiplier = 1.5

        return {
            'approach': approach,
            'description': description,
            'timeline_multiplier': timeline_multiplier,
            'phases': self._generate_approach_phases(approach)
        }

    def _generate_approach_phases(self, approach: str) -> List[str]:
        """
        Generate phase descriptions for migration approach.

        Args:
            approach: Migration approach type

        Returns:
            List of phase descriptions
        """
        phases = {
            'direct_migration': [
                'Phase 1: Set up target environment and migrate configuration',
                'Phase 2: Migrate codebase and dependencies',
                'Phase 3: Migrate data with validation',
                'Phase 4: Comprehensive testing',
                'Phase 5: Cutover and monitoring'
            ],
            'phased_migration': [
                'Phase 1: Identify and prioritize components for migration',
                'Phase 2: Migrate non-critical components first',
                'Phase 3: Migrate core components with parallel running',
                'Phase 4: Migrate critical components with rollback plan',
                'Phase 5: Decommission old system'
            ],
            'strangler_pattern': [
                'Phase 1: Set up routing layer between old and new systems',
                'Phase 2: Implement new features in target technology only',
                'Phase 3: Gradually migrate existing features (lowest risk first)',
                'Phase 4: Migrate high-risk components last with extensive testing',
                'Phase 5: Complete migration and remove routing layer'
            ]
        }

        return phases.get(approach, phases['phased_migration'])

    def _generate_migration_recommendation(
        self,
        complexity: Dict[str, float],
        effort: Dict[str, Any],
        risks: Dict[str, List[Dict[str, str]]]
    ) -> str:
        """
        Generate overall migration recommendation.

        Args:
            complexity: Complexity analysis
            effort: Effort estimation
            risks: Risk assessment

        Returns:
            Recommendation string
        """
        overall_complexity = complexity['overall_complexity']
        timeline_months = effort['estimated_timeline']['calendar_months']

        # Count high/critical severity risks
        high_risk_count = sum(
            1 for risk_list in risks.values()
            for risk in risk_list
            if risk['severity'] in ['High', 'Critical']
        )

        if overall_complexity <= 4 and high_risk_count <= 2:
            return f"Recommended - Low complexity migration achievable in {timeline_months:.1f} months with manageable risks"
        elif overall_complexity <= 7 and high_risk_count <= 4:
            return f"Proceed with caution - Moderate complexity migration requiring {timeline_months:.1f} months and careful risk management"
        else:
            return f"High risk - Complex migration requiring {timeline_months:.1f} months. Consider: incremental approach, additional resources, or alternative solutions"

    def _define_success_criteria(self) -> List[str]:
        """
        Define success criteria for migration.

        Returns:
            List of success criteria
        """
        return [
            'Feature parity with current system',
            'Performance equal or better than current system',
            'Zero data loss or corruption',
            'All tests passing (unit, integration, E2E)',
            'Successful production deployment with <1% error rate',
            'Team trained and comfortable with new technology',
            'Documentation complete and up-to-date'
        ]