# web_sentinel_api_production.py - API de production avec auth
from flask import Flask, request, jsonify, send_file
from flask_cors import CORS
from flask_sqlalchemy import SQLAlchemy
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
import os
import json
import hashlib
import tempfile
from datetime import datetime, timedelta
import logging
from typing import Optional
from pathlib import Path

from web_sentinel.scanner import SentinelScanner
from web_sentinel.model import ScanRequest
from web_sentinel.reporting import ReportEngine

# Configuration Flask
app = Flask(__name__)
app.config['SECRET_KEY'] = os.environ.get('WEB_SENTINEL_SECRET_KEY', 'dev-key-change-in-production')
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', 'sqlite:///web_sentinel.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Extensions
db = SQLAlchemy(app)
CORS(app, origins=['https://taaazzz-prog.fr', 'https://*.taaazzz-prog.fr', 'http://localhost:*'])

# Rate limiting
limiter = Limiter(
    key_func=get_remote_address,
    app=app,
    default_limits=["200 per day", "50 per hour"],
    storage_uri=os.environ.get('REDIS_URL', 'memory://')
)

# Logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Modèles de base de données
class APIKey(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    key_hash = db.Column(db.String(64), unique=True, nullable=False)
    name = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), nullable=False)
    tier = db.Column(db.String(20), default='free')  # free, pro, enterprise
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_used = db.Column(db.DateTime)
    is_active = db.Column(db.Boolean, default=True)
    
    # Limitations par tier
    daily_limit = db.Column(db.Integer, default=50)
    monthly_limit = db.Column(db.Integer, default=1000)

class ScanHistory(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    api_key_id = db.Column(db.Integer, db.ForeignKey('api_key.id'), nullable=False)
    scan_type = db.Column(db.String(20), nullable=False)  # source, domain
    target = db.Column(db.String(500), nullable=False)
    findings_count = db.Column(db.Integer, default=0)
    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
    processing_time = db.Column(db.Float)

# Créer les tables
with app.app_context():
    db.create_all()

def hash_api_key(key: str) -> str:
    """Hasher une clé API."""
    return hashlib.sha256(key.encode()).hexdigest()

def validate_api_key(key: str) -> Optional[APIKey]:
    """Valider une clé API."""
    if not key:
        return None
    
    key_hash = hash_api_key(key)
    api_key = APIKey.query.filter_by(key_hash=key_hash, is_active=True).first()
    
    if api_key:
        api_key.last_used = datetime.utcnow()
        db.session.commit()
    
    return api_key

def can_scan_source(api_key: APIKey) -> bool:
    """Vérifier si l'API key peut scanner du code source."""
    # Seul le tier SYSOP peut scanner du code source
    return api_key.tier.lower() == 'sysop'

def check_rate_limits(api_key: APIKey) -> bool:
    """Vérifier les limites de taux."""
    today = datetime.utcnow().date()
    
    # Compter les scans aujourd'hui
    daily_scans = ScanHistory.query.filter(
        ScanHistory.api_key_id == api_key.id,
        ScanHistory.timestamp >= today
    ).count()
    
    if daily_scans >= api_key.daily_limit:
        return False
    
    # Compter les scans ce mois
    month_start = today.replace(day=1)
    monthly_scans = ScanHistory.query.filter(
        ScanHistory.api_key_id == api_key.id,
        ScanHistory.timestamp >= month_start
    ).count()
    
    return monthly_scans < api_key.monthly_limit

@app.route('/api/v1/health')
def health():
    """Endpoint de santé."""
    return jsonify({
        'status': 'healthy',
        'version': '1.0.0',
        'timestamp': datetime.utcnow().isoformat(),
        'server': 'taaazzz-prog.fr'
    })

@app.route('/api/v1/debug/sast', methods=['POST'])
def debug_sast():
    """Debug endpoint pour tester le scanner SAST."""
    try:
        # Test simple du scanner SAST
        import tempfile
        from pathlib import Path
        
        test_code = '''
password = "admin123"
api_key = "sk-test-key"
'''
        
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tmp_file:
            tmp_file.write(test_code)
            tmp_path = tmp_file.name
        
        # Import du scanner
        from web_sentinel.checks.source_code.scanner import SourceCodeScanner, SourceScanConfig
        
        config = SourceScanConfig(
            source_path=Path(tmp_path),
            languages={'python'},
            min_severity='low',
            max_files=1,
            advanced_rules=True,
            recursive=False
        )
        
        scanner = SourceCodeScanner(config)
        findings = scanner.scan()
        
        # Nettoyer
        Path(tmp_path).unlink()
        
        return jsonify({
            'status': 'success',
            'findings_count': len(findings),
            'findings': [f.title for f in findings]
        })
        
    except Exception as e:
        import traceback
        return jsonify({
            'status': 'error',
            'error': str(e),
            'traceback': traceback.format_exc()
        }), 500

@app.route('/api/v1/scan-source', methods=['POST'])
@limiter.limit("20 per minute")
def scan_source_code():
    """Scanner du code source."""
    start_time = datetime.utcnow()
    
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': 'JSON payload required'}), 400
        
        # Validation de l'API key
        api_key_str = data.get('api_key')
        api_key = validate_api_key(api_key_str)
        
        if not api_key:
            return jsonify({'error': 'Invalid or missing API key'}), 401
        
        # Vérifier les permissions pour le scan de source
        if not can_scan_source(api_key):
            return jsonify({
                'error': 'Source code scanning requires SYSOP tier',
                'current_tier': api_key.tier,
                'required_tier': 'sysop'
            }), 403
        
        # Vérifier les limites
        if not check_rate_limits(api_key):
            return jsonify({
                'error': 'Rate limit exceeded',
                'daily_limit': api_key.daily_limit,
                'monthly_limit': api_key.monthly_limit
            }), 429
        
        # Paramètres obligatoires
        source_content = data.get('source_content')
        if not source_content:
            return jsonify({'error': 'source_content required'}), 400
        
        file_path = data.get('file_path', 'unknown.txt')
        language = data.get('language', 'auto')
        options = data.get('options', {})
        
        # Créer un fichier temporaire pour le contenu source
        with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{language}', delete=False) as tmp_file:
            tmp_file.write(source_content)
            tmp_path = tmp_file.name
        
        try:
            # Importer le scanner SAST
            from web_sentinel.checks.source_code.scanner import SourceCodeScanner, SourceScanConfig
            
            # Configuration du scan
            config = SourceScanConfig(
                source_path=Path(tmp_path),
                languages={language} if language != 'auto' else {'auto'},
                min_severity=options.get('min_severity', 'medium'),
                max_files=options.get('max_files', 1),  # Un seul fichier pour l'API
                max_size_mb=options.get('max_size_mb', 10),  # 10MB max par défaut
                advanced_rules=True,  # SYSOP a accès aux règles avancées
                recursive=False,  # Pas de récursion pour un seul fichier
                detailed_report=True
            )
            
            # Lancer le scan SAST
            scanner = SourceCodeScanner(config)
            scan_findings = scanner.scan()
            
            # Convertir les findings en format API
            findings = []
            for finding in scan_findings:
                findings.append({
                    'check': finding.check,
                    'title': finding.title,
                    'severity': finding.severity,
                    'description': finding.description,
                    'remediation': finding.remediation,
                    'impact': finding.impact,
                    'evidence': finding.evidence
                })
        
        finally:
            # Nettoyer le fichier temporaire
            try:
                os.unlink(tmp_path)
            except OSError:
                pass
        
        # NOTE: Enregistrement d'historique temporairement désactivé pour debug
        # scan_record = ScanHistory(...)
        processing_time = (datetime.utcnow() - start_time).total_seconds()
        
        logger.info(f"Source scan completed for {api_key.email}: {len(findings)} findings")
        
        return jsonify({
            'status': 'success',
            'scan_id': f"src_debug_{int(datetime.utcnow().timestamp())}",
            'timestamp': datetime.utcnow().isoformat(),
            'file_path': file_path,
            'language': language,
            'findings': findings,
            'summary': {
                'total': len(findings),
                'by_severity': {
                    'critical': len([f for f in findings if f['severity'] == 'critical']),
                    'high': len([f for f in findings if f['severity'] == 'high']),
                    'medium': len([f for f in findings if f['severity'] == 'medium']),
                    'low': len([f for f in findings if f['severity'] == 'low'])
                }
            }
        })
        
    except Exception as e:
        logger.error(f"Error in source scan: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({
            'error': 'Internal server error', 
            'details': str(e),
            'type': type(e).__name__
        }), 500@app.route('/api/v1/scan-domain', methods=['POST'])
@limiter.limit("10 per minute")
def scan_domain():
    """Scanner un domaine (utilise votre scanner existant)."""
    start_time = datetime.utcnow()
    
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': 'JSON payload required'}), 400
        
        # Validation API key
        api_key_str = data.get('api_key')
        api_key = validate_api_key(api_key_str)
        
        if not api_key:
            return jsonify({'error': 'Invalid or missing API key'}), 401
        
        if not check_rate_limits(api_key):
            return jsonify({'error': 'Rate limit exceeded'}), 429
        
        domain = data.get('domain')
        if not domain:
            return jsonify({'error': 'domain required'}), 400
        
        options = data.get('options', {})
        
        # Utiliser votre scanner existant
        request_obj = ScanRequest(
            domain=domain,
            timeout=options.get('timeout', 5.0),
            allow_invasive=options.get('allow_invasive', False)
        )
        
        scanner = SentinelScanner()
        modules = options.get('modules', list(scanner.modules.keys()))
        
        result = scanner.run(request_obj, modules)
        
        # Enregistrer l'historique
        scan_record = ScanHistory(
            api_key_id=api_key.id,
            scan_type='domain',
            target=domain,
            findings_count=len(result.findings),
            processing_time=(datetime.utcnow() - start_time).total_seconds()
        )
        db.session.add(scan_record)
        db.session.commit()
        
        logger.info(f"Domain scan completed for {api_key.email}: {domain}")
        
        # Formatter la réponse
        findings = [
            {
                'check': f.check,
                'title': f.title,
                'severity': f.severity,
                'description': f.description,
                'remediation': f.remediation
            } for f in result.findings
        ]
        
        return jsonify({
            'status': 'success',
            'scan_id': f"dom_{scan_record.id}",
            'timestamp': datetime.utcnow().isoformat(),
            'domain': domain,
            'findings': findings,
            'summary': {
                'total': len(findings),
                'by_severity': {
                    'critical': len([f for f in findings if f['severity'] == 'critical']),
                    'high': len([f for f in findings if f['severity'] == 'high']),
                    'medium': len([f for f in findings if f['severity'] == 'medium']),
                    'low': len([f for f in findings if f['severity'] == 'low'])
                }
            }
        })
        
    except Exception as e:
        logger.error(f"Error in domain scan: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/api/v1/register', methods=['POST'])
@limiter.limit("5 per hour")
def register_api_key():
    """Enregistrer une nouvelle clé API."""
    try:
        data = request.get_json()
        
        name = data.get('name')
        email = data.get('email')
        
        if not name or not email:
            return jsonify({'error': 'name and email required'}), 400
        
        # Générer une clé API
        import secrets
        api_key_str = f"ws_{secrets.token_urlsafe(32)}"
        key_hash = hash_api_key(api_key_str)
        
        # Créer l'enregistrement
        api_key = APIKey(
            key_hash=key_hash,
            name=name,
            email=email,
            tier='free'
        )
        
        db.session.add(api_key)
        db.session.commit()
        
        logger.info(f"New API key registered for {email}")
        
        return jsonify({
            'api_key': api_key_str,
            'tier': 'free',
            'daily_limit': 50,
            'monthly_limit': 1000,
            'message': 'API key generated successfully'
        })
        
    except Exception as e:
        logger.error(f"Error registering API key: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/api/v1/admin/create-sysop-key', methods=['POST'])
@limiter.limit("2 per hour")
def create_sysop_key():
    """Créer une clé API SYSOP (endpoint administratif)."""
    try:
        data = request.get_json()
        
        # Vérification du secret admin
        admin_secret = data.get('admin_secret')
        expected_secret = os.environ.get('WEB_SENTINEL_ADMIN_SECRET')
        
        if not admin_secret or not expected_secret or admin_secret != expected_secret:
            return jsonify({'error': 'Invalid admin secret'}), 403
        
        name = data.get('name')
        email = data.get('email')
        
        if not name or not email:
            return jsonify({'error': 'name and email required'}), 400
        
        # Générer une clé API SYSOP
        import secrets
        api_key_str = f"ws_sysop_{secrets.token_urlsafe(32)}"
        key_hash = hash_api_key(api_key_str)
        
        # Créer l'enregistrement avec tier SYSOP
        api_key = APIKey(
            key_hash=key_hash,
            name=name,
            email=email,
            tier='sysop',
            daily_limit=1000,  # Limites plus élevées pour SYSOP
            monthly_limit=10000
        )
        
        db.session.add(api_key)
        db.session.commit()
        
        logger.info(f"New SYSOP API key created for {email}")
        
        return jsonify({
            'api_key': api_key_str,
            'tier': 'sysop',
            'daily_limit': 1000,
            'monthly_limit': 10000,
            'message': 'SYSOP API key generated successfully',
            'permissions': ['source_code_scanning', 'unlimited_domains']
        })
        
    except Exception as e:
        logger.error(f"Error creating SYSOP key: {e}")
        return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    try:
        print("Démarrage du serveur Web Sentinel API...")
        print(f"Secret admin configuré: {bool(os.environ.get('WEB_SENTINEL_ADMIN_SECRET'))}")
        app.run(host='0.0.0.0', port=5000, debug=False)
    except Exception as e:
        print(f"Erreur lors du démarrage: {e}")
        import traceback
        traceback.print_exc()