from flask import request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from datetime import datetime

from . import safety_bp
from ...models import WHSAssessment, JobProgress, Job, User, Contract, Review
from ...extensions import db
from ...utils.gamification import award_points, check_achievements


@safety_bp.route('/whs-assessments', methods=['POST'])
@jwt_required()
def create_whs_assessment():
    """Create WHS Act 2011 compliance assessment"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        # Validation
        required_fields = ['job_id', 'risk_assessment', 'hazard_identification', 'risk_control_measures']
        for field in required_fields:
            if not data.get(field):
                return jsonify({"error": f"{field} is required"}), 400
        
        # Verify job access
        job = Job.query.get(data['job_id'])
        if not job:
            return jsonify({"error": "Job not found"}), 404
        
        # Check if user can create assessment (job owner or assigned worker)
        if job.contractor_id != current_user_id:
            # Check if user is assigned worker
            contract = Contract.query.filter_by(job_id=job.id, worker_id=current_user_id).first()
            if not contract:
                return jsonify({"error": "Unauthorized to create assessment for this job"}), 403
        
        # Create WHS assessment
        assessment = WHSAssessment(
            job_id=data['job_id'],
            risk_assessment=data['risk_assessment'],
            hazard_identification=data['hazard_identification'],
            risk_control_measures=data['risk_control_measures'],
            safety_plan_accepted=data.get('safety_plan_accepted', False),
            safety_induction_completed=data.get('safety_induction_completed', False),
            emergency_procedures_briefed=data.get('emergency_procedures_briefed', False),
            insurance_verified=data.get('insurance_verified', False),
            white_card_verified=data.get('white_card_verified', False),
            completed_by=current_user_id
        )
        
        assessment.generate_assessment_reference()
        db.session.add(assessment)
        db.session.commit()
        
        # Award points for safety compliance
        compliance_score = assessment.calculate_compliance_score()
        if compliance_score >= 80:
            base_points = 50 if compliance_score >= 95 else 25
            award_points(
                current_user_id, 
                'safety_assessment', 
                base_points,
                f"WHS assessment completed - {compliance_score}% compliance",
                job_id=job.id,
                safety_compliant=compliance_score >= 95
            )
        
        db.session.commit()
        
        return jsonify({
            "message": "WHS assessment created successfully",
            "assessment": {
                "id": assessment.id,
                "assessment_reference": assessment.assessment_reference,
                "compliance_score": compliance_score,
                "is_compliant": assessment.is_compliant(),
                "status": assessment.status
            }
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"WHS assessment creation failed: {str(e)}"}), 500


@safety_bp.route('/job-progress', methods=['POST'])
@jwt_required()
def update_job_progress():
    """Update construction job progress with safety tracking"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        # Validation
        required_fields = ['contract_id', 'status', 'progress_percentage']
        for field in required_fields:
            if not data.get(field):
                return jsonify({"error": f"{field} is required"}), 400
        
        # Verify contract access
        contract = Contract.query.get(data['contract_id'])
        if not contract:
            return jsonify({"error": "Contract not found"}), 404
        
        if current_user_id not in [contract.contractor_id, contract.worker_id]:
            return jsonify({"error": "Unauthorized to update progress for this contract"}), 403
        
        # Create progress record
        progress = JobProgress(
            job_id=contract.job_id,
            contract_id=contract.id,
            status=data['status'],
            progress_percentage=data['progress_percentage'],
            milestone_description=data.get('milestone_description'),
            worker_notes=data.get('worker_notes'),
            contractor_notes=data.get('contractor_notes'),
            safety_incidents_reported=data.get('safety_incidents_reported', 0),
            safety_compliance_maintained=data.get('safety_compliance_maintained', True),
            daily_safety_checks_completed=data.get('daily_safety_checks_completed', False),
            updated_by=current_user_id
        )
        
        # Set dates based on status
        if data['status'] == 'in_progress' and not progress.start_date:
            progress.start_date = datetime.utcnow().date()
        elif data['status'] == 'completed':
            progress.actual_completion_date = datetime.utcnow().date()
            
            # Award completion points
            job_value = float(contract.agreed_rate)
            base_points = 100
            
            award_points(
                contract.worker_id,
                'job_completed',
                base_points,
                f"Completed construction job: {contract.job.title}",
                job_id=contract.job_id,
                contract_id=contract.id,
                job_value=job_value,
                safety_compliant=progress.safety_compliance_maintained
            )
            
            # Update user job count
            worker = User.query.get(contract.worker_id)
            worker.jobs_completed += 1
            
            # Check for achievements
            check_achievements(contract.worker_id)
        
        db.session.add(progress)
        db.session.commit()
        
        return jsonify({
            "message": "Job progress updated successfully",
            "progress": {
                "id": progress.id,
                "status": progress.status,
                "progress_percentage": progress.progress_percentage,
                "safety_compliance": progress.safety_compliance_maintained,
                "timeline_status": progress.get_timeline_status()
            }
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Progress update failed: {str(e)}"}), 500


@safety_bp.route('/reviews', methods=['POST'])
@jwt_required()
def create_review():
    """Create trust system review - only allowed after job completion"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        # Get contract and validate it exists
        contract_id = data.get('contract_id')
        if not contract_id:
            return jsonify({"error": "contract_id is required"}), 400
            
        contract = Contract.query.get(contract_id)
        if not contract:
            return jsonify({"error": "Contract not found"}), 404
            
        # Validate contract status is ready for rating
        if contract.status != 'pending_rating':
            return jsonify({"error": f"Reviews only allowed after job completion. Current status: {contract.status}"}), 403
            
        # Validate user is part of this contract
        if current_user_id not in [contract.contractor_id, contract.worker_id]:
            return jsonify({"error": "You are not part of this contract"}), 403
            
        # Prevent duplicate reviews for same contract
        existing_review = Review.query.filter_by(
            reviewer_id=current_user_id,
            contract_id=contract_id
        ).first()
        if existing_review:
            return jsonify({"error": "You have already reviewed this contract"}), 409
            
        # Determine reviewee based on current user role
        if current_user_id == contract.contractor_id:
            reviewee_id = contract.worker_id
        else:
            reviewee_id = contract.contractor_id
        
        # Validation
        required_fields = ['overall_rating', 'quality_rating', 'communication_rating', 'safety_rating']
        for field in required_fields:
            if not data.get(field):
                return jsonify({"error": f"{field} is required"}), 400
        
        # Validate ratings
        for rating_field in ['overall_rating', 'quality_rating', 'communication_rating', 'safety_rating']:
            rating = data.get(rating_field)
            if not isinstance(rating, int) or rating < 1 or rating > 5:
                return jsonify({"error": f"{rating_field} must be between 1 and 5"}), 400
        
        # Create review
        review = Review(
            reviewer_id=current_user_id,
            reviewee_id=reviewee_id,  # Auto-determined from contract
            job_id=contract.job_id,
            contract_id=contract_id,
            overall_rating=data['overall_rating'],
            quality_rating=data['quality_rating'],
            communication_rating=data['communication_rating'],
            safety_rating=data['safety_rating'],
            comment=data.get('comment'),
            would_work_again=data.get('would_work_again', True),
            verified_completion=data.get('verified_completion', False)
        )
        
        db.session.add(review)
        db.session.commit()
        
        # Check if both parties have now reviewed
        other_review = Review.query.filter_by(
            reviewer_id=reviewee_id,
            contract_id=contract_id
        ).first()
        
        if other_review:
            # Both parties have reviewed - update contract status to completed
            contract.mark_as_completed()  # Use method to properly set status, completion_status, and increment jobs_completed
            
            # TODO: Trigger payment release here
            db.session.commit()
        
        # Update reviewee's ratings
        reviewee = User.query.get(reviewee_id)
        if reviewee:
            # Recalculate average rating
            all_reviews = Review.query.filter_by(reviewee_id=reviewee.id).all()
            total_rating = sum(r.overall_rating for r in all_reviews)
            reviewee.total_reviews = len(all_reviews)
            reviewee.average_rating = total_rating / reviewee.total_reviews if reviewee.total_reviews > 0 else 0
        
        # Award points for giving review
        award_points(current_user_id, 'review_given', 25, 
                    f"Gave review for job {data['job_id']}")
        
        db.session.commit()
        
        return jsonify({
            "message": "Review created successfully",
            "review": {
                "id": review.id,
                "weighted_score": review.calculate_weighted_score(),
                "overall_rating": review.overall_rating
            }
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Review creation failed: {str(e)}"}), 500