# app/models/contract.py (create this file)
from datetime import datetime, date
from ..extensions import db
from .base import BaseModel


class Contract(BaseModel):
    """Independent contractor agreements (Fair Work Act compliant)"""
    __tablename__ = 'contracts'
    
    # Contract Parties
    job_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
    contractor_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    worker_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    
    # Contract Terms
    agreed_rate = db.Column(db.Numeric(10, 2), nullable=False)
    rate_type = db.Column(db.String(20), default='total', nullable=False)  # total, hourly, daily
    start_date = db.Column(db.Date, nullable=False)
    end_date = db.Column(db.Date, nullable=False)
    scope_of_work = db.Column(db.Text, nullable=False)
    
    # Australian Legal Requirements
    independent_contractor_status = db.Column(db.Boolean, default=True, nullable=False)
    superannuation_required = db.Column(db.Boolean, default=False, nullable=False)
    workers_comp_covered = db.Column(db.Boolean, default=False, nullable=False)
    
    # Contract Status
    status = db.Column(db.String(20), default='draft', nullable=False)
    # Status: 'draft', 'sent', 'signed', 'active', 'completed', 'terminated'
    contractor_signed = db.Column(db.Boolean, default=False, nullable=False)
    worker_signed = db.Column(db.Boolean, default=False, nullable=False)
    contractor_signed_date = db.Column(db.DateTime)
    worker_signed_date = db.Column(db.DateTime)
    
    # Payment Terms
    payment_terms = db.Column(db.String(50), default='completion', nullable=False)
    # Terms: 'completion', 'milestone', 'weekly', 'fortnightly'
    payment_schedule = db.Column(db.Text)  # JSON for milestone payments
    
    # Relationships
    job = db.relationship('Job', backref='contracts')
    contractor = db.relationship('User', foreign_keys=[contractor_id], backref='contractor_contracts')
    worker = db.relationship('User', foreign_keys=[worker_id], backref='worker_contracts')
    payments = db.relationship('Payment', backref='contract', lazy='dynamic', cascade='all, delete-orphan')
    
    def is_fully_signed(self):
        """Check if both parties have signed"""
        return self.contractor_signed and self.worker_signed
    
    def calculate_total_value(self):
        """Calculate total contract value including GST if applicable"""
        base_amount = float(self.agreed_rate)
        
        # Add GST if worker is GST registered
        if self.worker.gst_registered:
            gst_amount = base_amount * 0.10
            return base_amount + gst_amount
        
        return base_amount
    
    def get_contract_type(self):
        """Determine contract type for legal compliance"""
        # Simplified logic - in production would use more complex rules
        if self.agreed_rate > 20000 or (self.end_date - self.start_date).days > 30:
            return 'independent_contractor'
        return 'casual_contractor'
    
    def __repr__(self):
        return f'<Contract {self.id} - {self.status}>'


class Payment(BaseModel):
    """Escrow payment system for construction contracts"""
    __tablename__ = 'payments'
    
    # Payment Reference
    contract_id = db.Column(db.Integer, db.ForeignKey('contracts.id'), nullable=False)
    payment_reference = db.Column(db.String(50), unique=True, nullable=False)
    
    # Payment Amounts (all in AUD)
    gross_amount = db.Column(db.Numeric(10, 2), nullable=False)
    platform_fee = db.Column(db.Numeric(10, 2), nullable=False)
    gst_amount = db.Column(db.Numeric(10, 2), default=0, nullable=False)
    net_to_worker = db.Column(db.Numeric(10, 2), nullable=False)
    
    # Withholding Tax (for non-GST registered contractors)
    withholding_tax_rate = db.Column(db.Numeric(5, 4), default=0, nullable=False)
    withholding_tax_amount = db.Column(db.Numeric(10, 2), default=0, nullable=False)
    
    # Payment Status
    status = db.Column(db.String(20), default='pending', nullable=False)
    # Status: 'pending', 'held_escrow', 'released', 'refunded', 'disputed'
    
    # Payment Timeline
    date_initiated = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
    date_held_escrow = db.Column(db.DateTime)
    date_released = db.Column(db.DateTime)
    release_conditions_met = db.Column(db.Boolean, default=False, nullable=False)
    
    # Dispute Protection
    dispute_period_days = db.Column(db.Integer, default=7, nullable=False)
    dispute_deadline = db.Column(db.DateTime)
    
    # Relationships
    invoices = db.relationship('Invoice', backref='payment', lazy='dynamic', cascade='all, delete-orphan')
    
    def calculate_amounts(self):
        """Calculate all payment amounts based on contract"""
        contract = self.contract
        base_amount = float(contract.agreed_rate)
        
        # Platform fee (10%)
        self.platform_fee = base_amount * 0.10
        
        # GST calculation
        if contract.worker.gst_registered:
            self.gst_amount = base_amount * 0.10
            self.gross_amount = base_amount + self.gst_amount
        else:
            self.gst_amount = 0
            self.gross_amount = base_amount
            
            # Withholding tax for non-GST registered (simplified)
            self.withholding_tax_rate = 0.47  # 47% withholding rate
            self.withholding_tax_amount = base_amount * 0.47
        
        # Net amount to worker
        self.net_to_worker = self.gross_amount - self.platform_fee - self.withholding_tax_amount
    
    def can_be_released(self):
        """Check if payment can be released from escrow"""
        if self.status != 'held_escrow':
            return False
        
        # Check if dispute period has passed
        if self.dispute_deadline and datetime.utcnow() < self.dispute_deadline:
            return False
        
        return self.release_conditions_met
    
    def __repr__(self):
        return f'<Payment {self.payment_reference} - {self.status}>'


class Invoice(BaseModel):
    """GST-compliant invoices for Australian tax law"""
    __tablename__ = 'invoices'
    
    # Invoice Reference
    payment_id = db.Column(db.Integer, db.ForeignKey('payments.id'), nullable=False)
    invoice_number = db.Column(db.String(50), unique=True, nullable=False)
    
    # Invoice Details
    invoice_date = db.Column(db.Date, default=date.today, nullable=False)
    due_date = db.Column(db.Date, nullable=False)
    description = db.Column(db.Text, nullable=False)
    
    # GST Compliance (Australian Tax Office requirements)
    amount_ex_gst = db.Column(db.Numeric(10, 2), nullable=False)
    gst_amount = db.Column(db.Numeric(10, 2), nullable=False)
    total_amount = db.Column(db.Numeric(10, 2), nullable=False)
    gst_rate = db.Column(db.Numeric(5, 4), default=0.10, nullable=False)  # 10% GST
    
    # Business Details (for GST compliance)
    supplier_abn = db.Column(db.String(11), nullable=False)
    supplier_name = db.Column(db.String(200), nullable=False)
    buyer_abn = db.Column(db.String(11), nullable=False)
    buyer_name = db.Column(db.String(200), nullable=False)
    
    # Invoice Status
    status = db.Column(db.String(20), default='draft', nullable=False)
    # Status: 'draft', 'sent', 'paid', 'overdue', 'cancelled'
    
    def generate_invoice_number(self):
        """Generate unique invoice number"""
        import uuid
        year = date.today().year
        short_uuid = str(uuid.uuid4())[:8].upper()
        self.invoice_number = f"RR{year}-{short_uuid}"
    
    def validate_gst_compliance(self):
        """Validate invoice meets Australian GST requirements"""
        errors = []
        
        # ABN validation
        if not self.supplier_abn or len(self.supplier_abn) != 11:
            errors.append("Valid supplier ABN required")
        
        if not self.buyer_abn or len(self.buyer_abn) != 11:
            errors.append("Valid buyer ABN required")
        
        # Amount validation
        expected_gst = float(self.amount_ex_gst) * float(self.gst_rate)
        if abs(float(self.gst_amount) - expected_gst) > 0.01:
            errors.append("GST amount calculation error")
        
        expected_total = float(self.amount_ex_gst) + float(self.gst_amount)
        if abs(float(self.total_amount) - expected_total) > 0.01:
            errors.append("Total amount calculation error")
        
        return len(errors) == 0, errors
    
    def __repr__(self):
        return f'<Invoice {self.invoice_number} - ${self.total_amount}>'


# app/models/__init__.py (update this file)
from .base import BaseModel
from .user import User
from .category import Category
from .job import Job, Application
from .contract import Contract, Payment, Invoice

# Import all models for relationship setup
__all__ = ['BaseModel', 'User', 'Category', 'Job', 'Application', 'Contract', 'Payment', 'Invoice']


# app/utils/compliance.py (create this file)
"""Australian legal compliance utilities"""

def calculate_gst(amount):
    """Calculate GST (10% in Australia)"""
    return float(amount) * 0.10

def calculate_total_with_gst(amount):
    """Calculate total amount including GST"""
    gst = calculate_gst(amount)
    return float(amount) + gst

def calculate_withholding_tax(amount, abn_registered=True, gst_registered=False):
    """
    Calculate withholding tax for contractors
    Based on Australian Tax Office guidelines
    """
    if gst_registered:
        return 0  # No withholding tax for GST registered businesses
    
    if not abn_registered:
        return float(amount) * 0.47  # 47% withholding for no ABN
    
    # Standard withholding for ABN but no GST registration
    return float(amount) * 0.47

def generate_payment_reference():
    """Generate unique payment reference"""
    import uuid
    from datetime import datetime
    
    year = datetime.now().year
    month = datetime.now().month
    unique_id = str(uuid.uuid4())[:8].upper()
    
    return f"PAY{year}{month:02d}-{unique_id}"

def validate_contract_terms(start_date, end_date, amount):
    """Validate contract terms for Fair Work Act compliance"""
    errors = []
    
    # Date validation
    if end_date <= start_date:
        errors.append("End date must be after start date")
    
    # Minimum payment validation (simplified)
    if amount < 100:
        errors.append("Minimum contract value is $100")
    
    # Duration validation
    duration_days = (end_date - start_date).days
    if duration_days > 365:
        errors.append("Contracts over 1 year require additional legal review")
    
    return len(errors) == 0, errors


# app/blueprints/legal/__init__.py (create this file)
from flask import Blueprint

legal_bp = Blueprint('legal', __name__)

from . import routes


# app/blueprints/legal/routes.py (create this file)
from flask import request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from datetime import datetime, date, timedelta

from . import legal_bp
from ...models import Contract, Payment, Invoice, Job, User
from ...extensions import db
from ...utils.compliance import (
    calculate_gst, generate_payment_reference, 
    calculate_withholding_tax, validate_contract_terms
)


@legal_bp.route('/contracts', methods=['POST'])
@jwt_required()
def create_contract():
    """Create new contract between contractor and worker"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        # Validation
        required_fields = ['job_id', 'worker_id', 'agreed_rate', 'start_date', 'end_date', 'scope_of_work']
        for field in required_fields:
            if not data.get(field):
                return jsonify({"error": f"{field} is required"}), 400
        
        # Verify job ownership
        job = Job.query.get(data['job_id'])
        if not job or job.contractor_id != current_user_id:
            return jsonify({"error": "Job not found or unauthorized"}), 404
        
        # Verify worker exists
        worker = User.query.get(data['worker_id'])
        if not worker or worker.role != 'worker':
            return jsonify({"error": "Invalid worker"}), 400
        
        # Parse dates
        start_date = datetime.strptime(data['start_date'], '%Y-%m-%d').date()
        end_date = datetime.strptime(data['end_date'], '%Y-%m-%d').date()
        
        # Validate contract terms
        is_valid, validation_errors = validate_contract_terms(
            start_date, end_date, float(data['agreed_rate'])
        )
        if not is_valid:
            return jsonify({"error": "Contract validation failed", "details": validation_errors}), 400
        
        # Create contract
        contract = Contract(
            job_id=data['job_id'],
            contractor_id=current_user_id,
            worker_id=data['worker_id'],
            agreed_rate=data['agreed_rate'],
            rate_type=data.get('rate_type', 'total'),
            start_date=start_date,
            end_date=end_date,
            scope_of_work=data['scope_of_work'],
            payment_terms=data.get('payment_terms', 'completion'),
            payment_schedule=data.get('payment_schedule')
        )
        
        db.session.add(contract)
        db.session.commit()
        
        return jsonify({
            "message": "Contract created successfully",
            "contract": {
                "id": contract.id,
                "job_id": contract.job_id,
                "agreed_rate": float(contract.agreed_rate),
                "start_date": contract.start_date.isoformat(),
                "end_date": contract.end_date.isoformat(),
                "status": contract.status,
                "total_value": contract.calculate_total_value()
            }
        }), 201
        
    except ValueError as e:
        return jsonify({"error": f"Invalid date format: {str(e)}"}), 400
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Contract creation failed: {str(e)}"}), 500


@legal_bp.route('/contracts/<int:contract_id>/sign', methods=['PUT'])
@jwt_required()
def sign_contract(contract_id):
    """Sign contract (contractor or worker)"""
    try:
        current_user_id = get_jwt_identity()
        contract = Contract.query.get_or_404(contract_id)
        
        # Check authorization
        if current_user_id not in [contract.contractor_id, contract.worker_id]:
            return jsonify({"error": "Unauthorized to sign this contract"}), 403
        
        # Sign contract
        if contract.contractor_id == current_user_id:
            contract.contractor_signed = True
            contract.contractor_signed_date = datetime.utcnow()
        elif contract.worker_id == current_user_id:
            contract.worker_signed = True
            contract.worker_signed_date = datetime.utcnow()
        
        # Update status if both signed
        if contract.is_fully_signed():
            contract.status = 'signed'
        
        db.session.commit()
        
        return jsonify({
            "message": "Contract signed successfully",
            "contract_status": contract.status,
            "fully_signed": contract.is_fully_signed()
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Contract signing failed: {str(e)}"}), 500


@legal_bp.route('/payments', methods=['POST'])
@jwt_required()
def initiate_payment():
    """Initiate escrow payment for contract"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        if not data.get('contract_id'):
            return jsonify({"error": "contract_id is required"}), 400
        
        contract = Contract.query.get(data['contract_id'])
        if not contract or contract.contractor_id != current_user_id:
            return jsonify({"error": "Contract not found or unauthorized"}), 404
        
        if not contract.is_fully_signed():
            return jsonify({"error": "Contract must be fully signed before payment"}), 400
        
        # Create payment
        payment = Payment(
            contract_id=contract.id,
            payment_reference=generate_payment_reference()
        )
        
        # Calculate payment amounts
        payment.calculate_amounts()
        
        # Set escrow hold period
        payment.date_held_escrow = datetime.utcnow()
        payment.dispute_deadline = datetime.utcnow() + timedelta(days=payment.dispute_period_days)
        payment.status = 'held_escrow'
        
        db.session.add(payment)
        db.session.commit()
        
        return jsonify({
            "message": "Payment initiated and held in escrow",
            "payment": {
                "id": payment.id,
                "payment_reference": payment.payment_reference,
                "gross_amount": float(payment.gross_amount),
                "platform_fee": float(payment.platform_fee),
                "gst_amount": float(payment.gst_amount),
                "withholding_tax": float(payment.withholding_tax_amount),
                "net_to_worker": float(payment.net_to_worker),
                "status": payment.status,
                "dispute_deadline": payment.dispute_deadline.isoformat()
            }
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Payment initiation failed: {str(e)}"}), 500


@legal_bp.route('/invoices', methods=['POST'])
@jwt_required()
def generate_invoice():
    """Generate GST-compliant invoice"""
    try:
        current_user_id = get_jwt_identity()
        data = request.get_json()
        
        if not data.get('payment_id'):
            return jsonify({"error": "payment_id is required"}), 400
        
        payment = Payment.query.get(data['payment_id'])
        if not payment:
            return jsonify({"error": "Payment not found"}), 404
        
        contract = payment.contract
        
        # Check if user is the worker (invoice issuer)
        if contract.worker_id != current_user_id:
            return jsonify({"error": "Only the worker can generate invoices"}), 403
        
        # Check if worker is GST registered
        worker = User.query.get(contract.worker_id)
        if not worker.gst_registered:
            return jsonify({"error": "Worker must be GST registered to issue invoices"}), 400
        
        # Create invoice
        invoice = Invoice(
            payment_id=payment.id,
            description=f"Construction services for {contract.job.title}",
            due_date=date.today() + timedelta(days=30),
            amount_ex_gst=float(contract.agreed_rate),
            gst_amount=calculate_gst(contract.agreed_rate),
            total_amount=calculate_total_with_gst(contract.agreed_rate),
            supplier_abn=worker.abn_number,
            supplier_name=worker.business_name or f"{worker.first_name} {worker.last_name}",
            buyer_abn=contract.contractor.abn_number,
            buyer_name=contract.contractor.business_name or f"{contract.contractor.first_name} {contract.contractor.last_name}"
        )
        
        invoice.generate_invoice_number()
        
        # Validate GST compliance
        is_compliant, compliance_errors = invoice.validate_gst_compliance()
        if not is_compliant:
            return jsonify({"error": "Invoice GST compliance failed", "details": compliance_errors}), 400
        
        db.session.add(invoice)
        db.session.commit()
        
        return jsonify({
            "message": "GST invoice generated successfully",
            "invoice": {
                "id": invoice.id,
                "invoice_number": invoice.invoice_number,
                "amount_ex_gst": float(invoice.amount_ex_gst),
                "gst_amount": float(invoice.gst_amount),
                "total_amount": float(invoice.total_amount),
                "due_date": invoice.due_date.isoformat(),
                "supplier_abn": invoice.supplier_abn,
                "buyer_abn": invoice.buyer_abn
            }
        }), 201
        
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": f"Invoice generation failed: {str(e)}"}), 500


@legal_bp.route('/validate-abn', methods=['POST'])
def validate_abn():
    """Validate Australian Business Number"""
    try:
        data = request.get_json()
        abn = data.get('abn')
        
        if not abn:
            return jsonify({"error": "ABN is required"}), 400
        
        from ...utils.validators import validate_australian_business_number
        is_valid = validate_australian_business_number(abn)
        
        # Check if ABN is registered with a user
        user = User.query.filter_by(abn_number=abn).first()
        gst_registered = user.gst_registered if user else False
        
        # Calculate withholding tax requirement
        withholding_required = not gst_registered
        
        return jsonify({
            "abn": abn,
            "is_valid": is_valid,
            "gst_registered": gst_registered,
            "withholding_tax_required": withholding_required,
            "registered_user": bool(user)
        })
        
    except Exception as e:
        return jsonify({"error": f"ABN validation failed: {str(e)}"}), 500


# app/__init__.py (update to register legal blueprint)
from flask import Flask
from flask_cors import CORS

def create_app():
    """Application factory for RateRight construction marketplace"""
    app = Flask(__name__)
    
    # Load configuration
    from .config import Config
    app.config.from_object(Config)
    
    # Initialize extensions
    from .extensions import db, jwt, migrate
    db.init_app(app)
    jwt.init_app(app)
    migrate.init_app(app, db)
    CORS(app)
    
    # Configure JWT handlers
    configure_jwt_handlers(jwt)
    
    # Register blueprints
    register_blueprints(app)
    
    return app

def configure_jwt_handlers(jwt):
    """Configure JWT error handlers"""
    from flask import jsonify
    
    @jwt.expired_token_loader
    def expired_token_callback(jwt_header, jwt_payload):
        return jsonify({"error": "Token has expired"}), 401

    @jwt.invalid_token_loader
    def invalid_token_callback(error):
        return jsonify({"error": "Invalid token"}), 401

    @jwt.unauthorized_loader
    def missing_token_callback(error):
        return jsonify({"error": "Authorization token is required"}), 401

def register_blueprints(app):
    """Register application blueprints"""
    from .blueprints.auth import auth_bp
    from .blueprints.marketplace import marketplace_bp
    from .blueprints.legal import legal_bp
    
    # Register blueprints with prefixes
    app.register_blueprint(auth_bp, url_prefix='/api/auth')
    app.register_blueprint(marketplace_bp, url_prefix='/api/marketplace')
    app.register_blueprint(legal_bp, url_prefix='/api/legal')
    
    # Basic routes
    @app.route('/')
    def home():
        return {
            "service": "RateRight Australian Construction Marketplace",
            "status": "running",
            "version": "1.0.0",
            "endpoints": {
                "auth": "/api/auth/*",
                "marketplace": "/api/marketplace/*", 
                "legal": "/api/legal/*",
                "health": "/api/health"
            }
        }
    
    @app.route('/api/health')
    def health_check():
        from datetime import datetime
        return {
            "status": "healthy",
            "service": "RateRight",
            "database": "connected",
            "timestamp": datetime.utcnow().isoformat(),
            "features": app.config.get('FEATURES', {}),
            "models": ["User", "Category", "Job", "Application", "Contract", "Payment", "Invoice"],
            "legal_compliance": {
                "fair_work_act": True,
                "gst_invoicing": True,
                "abn_validation": True,
                "escrow_payments": True
            }
        }


# test_chunk4.py (create this file)
"""Test Chunk 4: Contract Management and Payment System"""

def test_chunk4():
    """Test contract and payment models with legal compliance"""
    print("Testing Chunk 4: Contract Management + Payments")
    
    try:
        from app import create_app
        from app.models import Contract, Payment, Invoice
        from app.extensions import db
        from app.utils.compliance import calculate_gst, generate_payment_reference
        
        app = create_app()
        
        with app.app_context():
            # Create tables
            db.create_all()
            print("✅ Database tables created (contracts, payments, invoices)")
            
            # Test utilities
            gst = calculate_gst(1000)
            assert gst == 100.0
            print("✅ GST calculation works (10%)")
            
            payment_ref = generate_payment_reference()
            assert len(payment_ref) > 10
            print("✅ Payment reference generation works")
            
            # Test blueprint registration
            client = app.test_client()
            
            # Test legal endpoints
            response = client.post('/api/legal/validate-abn', 
                                  json={'abn': '12345678901'})
            assert response.status_code == 200
            print("✅ ABN validation endpoint works")
            
            # Test health check shows new models
            response = client.get('/api/health')
            data = response.get_json()
            assert 'Contract' in data['models']
            assert 'Payment' in data['models']
            assert 'Invoice' in data['models']
            print("✅ Health check shows contract/payment models")
            
            print("\n🎉 CHUNK 4 COMPLETE!")
            print("📄 New models: Contract, Payment, Invoice")
            print("⚖️  Legal blueprint: /api/legal/*")
            print("🇦🇺 Australian compliance: Fair Work Act, GST, ABN")
            print("💰 Escrow payments with dispute protection")
            print("📊 GST-compliant invoicing system")
            
            return True
            
    except Exception as e:
        print(f"❌ Error: {e}")
        import traceback
        traceback.print_exc()
        return False

if __name__ == "__main__":
    test_chunk4()