# requirements.txt
Flask==2.3.3
Flask-SQLAlchemy==3.0.5
Flask-JWT-Extended==4.5.3
Flask-CORS==4.0.0
Flask-Migrate==4.0.5
Werkzeug==2.3.7
SQLAlchemy==2.0.21
python-dotenv==1.0.0

# app/__init__.py - Application Factory
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 (will add in future chunks)
    register_blueprints(app)
    
    return app


def configure_jwt_handlers(jwt):
    """Configure JWT error handlers for authentication"""
    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 - will populate in later chunks"""
    # Basic health check for now
    @app.route('/api/health')
    def health_check():
        from datetime import datetime
        return {
            "status": "healthy",
            "service": "RateRight Australian Construction Marketplace",
            "database": "connected",
            "timestamp": datetime.utcnow().isoformat(),
            "features": app.config['FEATURES']
        }


# app/extensions.py - Flask Extensions
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager
from flask_migrate import Migrate

# Initialize extensions
db = SQLAlchemy()
jwt = JWTManager()
migrate = Migrate()


# app/config.py - Australian Construction Marketplace Configuration
import os
from datetime import timedelta

class Config:
    """Base configuration for RateRight marketplace"""
    
    # Flask Configuration
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'rateright-dev-key-change-in-production'
    
    # Database Configuration (connect to existing database)
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'sqlite:///rateright.db'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    
    # JWT Configuration
    JWT_SECRET_KEY = os.environ.get('JWT_SECRET_KEY') or SECRET_KEY
    JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=24)
    
    # Australian Construction Marketplace Features
    FEATURES = {
        # Core Marketplace
        'job_marketplace': True,
        'contract_management': True,
        'payment_escrow': True,
        
        # Legal Compliance (Australian Law)
        'abn_validation': True,
        'gst_invoicing': True,
        'whs_act_2011': True,
        'fair_work_act': True,
        
        # Safety & Trust Systems
        'whs_assessments': True,
        'insurance_verification': True,
        'dispute_mediation': True,
        'review_system': True,
        
        # Gamification (80/20 engagement system)
        'gamification_leaderboards': True,
        'achievement_badges': True, 
        'seasonal_competitions': True,
        'point_activities': True,
        
        # Advanced Features
        'advanced_whs': True,
        'audit_logging': True,
        'premium_subscriptions': False
    }
    
    # Australian Business Configuration
    BUSINESS = {
        'country': 'Australia',
        'gst_rate': 0.10,  # 10% GST
        'platform_commission': 0.10,  # 10% platform fee
        'currency': 'AUD',
        'min_insurance_amount': 1000000,  # $1M minimum public liability
        'abn_validation_required': True
    }


class DevelopmentConfig(Config):
    """Development configuration"""
    DEBUG = True
    SQLALCHEMY_ECHO = True  # Show SQL queries in development


class ProductionConfig(Config):
    """Production configuration"""
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')
    
    # Production security
    JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=8)  # Shorter tokens in production


class TestingConfig(Config):
    """Testing configuration"""
    TESTING = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
    WTF_CSRF_ENABLED = False


# Configuration dictionary
config = {
    'development': DevelopmentConfig,
    'production': ProductionConfig,
    'testing': TestingConfig,
    'default': DevelopmentConfig
}


# run.py - Development Server Entry Point
import os
from app import create_app

# Get configuration from environment
config_name = os.getenv('FLASK_ENV', 'development')

# Create Flask application
app = create_app()

if __name__ == '__main__':
    print("🏗️  RateRight - Australian Construction Marketplace")
    print("📋 Starting Flask development server...")
    print(f"🔧 Configuration: {config_name}")
    print(f"🗄️  Database: {app.config['SQLALCHEMY_DATABASE_URI']}")
    print(f"🎮 Gamification: {app.config['FEATURES']['gamification_leaderboards']}")
    print(f"⚖️  Legal Compliance: {app.config['FEATURES']['abn_validation']}")
    print(f"🛡️  Safety Systems: {app.config['FEATURES']['whs_act_2011']}")
    print("\n🚀 Server starting on http://localhost:5000")
    print("📍 Health check: http://localhost:5000/api/health")
    
    app.run(debug=True, host='0.0.0.0', port=5000)