from datetime import datetime, date
from ..extensions import db
from .base import BaseModel


class WHSAssessment(BaseModel):
    """WHS Act 2011 compliance assessments for construction jobs"""
    __tablename__ = 'whs_assessments'
    
    # Assessment Reference
    job_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
    assessment_reference = db.Column(db.String(50), unique=True, nullable=False)
    
    # Risk Assessment (WHS Act 2011 requirements)
    risk_assessment = db.Column(db.Text, nullable=False)
    hazard_identification = db.Column(db.Text, nullable=False)
    risk_control_measures = db.Column(db.Text, nullable=False)
    
    # Safety Documentation
    safety_plan_accepted = db.Column(db.Boolean, default=False, nullable=False)
    safety_induction_completed = db.Column(db.Boolean, default=False, nullable=False)
    emergency_procedures_briefed = db.Column(db.Boolean, default=False, nullable=False)
    
    # Insurance and Certification Verification
    insurance_verified = db.Column(db.Boolean, default=False, nullable=False)
    white_card_verified = db.Column(db.Boolean, default=False, nullable=False)
    license_verification = db.Column(db.Text)  # JSON of verified licenses
    
    # Incident Reporting
    incident_report = db.Column(db.Text)
    incidents_count = db.Column(db.Integer, default=0, nullable=False)
    near_miss_count = db.Column(db.Integer, default=0, nullable=False)
    
    # Assessment Status
    status = db.Column(db.String(20), default='pending', nullable=False)
    # Status: 'pending', 'approved', 'requires_action', 'failed'
    
    # Assessment Personnel
    completed_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    approved_by = db.Column(db.Integer, db.ForeignKey('users.id'))
    
    # Relationships
    job = db.relationship('Job', backref='whs_assessments')
    assessor = db.relationship('User', foreign_keys=[completed_by], backref='conducted_assessments')
    approver = db.relationship('User', foreign_keys=[approved_by], backref='approved_assessments')
    
    def generate_assessment_reference(self):
        """Generate unique assessment reference"""
        import uuid
        year = date.today().year
        unique_id = str(uuid.uuid4())[:8].upper()
        self.assessment_reference = f"WHS{year}-{unique_id}"
    
    def calculate_compliance_score(self):
        """Calculate WHS compliance score percentage"""
        checks = [
            self.safety_plan_accepted,
            self.safety_induction_completed,
            self.emergency_procedures_briefed,
            self.insurance_verified,
            self.white_card_verified,
            len(self.risk_assessment or '') > 50,
            len(self.hazard_identification or '') > 50,
            len(self.risk_control_measures or '') > 50
        ]
        return (sum(checks) / len(checks)) * 100
    
    def is_compliant(self):
        """Check if assessment meets WHS Act 2011 minimum requirements"""
        return (self.safety_plan_accepted and 
                self.insurance_verified and
                self.white_card_verified and
                self.status == 'approved' and
                self.incidents_count == 0)
    
    def __repr__(self):
        return f'<WHSAssessment {self.assessment_reference} - {self.status}>'


class JobProgress(BaseModel):
    """Construction job progress tracking with safety milestones"""
    __tablename__ = 'job_progress'
    
    # Progress Reference
    job_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
    contract_id = db.Column(db.Integer, db.ForeignKey('contracts.id'), nullable=False)
    
    # Progress Details
    status = db.Column(db.String(20), nullable=False)
    # Status: 'not_started', 'in_progress', 'completed', 'on_hold', 'cancelled'
    
    progress_percentage = db.Column(db.Integer, default=0, nullable=False)
    milestone_description = db.Column(db.String(200))
    
    # Timeline
    start_date = db.Column(db.Date)
    actual_completion_date = db.Column(db.Date)
    estimated_completion_date = db.Column(db.Date)
    
    # Progress Notes
    worker_notes = db.Column(db.Text)
    contractor_notes = db.Column(db.Text)
    photos_urls = db.Column(db.Text)  # JSON array of photo URLs
    
    # Safety Compliance During Work
    safety_incidents_reported = db.Column(db.Integer, default=0, nullable=False)
    safety_compliance_maintained = db.Column(db.Boolean, default=True, nullable=False)
    daily_safety_checks_completed = db.Column(db.Boolean, default=False, nullable=False)
    
    # Record Keeping
    updated_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    
    # Relationships
    job = db.relationship('Job', backref='progress_records')
    contract = db.relationship('Contract', backref='progress_records')
    updater = db.relationship('User', backref='progress_updates')
    
    def get_timeline_status(self):
        """Get timeline status vs estimated completion"""
        if not self.estimated_completion_date:
            return 'no_estimate'
        
        today = date.today()
        if today > self.estimated_completion_date and self.status != 'completed':
            return 'overdue'
        elif today == self.estimated_completion_date:
            return 'due_today'
        else:
            return 'on_track'
    
    def __repr__(self):
        return f'<JobProgress {self.job_id} - {self.progress_percentage}%>'


class Review(BaseModel):
    """Trust system reviews between contractors and workers"""
    __tablename__ = 'reviews'
    
    # Review Parties
    reviewer_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    reviewee_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    job_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
    contract_id = db.Column(db.Integer, db.ForeignKey('contracts.id'))
    
    # Review Content
    overall_rating = db.Column(db.Integer, nullable=False)  # 1-5 stars
    quality_rating = db.Column(db.Integer, nullable=False)  # 1-5 stars
    communication_rating = db.Column(db.Integer, nullable=False)  # 1-5 stars
    safety_rating = db.Column(db.Integer, nullable=False)  # 1-5 stars
    
    comment = db.Column(db.Text)
    would_work_again = db.Column(db.Boolean, default=True, nullable=False)
    
    # Review Verification
    verified_completion = db.Column(db.Boolean, default=False, nullable=False)
    
    # Relationships
    reviewer = db.relationship('User', foreign_keys=[reviewer_id], backref='reviews_given')
    reviewee = db.relationship('User', foreign_keys=[reviewee_id], backref='reviews_received')
    job = db.relationship('Job', backref='reviews')
    
    def calculate_weighted_score(self):
        """Calculate weighted average score (safety weighted higher)"""
        weights = {
            'overall': 0.3,
            'quality': 0.25,
            'communication': 0.2,
            'safety': 0.25  # Safety weighted equally with quality
        }
        
        weighted_score = (
            self.overall_rating * weights['overall'] +
            self.quality_rating * weights['quality'] +
            self.communication_rating * weights['communication'] +
            self.safety_rating * weights['safety']
        )
        
        return round(weighted_score, 2)
    
    def __repr__(self):
        return f'<Review {self.overall_rating}★ - Job {self.job_id}>'


class Dispute(BaseModel):
    """Dispute resolution system for contract conflicts"""
    __tablename__ = 'disputes'
    
    # Dispute Reference
    contract_id = db.Column(db.Integer, db.ForeignKey('contracts.id'), nullable=False)
    dispute_reference = db.Column(db.String(50), unique=True, nullable=False)
    
    # Dispute Details
    dispute_type = db.Column(db.String(50), nullable=False)
    # Types: 'payment', 'quality', 'safety', 'timeline', 'scope'
    
    raised_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    description = db.Column(db.Text, nullable=False)
    
    # Resolution
    status = db.Column(db.String(20), default='open', nullable=False)
    # Status: 'open', 'investigating', 'mediation', 'resolved', 'escalated'
    
    resolution_notes = db.Column(db.Text)
    resolved_by = db.Column(db.Integer, db.ForeignKey('users.id'))
    resolved_at = db.Column(db.DateTime)
    
    # Relationships
    contract = db.relationship('Contract', backref='disputes')
    disputer = db.relationship('User', foreign_keys=[raised_by], backref='raised_disputes')
    resolver = db.relationship('User', foreign_keys=[resolved_by], backref='resolved_disputes')
    
    def __repr__(self):
        return f'<Dispute {self.dispute_reference} - {self.status}>'


class AuditLog(BaseModel):
    """System audit trail for compliance and security"""
    __tablename__ = 'audit_logs'
    
    # Audit Reference
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
    action_type = db.Column(db.String(50), nullable=False)
    resource_type = db.Column(db.String(50), nullable=False)
    resource_id = db.Column(db.Integer)
    
    # Action Details
    action_description = db.Column(db.Text, nullable=False)
    ip_address = db.Column(db.String(45))
    user_agent = db.Column(db.Text)
    
    # Metadata
    before_state = db.Column(db.Text)  # JSON
    after_state = db.Column(db.Text)   # JSON
    
    # Relationships
    user = db.relationship('User', backref='audit_logs')
    
    def __repr__(self):
        return f'<AuditLog {self.action_type} - {self.resource_type}>'