"""
Smart Matching API Routes
Exposes AIService.smart_job_matching() and related methods
"""
from flask import jsonify, request
from flask_login import login_required, current_user
import logging

from . import matching_bp
from ...services.ai_service import AIService
from ...models.job import Job
from ...models.user import User
from ...models.rating import Rating
from ...extensions import db

logger = logging.getLogger(__name__)


@matching_bp.route('/jobs-for-me', methods=['GET'])
@login_required
def jobs_for_me():
    """Get recommended jobs for the current worker based on AI matching"""
    try:
        if current_user.role != 'worker':
            return jsonify({"error": "Only workers can get job recommendations"}), 403

        limit = request.args.get('limit', 5, type=int)
        limit = min(limit, 20)  # Cap at 20

        matches = AIService.smart_job_matching(current_user.id, limit=limit)

        return jsonify({
            "matches": matches,
            "total": len(matches),
            "worker_id": current_user.id
        }), 200

    except Exception as e:
        logger.error(f"Error in jobs-for-me: {str(e)}")
        return jsonify({"error": "Failed to get job recommendations"}), 500


@matching_bp.route('/workers-for-job/<int:job_id>', methods=['GET'])
@login_required
def workers_for_job(job_id):
    """Get recommended workers for a specific job"""
    try:
        job = Job.query.get(job_id)
        if not job:
            return jsonify({"error": "Job not found"}), 404

        # Only job owner can see worker recommendations
        if current_user.role == 'worker':
            return jsonify({"error": "Only contractors can view worker recommendations"}), 403

        limit = request.args.get('limit', 5, type=int)
        limit = min(limit, 20)

        # Get all active workers
        workers = User.query.filter_by(role='worker', is_deleted=False).all()

        matches = []
        for worker in workers:
            score = 0
            reasons = []

            # Trade matching (40% weight)
            if worker.primary_trade and job.category:
                job_cat = job.category.name.lower() if hasattr(job.category, 'name') else str(job.category).lower()
                if worker.primary_trade.lower() in job_cat or job_cat in worker.primary_trade.lower():
                    score += 40
                    reasons.append("Trade match")

            # Location match (20% weight)
            if worker.location and job.location:
                if worker.location.lower() == job.location.lower():
                    score += 20
                    reasons.append("Same location")
                elif any(area in worker.location.lower() for area in job.location.lower().split()):
                    score += 10
                    reasons.append("Nearby location")

            # Rating (20% weight)
            if worker.average_rating and worker.average_rating > 4.0:
                score += 20
                reasons.append(f"High rated ({worker.average_rating})")
            elif worker.average_rating and worker.average_rating > 3.0:
                score += 10

            # Experience - jobs completed (20% weight)
            if worker.jobs_completed and worker.jobs_completed > 5:
                score += 20
                reasons.append(f"{worker.jobs_completed} jobs completed")
            elif worker.jobs_completed and worker.jobs_completed > 0:
                score += 10

            if score > 0:
                matches.append({
                    "worker_id": worker.id,
                    "name": f"{worker.first_name} {worker.last_name}",
                    "primary_trade": worker.primary_trade,
                    "location": worker.location,
                    "average_rating": float(worker.average_rating) if worker.average_rating else None,
                    "jobs_completed": worker.jobs_completed or 0,
                    "match_score": score,
                    "match_reasons": reasons,
                    "profile_picture": worker.profile_picture
                })

        matches.sort(key=lambda x: x['match_score'], reverse=True)

        return jsonify({
            "matches": matches[:limit],
            "total": len(matches[:limit]),
            "job_id": job_id
        }), 200

    except Exception as e:
        logger.error(f"Error in workers-for-job: {str(e)}")
        return jsonify({"error": "Failed to get worker recommendations"}), 500


@matching_bp.route('/price-suggestion/<int:job_id>', methods=['GET'])
@login_required
def price_suggestion(job_id):
    """Get AI-powered price suggestion for a job"""
    try:
        job = Job.query.get(job_id)
        if not job:
            return jsonify({"error": "Job not found"}), 404

        job_details = {
            "trade": job.category.name.lower() if job.category and hasattr(job.category, 'name') else 'general',
            "description": job.description or '',
            "location": job.location or '',
            "urgency": getattr(job, 'urgency', 'normal') or 'normal'
        }

        recommendation = AIService.price_recommendation(job_details)

        return jsonify({
            "job_id": job_id,
            "recommendation": recommendation
        }), 200

    except Exception as e:
        logger.error(f"Error in price-suggestion: {str(e)}")
        return jsonify({"error": "Failed to get price suggestion"}), 500