"""
Competitor analysis for investor relations.
Uses free HuggingFace models with rule-based fallback.
"""
import re
from transformers import pipeline

_analyzer = None


def get_analyzer(model_name="google/flan-t5-base"):
    """Load text2text generation pipeline with fallback."""
    global _analyzer
    if _analyzer is None:
        try:
            _analyzer = pipeline(
                "text2text-generation",
                model=model_name,
                device=-1  # CPU only for free deployment
            )
        except Exception:
            _analyzer = None
    return _analyzer


def extract_competitor_info(competitors_data):
    """Parse competitor data into structured format."""
    lines = [l.strip() for l in competitors_data.split('\n') if l.strip()]
    
    competitors = []
    for line in lines:
        # Try to extract competitor name and key facts
        if ':' in line:
            parts = line.split(':', 1)
            name = parts[0].strip()
            details = parts[1].strip()
            competitors.append({'name': name, 'details': details})
        else:
            competitors.append({'name': f"Competitor {len(competitors)+1}", 'details': line})
    
    return competitors


def rule_based_analysis(company_name, competitors_data, market_context):
    """Fallback: Structure competitor analysis using rules."""
    competitors = extract_competitor_info(competitors_data)
    
    analysis_parts = [f"## Competitive Landscape Analysis for {company_name}\n"]
    
    # Market overview
    analysis_parts.append("### Market Context\n")
    analysis_parts.append(f"{market_context}\n")
    
    # Competitor breakdown
    analysis_parts.append("\n### Competitive Position\n")
    
    for comp in competitors:
        analysis_parts.append(f"\n**{comp['name']}**")
        analysis_parts.append(f"- {comp['details']}")
        
        # Identify strengths/threats
        details_lower = comp['details'].lower()
        
        if any(word in details_lower for word in ['launch', 'new', 'expand', 'grow', 'acqui']):
            analysis_parts.append(f"- *Threat Level*: Active expansion and innovation")
        
        if any(word in details_lower for word in ['revenue', 'billion', 'million', '$']):
            # Try to extract revenue
            import re
            revenue_match = re.search(r'\$?(\d+(?:\.\d+)?)\s*([BM])', comp['details'], re.I)
            if revenue_match:
                val = revenue_match.group(1)
                unit = revenue_match.group(2).upper()
                analysis_parts.append(f"- *Scale*: ${val}{unit} revenue")
    
    # Strategic implications
    analysis_parts.append("\n### Strategic Implications for " + company_name + "\n")
    
    if 'ai' in competitors_data.lower() or 'ml' in competitors_data.lower():
        analysis_parts.append("- **Technology Focus**: Multiple competitors investing in AI/ML capabilities - maintain competitive technology roadmap")
    
    if 'expansion' in competitors_data.lower() or 'market' in competitors_data.lower():
        analysis_parts.append("- **Market Expansion**: Competitive pressure in geographic/market segment expansion")
    
    if 'acqui' in competitors_data.lower():
        analysis_parts.append("- **M&A Activity**: Active acquisition landscape - identify strategic targets")
    
    if 'pricing' in competitors_data.lower() or 'price' in competitors_data.lower():
        analysis_parts.append("- **Pricing Pressure**: Monitor competitive pricing dynamics and value proposition")
    
    # Recommendations
    analysis_parts.append("\n### Recommendations\n")
    analysis_parts.append(f"- Maintain differentiation through unique value propositions")
    analysis_parts.append(f"- Monitor competitor product launches and market positioning")
    analysis_parts.append(f"- Leverage strengths in areas where competitors show weakness")
    analysis_parts.append(f"- Consider strategic partnerships or acquisitions to strengthen market position")
    
    return "\n".join(analysis_parts)


def analyze_competitors(company_name, competitors_data, market_context, model_name="google/flan-t5-base"):
    """
    Analyze competitive landscape for investor communications.
    
    Args:
        company_name: Name of the company
        competitors_data: Text containing competitor information
        market_context: Industry trends and market conditions
        model_name: HuggingFace model to use
    
    Returns:
        Formatted competitive analysis report
    """
    analyzer = get_analyzer(model_name)
    
    if analyzer is None:
        # Use rule-based fallback
        return rule_based_analysis(company_name, competitors_data, market_context)
    
    # Use AI model
    prompt = f"""Analyze the competitive landscape for {company_name}.

Market Context:
{market_context}

Competitor Information:
{competitors_data[:1500]}

Provide a competitive analysis with:
1. Market positioning overview
2. Key competitor strengths and threats
3. Strategic implications for {company_name}
4. Recommendations for maintaining competitive advantage

Analysis:"""
    
    try:
        result = analyzer(
            prompt,
            max_length=512,
            min_length=150,
            do_sample=False,
            temperature=0.7
        )
        analysis = result[0]['generated_text']
        
        # Format the output
        formatted = f"""## Competitive Landscape Analysis for {company_name}

### Market Context
{market_context}

### Competitive Analysis
{analysis}

### Competitor Overview
{competitors_data}

---
*Note: This analysis should be supplemented with detailed market research and verified competitive intelligence.*
"""
        return formatted
    
    except Exception as e:
        # Fallback to rule-based on any error
        return rule_based_analysis(company_name, competitors_data, market_context)