"""Test routes to verify everything works"""
from flask import Blueprint, jsonify, request
from flask_login import login_required, current_user
from app.utils.gamification import award_points, calculate_level, get_user_rank_in_league, check_achievement_triggers
from app.services.leaderboard_service import LeaderboardService
from app.config.achievements import check_user_achievements, get_user_achievement_progress, get_achievement_stats
from app.models.user import User
from app.extensions import db
import logging

logger = logging.getLogger(__name__)

test_gamification_bp = Blueprint('test_gamification', __name__, url_prefix='/api/test')

@test_gamification_bp.route('/award-points/<int:user_id>')
def test_award_points(user_id):
    """Test awarding points - Example: /api/test/award-points/1"""
    try:
        activity_type = request.args.get('activity', 'contract_completed')
        points = request.args.get('points', type=int)
        
        success = award_points(
            user_id=user_id, 
            activity_type=activity_type,
            points=points
        )
        
        # Get updated user info
        user = User.query.get(user_id)
        
        return jsonify({
            'success': success,
            'activity_type': activity_type,
            'points_awarded': points if points else 100,
            'user': {
                'id': user_id,
                'total_points': user.total_points if user else 0,
                'current_level': user.current_level if user else 1,
                'league': user.seasonal_league if user else 'bronze'
            }
        })
        
    except Exception as e:
        logger.error(f"Error in test award points: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@test_gamification_bp.route('/leaderboard')
def test_leaderboard():
    """Test leaderboard - Example: /api/test/leaderboard"""
    try:
        leaderboard_type = request.args.get('type', 'weekly')
        limit = request.args.get('limit', 10, type=int)
        
        service = LeaderboardService()
        
        if leaderboard_type == 'weekly':
            data = service.get_weekly_leaderboard(limit=limit)
        elif leaderboard_type == 'monthly':
            data = service.get_monthly_leaderboard(limit=limit)
        elif leaderboard_type == 'all_time':
            data = service.get_all_time_leaderboard(limit=limit)
        else:
            # League leaderboard
            league = request.args.get('league', 'bronze')
            data = service.get_league_leaderboard(league=league, limit=limit)
        
        return jsonify(data)
        
    except Exception as e:
        logger.error(f"Error in test leaderboard: {e}")
        return jsonify({
            'error': str(e),
            'leaderboard': [],
            'period': {}
        }), 500

@test_gamification_bp.route('/level/<int:points>')
def test_level(points):
    """Test level calculation - Example: /api/test/level/500"""
    try:
        level = calculate_level(points)
        
        # Calculate points needed for next level
        from app.utils.gamification import get_points_for_next_level
        points_to_next = get_points_for_next_level(points)
        
        return jsonify({
            'points': points,
            'level': level,
            'points_to_next_level': points_to_next,
            'level_thresholds': {
                'level_1': '0-99 points',
                'level_2': '100-149 points',
                'level_3': '150-299 points',
                'level_4': '300-499 points',
                'level_5': '500-699 points',
                'level_6': '700-999 points',
                'level_7': '1000-1499 points',
                'level_8': '1500-2499 points',
                'level_9': '2500-4999 points',
                'level_10': '5000+ points'
            }
        })
        
    except Exception as e:
        logger.error(f"Error in test level: {e}")
        return jsonify({
            'error': str(e),
            'points': points,
            'level': 1
        }), 500

@test_gamification_bp.route('/achievements/<int:user_id>')
def test_achievements(user_id):
    """Test achievement checking - Example: /api/test/achievements/1"""
    try:
        # Check for new achievements
        new_achievements = check_user_achievements(user_id)
        
        # Get achievement progress
        progress = get_user_achievement_progress(user_id)
        
        # Get achievement stats
        stats = get_achievement_stats()
        
        return jsonify({
            'user_id': user_id,
            'new_achievements_earned': new_achievements,
            'achievement_progress': progress,
            'achievement_system_stats': stats
        })
        
    except Exception as e:
        logger.error(f"Error in test achievements: {e}")
        return jsonify({
            'error': str(e),
            'user_id': user_id,
            'new_achievements_earned': [],
            'achievement_progress': []
        }), 500

@test_gamification_bp.route('/user-rank/<int:user_id>')
def test_user_rank(user_id):
    """Test user ranking - Example: /api/test/user-rank/1"""
    try:
        # Get user's rank in their league
        rank_info = get_user_rank_in_league(user_id)
        
        # Get user's position in different leaderboards
        service = LeaderboardService()
        weekly_position = service.get_user_position(user_id, 'weekly')
        all_time_position = service.get_user_position(user_id, 'all_time')
        
        return jsonify({
            'user_id': user_id,
            'league_rank': rank_info,
            'weekly_position': weekly_position,
            'all_time_position': all_time_position
        })
        
    except Exception as e:
        logger.error(f"Error in test user rank: {e}")
        return jsonify({
            'error': str(e),
            'user_id': user_id,
            'league_rank': {},
            'weekly_position': {},
            'all_time_position': {}
        }), 500

@test_gamification_bp.route('/create-test-user')
def test_create_user():
    """Create a test user for gamification testing"""
    try:
        import random
        from datetime import datetime
        
        # Create test user
        test_user = User(
            email=f'testuser{ra, timezonendom.randint(1000, 9999)}@example.com',
            first_name='Test',
            last_name='User',
            role='worker',
            phone_number='0400000000',
            location='Sydney, NSW',
            abn_number=f'{random.randint(10000000000, 99999999999)}',
            jobs_completed=random.randint(0, 20),
            average_rating=round(random.uniform(3.5, 5.0), 1),
            total_points=random.randint(0, 2000),
            current_level=1,
            seasonal_league='bronze',
            public_liability_insurance=True,
            workers_comp_insurance=True,
            privacy_consent=True,
            terms_accepted=True,
            terms_accepted_date=datetime.now(timezone.utc)
        )
        
        # Set a password
        test_user.set_password('testpassword123')
        
        db.session.add(test_user)
        db.session.commit()
        
        # Update level based on points
        test_user.current_level = calculate_level(test_user.total_points)
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'Test user created successfully',
            'user': {
                'id': test_user.id,
                'email': test_user.email,
                'name': f'{test_user.first_name} {test_user.last_name}',
                'role': test_user.role,
                'jobs_completed': test_user.jobs_completed,
                'total_points': test_user.total_points,
                'current_level': test_user.current_level,
                'average_rating': float(test_user.average_rating),
                'seasonal_league': test_user.seasonal_league
            },
            'test_urls': {
                'award_points': f'/api/test/award-points/{test_user.id}',
                'check_achievements': f'/api/test/achievements/{test_user.id}',
                'user_rank': f'/api/test/user-rank/{test_user.id}',
                'level_calc': f'/api/test/level/{test_user.total_points}'
            }
        })
        
    except Exception as e:
        logger.error(f"Error creating test user: {e}")
        db.session.rollback()
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@test_gamification_bp.route('/full-test/<int:user_id>')
def test_full_gamification(user_id):
    """Run complete gamification test suite for a user"""
    try:
        results = {
            'user_id': user_id,
            'tests': {}
        }
        
        # Test 1: Award points
        points_result = award_points(user_id, 'contract_completed')
        results['tests']['award_points'] = {
            'success': points_result,
            'points_awarded': 100
        }
        
        # Test 2: Check achievements
        achievements = check_user_achievements(user_id)
        results['tests']['achievements'] = {
            'new_achievements': achievements,
            'count': len(achievements)
        }
        
        # Test 3: Get leaderboard position
        service = LeaderboardService()
        weekly_pos = service.get_user_position(user_id, 'weekly')
        results['tests']['leaderboard_position'] = weekly_pos
        
        # Test 4: Get user rank in league
        league_rank = get_user_rank_in_league(user_id)
        results['tests']['league_rank'] = league_rank
        
        # Test 5: Get updated user info
        user = User.query.get(user_id)
        if user:
            results['final_user_state'] = {
                'total_points': user.total_points,
                'current_level': user.current_level,
                'jobs_completed': user.jobs_completed,
                'average_rating': float(user.average_rating) if user.average_rating else 0.0,
                'seasonal_league': user.seasonal_league
            }
        
        results['summary'] = {
            'all_tests_passed': all([
                results['tests']['award_points']['success'],
                len(results['tests']['achievements']['new_achievements']) >= 0,
                results['tests']['leaderboard_position']['position'] > 0,
                results['tests']['league_rank']['rank'] > 0
            ]),
            'timestamp': datetime.now(timezone.utc).isoformat()
        }
        
        return jsonify(results)
        
    except Exception as e:
        logger.error(f"Error in full gamification test: {e}")
        return jsonify({
            'error': str(e),
            'user_id': user_id,
            'tests': {},
            'summary': {'all_tests_passed': False}
        }), 500

@test_gamification_bp.route('/system-status')
def test_system_status():
    """Get gamification system status and statistics"""
    try:
        # Basic system stats
        total_users = User.query.count()
        users_with_points = User.query.filter(User.total_points > 0).count()
        
        # League distribution
        league_stats = {}
        for league in ['bronze', 'silver', 'gold', 'platinum', 'diamond']:
            count = User.query.filter(User.seasonal_league == league).count()
            league_stats[league] = count
        
        # Achievement stats
        achievement_stats = get_achievement_stats()
        
        return jsonify({
            'system_status': 'operational',
            'user_statistics': {
                'total_users': total_users,
                'users_with_points': users_with_points,
                'league_distribution': league_stats
            },
            'achievement_system': achievement_stats,
            'available_test_endpoints': {
                'award_points': '/api/test/award-points/<user_id>',
                'leaderboard': '/api/test/leaderboard?type=weekly&limit=10',
                'level_calc': '/api/test/level/<points>',
                'achievements': '/api/test/achievements/<user_id>',
                'user_rank': '/api/test/user-rank/<user_id>',
                'create_test_user': '/api/test/create-test-user',
                'full_test': '/api/test/full-test/<user_id>',
                'system_status': '/api/test/system-status'
            }
        })
        
    except Exception as e:
        logger.error(f"Error getting system status: {e}")
        return jsonify({
            'system_status': 'error',
            'error': str(e)
        }), 500