GameFi Token Analysis with Ollama: Play-to-Earn Economics and Sustainability

# Verify Ollama installation
ollama --version

# Pull the recommended model for financial analysis
ollama pull llama2:13b

# Create project directory
mkdir gamefi-analysis
cd gamefi-analysis

# Initialize Python environment
python -m venv gamefi-env
source gamefi-env/bin/activate  # On Windows: gamefi-env\Scripts\activate

# Install required packages
pip install requests pandas matplotlib seaborn ollama-python

# config.py - Configuration for data sources
import os

# API Configuration
COINGECKO_API_KEY = os.getenv('COINGECKO_API_KEY')
DEXTOOLS_API_KEY = os.getenv('DEXTOOLS_API_KEY')
DEFILLAMA_API_URL = "https://api.llama.fi"

# Ollama Configuration
OLLAMA_HOST = "http://localhost:11434"
OLLAMA_MODEL = "llama2:13b"

# Analysis Parameters
ANALYSIS_TIMEFRAME = 30  # Days
MIN_DAILY_VOLUME = 10000  # USD
MIN_MARKET_CAP = 1000000  # USD

# data_collector.py - GameFi token data collection
import requests
import pandas as pd
from datetime import datetime, timedelta
import time

class GameFiDataCollector:
    def __init__(self, config):
        self.config = config
        self.session = requests.Session()
        
    def fetch_token_metrics(self, token_address, days=30):
        """
        Fetch comprehensive token metrics for GameFi analysis
        Returns: Dictionary with price, volume, and supply data
        """
        # Price and volume data from CoinGecko
        price_data = self._get_price_history(token_address, days)
        
        # On-chain metrics from blockchain
        supply_data = self._get_supply_metrics(token_address)
        
        # Gaming-specific metrics
        gaming_metrics = self._get_gaming_metrics(token_address)
        
        return {
            'price_history': price_data,
            'supply_metrics': supply_data,
            'gaming_metrics': gaming_metrics,
            'collected_at': datetime.now()
        }
    
    def _get_price_history(self, token_address, days):
        """Fetch historical price and volume data"""
        url = f"https://api.coingecko.com/api/v3/coins/{token_address}/market_chart"
        params = {
            'vs_currency': 'usd',
            'days': days,
            'interval': 'daily'
        }
        
        response = self.session.get(url, params=params)
        if response.status_code == 200:
            data = response.json()
            
            # Convert to pandas DataFrame for easier analysis
            df = pd.DataFrame({
                'timestamp': [pd.to_datetime(item[0], unit='ms') for item in data['prices']],
                'price': [item[1] for item in data['prices']],
                'volume': [item[1] for item in data['total_volumes']]
            })
            
            return df
        
        return None
    
    def _get_supply_metrics(self, token_address):
        """Fetch token supply and distribution metrics"""
        # This would connect to blockchain APIs or smart contract calls
        # For demonstration, we'll use mock data structure
        return {
            'total_supply': 1000000000,
            'circulating_supply': 350000000,
            'burned_tokens': 50000000,
            'staked_tokens': 200000000,
            'treasury_balance': 400000000,
            'daily_emissions': 1000000
        }
    
    def _get_gaming_metrics(self, token_address):
        """Fetch gaming-specific metrics"""
        # This would integrate with gaming platform APIs
        return {
            'daily_active_users': 15000,
            'monthly_active_users': 75000,
            'average_session_time': 45,  # minutes
            'tokens_earned_per_hour': 50,
            'new_user_acquisition': 500,  # daily
            'user_retention_7d': 0.35,
            'user_retention_30d': 0.15
        }

# Usage example
collector = GameFiDataCollector(config)
token_data = collector.fetch_token_metrics('axie-infinity')

# token_analyzer.py - AI-powered GameFi token analysis
import ollama
import json
from typing import Dict, List

class GameFiTokenAnalyzer:
    def __init__(self, ollama_host, model_name):
        self.client = ollama.Client(host=ollama_host)
        self.model = model_name
        
    def analyze_token_sustainability(self, token_data: Dict) -> Dict:
        """
        Analyze GameFi token sustainability using Ollama AI
        Returns: Comprehensive sustainability assessment
        """
        
        # Prepare data for AI analysis
        analysis_prompt = self._create_analysis_prompt(token_data)
        
        # Get AI analysis
        response = self.client.chat(
            model=self.model,
            messages=[{
                'role': 'user',
                'content': analysis_prompt
            }]
        )
        
        # Parse and structure the response
        analysis_result = self._parse_ai_response(response['message']['content'])
        
        # Add quantitative scoring
        analysis_result['sustainability_score'] = self._calculate_sustainability_score(token_data)
        analysis_result['risk_factors'] = self._identify_risk_factors(token_data)
        
        return analysis_result
    
    def _create_analysis_prompt(self, token_data: Dict) -> str:
        """Create detailed prompt for AI analysis"""
        
        price_data = token_data['price_history']
        supply_data = token_data['supply_metrics']
        gaming_data = token_data['gaming_metrics']
        
        prompt = f"""
        Analyze this GameFi token's economic sustainability:

        PRICE METRICS:
        - Current price: ${price_data['price'].iloc[-1]:.4f}
        - 30-day change: {((price_data['price'].iloc[-1] / price_data['price'].iloc[0]) - 1) * 100:.2f}%
        - Average daily volume: ${price_data['volume'].mean():,.2f}
        - Price volatility: {price_data['price'].std():.4f}

        SUPPLY METRICS:
        - Total supply: {supply_data['total_supply']:,}
        - Circulating supply: {supply_data['circulating_supply']:,}
        - Daily emissions: {supply_data['daily_emissions']:,}
        - Staked tokens: {supply_data['staked_tokens']:,}
        - Treasury balance: {supply_data['treasury_balance']:,}

        GAMING METRICS:
        - Daily active users: {gaming_data['daily_active_users']:,}
        - Monthly active users: {gaming_data['monthly_active_users']:,}
        - 7-day retention: {gaming_data['user_retention_7d']*100:.1f}%
        - 30-day retention: {gaming_data['user_retention_30d']*100:.1f}%
        - Tokens earned per hour: {gaming_data['tokens_earned_per_hour']}

        Provide analysis covering:
        1. Economic sustainability outlook (1-5 score)
        2. Key strengths and weaknesses
        3. Inflationary/deflationary balance
        4. Player retention impact on token demand
        5. Treasury runway assessment
        6. Recommended monitoring metrics
        7. Risk mitigation suggestions

        Format response as structured analysis with clear sections.
        """
        
        return prompt
    
    def _parse_ai_response(self, response_text: str) -> Dict:
        """Parse AI response into structured data"""
        
        # This is a simplified parser - in production, you'd want more robust parsing
        sections = response_text.split('\n\n')
        
        parsed_response = {
            'overall_assessment': '',
            'sustainability_outlook': '',
            'key_strengths': [],
            'key_weaknesses': [],
            'recommendations': [],
            'raw_analysis': response_text
        }
        
        # Extract structured information from AI response
        for section in sections:
            if 'sustainability' in section.lower():
                parsed_response['sustainability_outlook'] = section
            elif 'strength' in section.lower():
                parsed_response['key_strengths'] = self._extract_bullet_points(section)
            elif 'weakness' in section.lower() or 'risk' in section.lower():
                parsed_response['key_weaknesses'] = self._extract_bullet_points(section)
            elif 'recommend' in section.lower():
                parsed_response['recommendations'] = self._extract_bullet_points(section)
        
        return parsed_response
    
    def _extract_bullet_points(self, text: str) -> List[str]:
        """Extract bullet points from text"""
        lines = text.split('\n')
        bullet_points = []
        
        for line in lines:
            line = line.strip()
            if line.startswith(('-', '•', '*', '1.', '2.', '3.', '4.', '5.')):
                bullet_points.append(line[2:].strip())
        
        return bullet_points
    
    def _calculate_sustainability_score(self, token_data: Dict) -> float:
        """Calculate quantitative sustainability score (0-100)"""
        
        supply_data = token_data['supply_metrics']
        gaming_data = token_data['gaming_metrics']
        price_data = token_data['price_history']
        
        # Supply health score (0-25)
        supply_ratio = supply_data['circulating_supply'] / supply_data['total_supply']
        supply_score = min(25, (1 - supply_ratio) * 50)
        
        # User engagement score (0-25)
        retention_score = (gaming_data['user_retention_7d'] + gaming_data['user_retention_30d']) * 50
        
        # Treasury sustainability score (0-25)
        daily_cost = supply_data['daily_emissions'] * price_data['price'].iloc[-1]
        treasury_value = supply_data['treasury_balance'] * price_data['price'].iloc[-1]
        runway_days = treasury_value / daily_cost if daily_cost > 0 else 365
        treasury_score = min(25, (runway_days / 365) * 25)
        
        # Price stability score (0-25)
        volatility = price_data['price'].std() / price_data['price'].mean()
        stability_score = max(0, 25 - (volatility * 100))
        
        total_score = supply_score + retention_score + treasury_score + stability_score
        
        return min(100, max(0, total_score))
    
    def _identify_risk_factors(self, token_data: Dict) -> List[Dict]:
        """Identify specific risk factors with severity ratings"""
        
        risks = []
        supply_data = token_data['supply_metrics']
        gaming_data = token_data['gaming_metrics']
        
        # High inflation risk
        inflation_rate = (supply_data['daily_emissions'] * 365) / supply_data['circulating_supply']
        if inflation_rate > 0.5:  # 50% annual inflation
            risks.append({
                'factor': 'High Token Inflation',
                'severity': 'High',
                'description': f'Annual inflation rate of {inflation_rate*100:.1f}% may devalue tokens'
            })
        
        # Low user retention risk
        if gaming_data['user_retention_30d'] < 0.2:  # Less than 20% retention
            risks.append({
                'factor': 'Poor User Retention',
                'severity': 'Medium',
                'description': f'30-day retention of {gaming_data["user_retention_30d"]*100:.1f}% indicates engagement issues'
            })
        
        # Treasury depletion risk
        daily_cost = supply_data['daily_emissions'] * token_data['price_history']['price'].iloc[-1]
        treasury_value = supply_data['treasury_balance'] * token_data['price_history']['price'].iloc[-1]
        runway_days = treasury_value / daily_cost if daily_cost > 0 else 365
        
        if runway_days < 180:  # Less than 6 months runway
            risks.append({
                'factor': 'Treasury Depletion',
                'severity': 'Critical',
                'description': f'Treasury runway of {runway_days:.0f} days requires immediate attention'
            })
        
        return risks

# Usage example
analyzer = GameFiTokenAnalyzer(OLLAMA_HOST, OLLAMA_MODEL)
analysis_result = analyzer.analyze_token_sustainability(token_data)

# player_economics.py - Play-to-earn economics modeling
import numpy as np
import matplotlib.pyplot as plt
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class PlayerProfile:
    skill_level: float  # 0.0 to 1.0
    time_investment: float  # hours per day
    risk_tolerance: float  # 0.0 to 1.0
    retention_probability: float  # 0.0 to 1.0

class PlayToEarnSimulator:
    def __init__(self, token_price: float, base_earning_rate: float):
        self.token_price = token_price
        self.base_earning_rate = base_earning_rate  # tokens per hour
        self.player_profiles = []
        
    def add_player_cohort(self, profile: PlayerProfile, count: int):
        """Add a cohort of players with similar characteristics"""
        for _ in range(count):
            # Add some variance to the profile
            varied_profile = PlayerProfile(
                skill_level=max(0, min(1, profile.skill_level + np.random.normal(0, 0.1))),
                time_investment=max(0.5, profile.time_investment + np.random.normal(0, 0.5)),
                risk_tolerance=max(0, min(1, profile.risk_tolerance + np.random.normal(0, 0.1))),
                retention_probability=max(0, min(1, profile.retention_probability + np.random.normal(0, 0.05)))
            )
            self.player_profiles.append(varied_profile)
    
    def simulate_earnings_distribution(self, days: int = 30) -> Dict:
        """Simulate token earnings across player base"""
        
        daily_earnings = []
        active_players = []
        total_tokens_earned = 0
        
        for day in range(days):
            day_earnings = 0
            day_active = 0
            
            for player in self.player_profiles:
                # Check if player is still active (simplified retention model)
                if np.random.random() < player.retention_probability:
                    # Calculate daily earnings for this player
                    skill_multiplier = 0.5 + (player.skill_level * 1.5)  # 0.5x to 2.0x multiplier
                    time_factor = player.time_investment
                    
                    player_daily_tokens = (
                        self.base_earning_rate * 
                        skill_multiplier * 
                        time_factor *
                        np.random.uniform(0.8, 1.2)  # Daily variance
                    )
                    
                    day_earnings += player_daily_tokens
                    day_active += 1
                    total_tokens_earned += player_daily_tokens
            
            daily_earnings.append(day_earnings)
            active_players.append(day_active)
        
        return {
            'daily_token_emissions': daily_earnings,
            'active_players': active_players,
            'total_tokens_earned': total_tokens_earned,
            'average_daily_emissions': np.mean(daily_earnings),
            'peak_daily_emissions': max(daily_earnings),
            'player_retention_rate': np.mean(active_players) / len(self.player_profiles)
        }
    
    def analyze_economic_sustainability(self, treasury_tokens: float, simulation_results: Dict) -> Dict:
        """Analyze if the economic model is sustainable"""
        
        daily_emissions = simulation_results['average_daily_emissions']
        treasury_runway_days = treasury_tokens / daily_emissions if daily_emissions > 0 else float('inf')
        
        # Calculate required token price appreciation to maintain sustainability
        current_daily_cost_usd = daily_emissions * self.token_price
        
        # Estimate required revenue per user to break even
        active_players = simulation_results['player_retention_rate'] * len(self.player_profiles)
        required_revenue_per_user = current_daily_cost_usd / active_players if active_players > 0 else 0
        
        sustainability_analysis = {
            'treasury_runway_days': treasury_runway_days,
            'daily_emission_cost_usd': current_daily_cost_usd,
            'required_revenue_per_user_daily': required_revenue_per_user,
            'sustainability_status': self._assess_sustainability(treasury_runway_days, required_revenue_per_user),
            'recommended_actions': self._generate_recommendations(treasury_runway_days, required_revenue_per_user)
        }
        
        return sustainability_analysis
    
    def _assess_sustainability(self, runway_days: float, revenue_per_user: float) -> str:
        """Assess overall sustainability status"""
        
        if runway_days < 90:
            return "Critical - Immediate action required"
        elif runway_days < 180:
            return "High Risk - Monitor closely"
        elif revenue_per_user > 5.0:  # $5+ per user per day
            return "Unsustainable - Revenue model needed"
        elif runway_days > 365:
            return "Healthy - Long-term sustainable"
        else:
            return "Moderate Risk - Optimization needed"
    
    def _generate_recommendations(self, runway_days: float, revenue_per_user: float) -> List[str]:
        """Generate specific recommendations based on analysis"""
        
        recommendations = []
        
        if runway_days < 180:
            recommendations.append("Reduce token emission rates by 20-30%")
            recommendations.append("Implement token burning mechanisms")
            recommendations.append("Seek additional treasury funding")
        
        if revenue_per_user > 3.0:
            recommendations.append("Introduce premium features or NFT sales")
            recommendations.append("Implement tournament entry fees")
            recommendations.append("Add advertising revenue streams")
        
        if runway_days > 365 and revenue_per_user < 1.0:
            recommendations.append("Consider increasing reward rates to attract players")
            recommendations.append("Expand marketing to grow player base")
        
        return recommendations

# Example usage with different player types
simulator = PlayToEarnSimulator(token_price=0.15, base_earning_rate=25)

# Add different player cohorts
casual_players = PlayerProfile(skill_level=0.3, time_investment=1.5, risk_tolerance=0.4, retention_probability=0.6)
simulator.add_player_cohort(casual_players, 5000)

hardcore_players = PlayerProfile(skill_level=0.8, time_investment=6.0, risk_tolerance=0.7, retention_probability=0.85)
simulator.add_player_cohort(hardcore_players, 1000)

intermediate_players = PlayerProfile(skill_level=0.5, time_investment=3.0, risk_tolerance=0.5, retention_probability=0.7)
simulator.add_player_cohort(intermediate_players, 3000)

# Run simulation
results = simulator.simulate_earnings_distribution(30)
sustainability = simulator.analyze_economic_sustainability(50000000, results)

print(f"Treasury runway: {sustainability['treasury_runway_days']:.0f} days")
print(f"Daily cost: ${sustainability['daily_emission_cost_usd']:,.2f}")
print(f"Status: {sustainability['sustainability_status']}")

# report_generator.py - Generate comprehensive GameFi analysis reports
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime
import pandas as pd

class GameFiReportGenerator:
    def __init__(self, analyzer, simulator):
        self.analyzer = analyzer
        self.simulator = simulator
        
    def generate_full_report(self, token_data: Dict, output_path: str = None) -> str:
        """Generate comprehensive GameFi token analysis report"""
        
        # Get AI analysis
        ai_analysis = self.analyzer.analyze_token_sustainability(token_data)
        
        # Run economics simulation
        simulation_results = self.simulator.simulate_earnings_distribution()
        sustainability_analysis = self.simulator.analyze_economic_sustainability(
            token_data['supply_metrics']['treasury_balance'], 
            simulation_results
        )
        
        # Generate report sections
        report_sections = {
            'executive_summary': self._create_executive_summary(ai_analysis, sustainability_analysis),
            'token_metrics': self._analyze_token_metrics(token_data),
            'economic_model': self._analyze_economic_model(simulation_results, sustainability_analysis),
            'risk_assessment': self._create_risk_assessment(ai_analysis['risk_factors']),
            'recommendations': self._compile_recommendations(ai_analysis, sustainability_analysis),
            'monitoring_dashboard': self._create_monitoring_metrics(token_data)
        }
        
        # Combine into full report
        full_report = self._format_report(report_sections)
        
        # Save report if path provided
        if output_path:
            with open(output_path, 'w') as f:
                f.write(full_report)
        
        return full_report
    
    def _create_executive_summary(self, ai_analysis: Dict, sustainability: Dict) -> str:
        """Create executive summary with key findings"""
        
        sustainability_score = ai_analysis['sustainability_score']
        runway_days = sustainability['treasury_runway_days']
        status = sustainability['sustainability_status']
        
        summary = f"""
## Executive Summary

**Sustainability Score: {sustainability_score:.1f}/100**
**Treasury Runway: {runway_days:.0f} days**
**Overall Status: {status}**

### Key Findings:

**Economic Health:**
- The token shows a sustainability score of {sustainability_score:.1f}/100
- Treasury runway provides {runway_days:.0f} days of current emission rates
- Daily emission cost: ${sustainability['daily_emission_cost_usd']:,.2f}

**Critical Insights:**
{ai_analysis['sustainability_outlook']}

**Immediate Actions Required:**
"""
        
        # Add top 3 recommendations
        top_recommendations = sustainability['recommended_actions'][:3]
        for i, rec in enumerate(top_recommendations, 1):
            summary += f"\n{i}. {rec}"
        
        return summary
    
    def _analyze_token_metrics(self, token_data: Dict) -> str:
        """Analyze core token metrics"""
        
        supply_data = token_data['supply_metrics']
        gaming_data = token_data['gaming_metrics']
        price_data = token_data['price_history']
        
        # Calculate key ratios
        circulation_ratio = supply_data['circulating_supply'] / supply_data['total_supply']
        staking_ratio = supply_data['staked_tokens'] / supply_data['circulating_supply']
        inflation_rate = (supply_data['daily_emissions'] * 365) / supply_data['circulating_supply']
        
        metrics_analysis = f"""
## Token Metrics Analysis

### Supply Dynamics
- **Total Supply:** {supply_data['total_supply']:,} tokens
- **Circulating Supply:** {supply_data['circulating_supply']:,} tokens ({circulation_ratio:.1%})
- **Staked Tokens:** {supply_data['staked_tokens']:,} tokens ({staking_ratio:.1%})
- **Daily Emissions:** {supply_data['daily_emissions']:,} tokens
- **Annual Inflation Rate:** {inflation_rate:.1%}

### Price Performance
- **Current Price:** ${price_data['price'].iloc[-1]:.4f}
- **30-Day Change:** {((price_data['price'].iloc[-1] / price_data['price'].iloc[0]) - 1) * 100:.2f}%
- **Average Daily Volume:** ${price_data['volume'].mean():,.2f}
- **Price Volatility:** {(price_data['price'].std() / price_data['price'].mean()) * 100:.1f}%

### Gaming Metrics
- **Daily Active Users:** {gaming_data['daily_active_users']:,}
- **7-Day Retention:** {gaming_data['user_retention_7d']*100:.1f}%
- **30-Day Retention:** {gaming_data['user_retention_30d']*100:.1f}%
- **Tokens Earned Per Hour:** {gaming_data['tokens_earned_per_hour']}
"""
        
        return metrics_analysis
    
    def _analyze_economic_model(self, simulation_results: Dict, sustainability: Dict) -> str:
        """Analyze the play-to-earn economic model"""
        
        avg_emissions = simulation_results['average_daily_emissions']
        peak_emissions = simulation_results['peak_daily_emissions']
        retention_rate = simulation_results['player_retention_rate']
        
        economic_analysis = f"""
## Economic Model Analysis

### Emission Dynamics
- **Average Daily Emissions:** {avg_emissions:,.0f} tokens
- **Peak Daily Emissions:** {peak_emissions:,.0f} tokens
- **Total Tokens Earned (30d):** {simulation_results['total_tokens_earned']:,.0f}
- **Player Retention Rate:** {retention_rate:.1%}

### Sustainability Metrics
- **Treasury Runway:** {sustainability['treasury_runway_days']:.0f} days
- **Daily Cost (USD):** ${sustainability['daily_emission_cost_usd']:,.2f}
- **Required Revenue per User:** ${sustainability['required_revenue_per_user_daily']:.2f}/day

### Economic Balance Assessment
The current economic model shows {'sustainable' if sustainability['treasury_runway_days'] > 365 else 'unsustainable'} characteristics.
Key factors influencing sustainability:

1. **Token Emission Rate:** {'High' if avg_emissions > 1000000 else 'Moderate' if avg_emissions > 100000 else 'Low'} daily emissions
2. **Player Retention:** {'Strong' if retention_rate > 0.7 else 'Moderate' if retention_rate > 0.4 else 'Weak'} retention rates
3. **Treasury Management:** {'Healthy' if sustainability['treasury_runway_days'] > 365 else 'Critical'} runway duration
"""
        
        return economic_analysis
    
    def _create_risk_assessment(self, risk_factors: List[Dict]) -> str:
        """Create detailed risk assessment section"""
        
        risk_section = """
## Risk Assessment

### Identified Risk Factors
"""
        
        for risk in risk_factors:
            risk_section += f"""
**{risk['factor']}** - {risk['severity']} Risk
- {risk['description']}
"""
        
        # Add general risk categories
        risk_section += """
### Risk Mitigation Strategies

**Economic Risks:**
- Monitor token emission rates weekly
- Implement dynamic reward adjustments
- Maintain 6+ month treasury runway

**User Engagement Risks:**
- Track retention metrics daily
- Implement player feedback systems
- Regular gameplay balance updates

**Market Risks:**
- Diversify treasury holdings
- Implement token burning mechanisms
- Monitor competitor strategies
"""
        
        return risk_section
    
    def _compile_recommendations(self, ai_analysis: Dict, sustainability: Dict) -> str:
        """Compile actionable recommendations"""
        
        recommendations_section = """
## Strategic Recommendations

### Immediate Actions (0-30 days)
"""
        
        # Add immediate recommendations
        immediate_actions = sustainability['recommended_actions'][:3]
        for action in immediate_actions:
            recommendations_section += f"- {action}\n"
        
        recommendations_section += """
### Medium-term Strategies (1-6 months)
"""
        
        # Add AI recommendations
        ai_recommendations = ai_analysis.get('recommendations', [])
        for rec in ai_recommendations[:3]:
            recommendations_section += f"- {rec}\n"
        
        recommendations_section += """
### Long-term Development (6+ months)
- Develop additional revenue streams beyond token sales
- Expand gaming ecosystem with new features
- Build strategic partnerships with other GameFi projects
- Implement governance mechanisms for community input
"""
        
        return recommendations_section
    
    def _create_monitoring_metrics(self, token_data: Dict) -> str:
        """Create monitoring dashboard specifications"""
        
        monitoring_section = """
## Monitoring Dashboard Metrics

### Daily Tracking Metrics
- Active user count and retention rates
- Token emission volumes and treasury balance
- Price performance and trading volumes
- Player engagement and session duration

### Weekly Analysis Metrics  
- User acquisition and churn rates
- Token distribution and staking ratios
- Revenue per user and lifetime value
- Competitor performance benchmarks

### Monthly Strategic Reviews
- Economic model sustainability assessment
- Risk factor evaluation and mitigation
- Strategic initiative performance
- Market positioning and opportunity analysis

### Alert Thresholds
- Treasury runway < 180 days: **Critical Alert**
- 7-day retention < 25%: **High Priority**
- Daily active users decline > 20%: **Medium Priority**
- Token price volatility > 50%: **Monitor Closely**
"""
        
        return monitoring_section
    
    def _format_report(self, sections: Dict) -> str:
        """Format all sections into final report"""
        
        report_header = f"""
# GameFi Token Analysis Report
**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
**Analysis Framework:** Ollama AI + Economic Simulation

---
"""
        
        full_report = report_header
        
        # Add each section
        for section_name, section_content in sections.items():
            full_report += section_content + "\n\n---\n\n"
        
        # Add footer
        full_report += """
## Disclaimer
This analysis is for informational purposes only and should not be considered financial advice. 
GameFi investments carry significant risks. Always conduct your own research and consult with 
financial professionals before making investment decisions.

**Report generated using Ollama AI and proprietary GameFi analysis algorithms.**
"""
        
        return full_report

# Generate comprehensive report
report_generator = GameFiReportGenerator(analyzer, simulator)
full_report = report_generator.generate_full_report(token_data, 'gamefi_analysis_report.md')
print("Report generated successfully!")

# Quick analysis script for any GameFi token
def quick_gamefi_analysis(token_symbol: str):
    """Perform rapid GameFi token assessment"""
    
    # Collect data
    token_data = collector.fetch_token_metrics(token_symbol)
    
    # AI analysis
    analysis = analyzer.analyze_token_sustainability(token_data)
    
    # Economic simulation
    sim_results = simulator.simulate_earnings_distribution()
    sustainability = simulator.analyze_economic_sustainability(
        token_data['supply_metrics']['treasury_balance'], sim_results
    )
    
    # Quick assessment
    print(f"\n=== {token_symbol.upper()} Quick Analysis ===")
    print(f"Sustainability Score: {analysis['sustainability_score']:.1f}/100")
    print(f"Treasury Runway: {sustainability['treasury_runway_days']:.0f} days")
    print(f"Status: {sustainability['sustainability_status']}")
    print(f"Top Risk: {analysis['risk_factors'][0]['factor'] if analysis['risk_factors'] else 'None identified'}")
    
    return {
        'score': analysis['sustainability_score'],
        'runway': sustainability['treasury_runway_days'],
        'status': sustainability['sustainability_status']
    }

# Analyze multiple projects
projects = ['axie-infinity', 'the-sandbox', 'decentraland', 'gala']
results = {}

for project in projects:
    try:
        results[project] = quick_gamefi_analysis(project)
    except Exception as e:
        print(f"Error analyzing {project}: {e}")

# monitoring_system.py - Real-time GameFi monitoring
import schedule
import time
import smtplib
from email.mime.text import MimeText
from datetime import datetime, timedelta

class GameFiMonitoringSystem:
    def __init__(self, config):
        self.config = config
        self.alert_thresholds = {
            'treasury_runway_critical': 90,  # days
            'treasury_runway_warning': 180,  # days
            'retention_rate_critical': 0.2,  # 20%
            'sustainability_score_warning': 40,  # out of 100
            'price_drop_alert': 0.2  # 20% in 24h
        }
        
    def setup_monitoring_schedule(self):
        """Setup automated monitoring schedule"""
        
        # Daily monitoring
        schedule.every().day.at("09:00").do(self.daily_health_check)
        schedule.every().day.at("18:00").do(self.daily_summary_report)
        
        # Weekly deep analysis
        schedule.every().monday.at("10:00").do(self.weekly_analysis)
        
        # Real-time price monitoring (every 15 minutes during trading hours)
        schedule.every(15).minutes.do(self.price_monitoring)
        
        print("Monitoring system initialized. Starting continuous monitoring...")
        
        while True:
            schedule.run_pending()
            time.sleep(60)  # Check every minute
    
    def daily_health_check(self):
        """Perform daily health assessment"""
        
        projects_to_monitor = self.config.get('monitored_projects', [])
        alerts = []
        
        for project in projects_to_monitor:
            try:
                # Collect latest data
                token_data = collector.fetch_token_metrics(project)
                analysis = analyzer.analyze_token_sustainability(token_data)
                
                # Check alert conditions
                project_alerts = self.check_alert_conditions(project, analysis, token_data)
                alerts.extend(project_alerts)
                
            except Exception as e:
                alerts.append({
                    'project': project,
                    'type': 'data_error',
                    'message': f"Failed to analyze {project}: {e}",
                    'severity': 'medium'
                })
        
        # Send alerts if any critical issues found
        if alerts:
            self.send_alert_notification(alerts)
        
        # Log daily status
        self.log_daily_status(alerts)
    
    def check_alert_conditions(self, project: str, analysis: Dict, token_data: Dict) -> List[Dict]:
        """Check various alert conditions for a project"""
        
        alerts = []
        
        # Treasury runway alerts
        runway_days = self.calculate_treasury_runway(token_data)
        if runway_days < self.alert_thresholds['treasury_runway_critical']:
            alerts.append({
                'project': project,
                'type': 'treasury_critical',
                'message': f"Treasury runway critically low: {runway_days:.0f} days remaining",
                'severity': 'critical',
                'value': runway_days
            })
        elif runway_days < self.alert_thresholds['treasury_runway_warning']:
            alerts.append({
                'project': project,
                'type': 'treasury_warning',
                'message': f"Treasury runway warning: {runway_days:.0f} days remaining",
                'severity': 'warning',
                'value': runway_days
            })
        
        # Sustainability score alerts
        score = analysis['sustainability_score']
        if score < self.alert_thresholds['sustainability_score_warning']:
            alerts.append({
                'project': project,
                'type': 'sustainability_low',
                'message': f"Sustainability score low: {score:.1f}/100",
                'severity': 'warning',
                'value': score
            })
        
        # User retention alerts
        retention = token_data['gaming_metrics']['user_retention_7d']
        if retention < self.alert_thresholds['retention_rate_critical']:
            alerts.append({
                'project': project,
                'type': 'retention_critical',
                'message': f"User retention critically low: {retention*100:.1f}%",
                'severity': 'high',
                'value': retention
            })
        
        return alerts
    
    def price_monitoring(self):
        """Monitor price movements for alerts"""
        
        current_time = datetime.now().hour
        
        # Only monitor during active trading hours (0-23 UTC)
        if 0 <= current_time <= 23:
            projects = self.config.get('monitored_projects', [])
            
            for project in projects:
                try:
                    # Get 24-hour price data
                    price_data = collector.fetch_token_metrics(project, days=1)
                    
                    if price_data and len(price_data['price_history']) >= 2:
                        current_price = price_data['price_history']['price'].iloc[-1]
                        previous_price = price_data['price_history']['price'].iloc[0]
                        price_change = (current_price - previous_price) / previous_price
                        
                        # Check for significant price movements
                        if abs(price_change) > self.alert_thresholds['price_drop_alert']:
                            direction = "increased" if price_change > 0 else "decreased"
                            self.send_price_alert(project, current_price, price_change, direction)
                
                except Exception as e:
                    print(f"Price monitoring error for {project}: {e}")
    
    def send_alert_notification(self, alerts: List[Dict]):
        """Send alert notifications via email/webhook"""
        
        critical_alerts = [a for a in alerts if a['severity'] == 'critical']
        high_alerts = [a for a in alerts if a['severity'] == 'high']
        warning_alerts = [a for a in alerts if a['severity'] == 'warning']
        
        if critical_alerts or high_alerts:
            # Send immediate notification for critical/high alerts
            self.send_email_alert(critical_alerts + high_alerts, urgent=True)
        
        if warning_alerts:
            # Send daily digest for warnings
            self.send_email_alert(warning_alerts, urgent=False)
    
    def send_email_alert(self, alerts: List[Dict], urgent: bool = False):
        """Send email alert notification"""
        
        subject = "🚨 Critical GameFi Alert" if urgent else "⚠️ GameFi Warning Notification"
        
        body = f"""
GameFi Monitoring Alert - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

{"URGENT ACTION REQUIRED" if urgent else "MONITORING ALERT"}

Detected Issues:
"""
        
        for alert in alerts:
            body += f"""
• {alert['project'].upper()}: {alert['message']}
  Severity: {alert['severity'].upper()}
  Type: {alert['type']}
"""
        
        body += """

This is an automated alert from your GameFi monitoring system.
Review the full dashboard for detailed analysis and recommendations.
"""
        
        # Send email (configure with your SMTP settings)
        try:
            msg = MimeText(body)
            msg['Subject'] = subject
            msg['From'] = self.config['email_from']
            msg['To'] = self.config['email_to']
            
            # Configure SMTP server
            server = smtplib.SMTP(self.config['smtp_server'], self.config['smtp_port'])
            server.starttls()
            server.login(self.config['email_username'], self.config['email_password'])
            server.send_message(msg)
            server.quit()
            
            print(f"Alert email sent: {subject}")
            
        except Exception as e:
            print(f"Failed to send email alert: {e}")

# Setup monitoring
monitoring_config = {
    'monitored_projects': ['axie-infinity', 'the-sandbox', 'decentraland'],
    'email_from': 'gamefi-monitor@yourcompany.com',
    'email_to': 'alerts@yourcompany.com',
    'smtp_server': 'smtp.gmail.com',
    'smtp_port': 587,
    'email_username': 'your-email@gmail.com',
    'email_password': 'your-app-password'
}

monitor = GameFiMonitoringSystem(monitoring_config)
# monitor.setup_monitoring_schedule()  # Uncomment to start monitoring