#!/usr/bin/env python
"""
Production Database Initialization Script for Fly.io
Works in /app directory and handles both empty and partial database states
"""

import os
import sys
from datetime import datetime, timezone

# Add the app directory to Python path for Fly.io environment
sys.path.insert(0, '/app')

# Try alternative import methods for production environment
try:
    from app import create_app
    from app.extensions import db
    from app.models.category import Category
    from app.models.user import User
    print("✓ Successfully imported app modules")
except ImportError as e1:
    print(f"Standard import failed: {e1}")
    try:
        # Try without 'app' prefix if we're already in app directory
        from extensions import db
        from models.category import Category
        from models.user import User
        from __init__ import create_app
        print("✓ Successfully imported modules without app prefix")
    except ImportError as e2:
        print(f"Alternative import failed: {e2}")
        print("Attempting direct Flask app creation...")
        
        # Fallback: Create minimal Flask app
        from flask import Flask
        from flask_sqlalchemy import SQLAlchemy
        
        app = Flask(__name__)
        app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', '').replace('postgres://', 'postgresql://')
        app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
        db = SQLAlchemy(app)
        
        class Category(db.Model):
            __tablename__ = "categories"
            id = db.Column(db.Integer, primary_key=True)
            name = db.Column(db.String(100), unique=True, nullable=False)
            description = db.Column(db.Text)
            whs_risk_level = db.Column(db.String(20), default="medium", nullable=False)
            insurance_requirements = db.Column(db.Text)
            license_required = db.Column(db.Boolean, default=False, nullable=False)
            white_card_required = db.Column(db.Boolean, default=True, nullable=False)
            is_active = db.Column(db.Boolean, default=True, nullable=False)
            sort_order = db.Column(db.Integer, default=0, nullable=False)
            created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
            updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))

def init_database():
    """Initialize database with tables and default data"""
    
    print("\n" + "="*60)
    print("PRODUCTION DATABASE INITIALIZATION")
    print("="*60)
    
    try:
        # Create Flask app context
        if 'create_app' in globals():
            app = create_app()
            print("✓ Flask app created")
        else:
            print("✓ Using fallback Flask app")
        
        with app.app_context():
            # Step 1: Create all tables
            print("\n1. Creating database tables...")
            try:
                db.create_all()
                print("✓ Database tables created successfully")
            except Exception as e:
                print(f"⚠ Warning creating tables: {e}")
                print("  Tables may already exist, continuing...")
            
            # Step 2: Check existing categories
            print("\n2. Checking existing categories...")
            existing_count = 0
            try:
                existing_count = Category.query.count()
                print(f"  Found {existing_count} existing categories")
            except Exception as e:
                print(f"  Could not query categories: {e}")
            
            # Step 3: Add default categories if needed
            if existing_count == 0:
                print("\n3. Adding default categories...")
                
                categories = [
                    {
                        'name': 'General Labor',
                        'description': 'General construction and labor work',
                        'whs_risk_level': 'low',
                        'insurance_requirements': 'Public liability insurance required',
                        'license_required': False,
                        'white_card_required': True,
                        'sort_order': 1
                    },
                    {
                        'name': 'Renovation',
                        'description': 'Kitchen, bathroom, and home renovations',
                        'whs_risk_level': 'medium',
                        'insurance_requirements': 'Public liability and contract works insurance',
                        'license_required': True,
                        'white_card_required': True,
                        'sort_order': 2
                    },
                    {
                        'name': 'Electrical',
                        'description': 'Electrical installations and repairs',
                        'whs_risk_level': 'high',
                        'insurance_requirements': 'Professional indemnity and public liability',
                        'license_required': True,
                        'white_card_required': True,
                        'sort_order': 3
                    },
                    {
                        'name': 'Plumbing',
                        'description': 'Plumbing installations and repairs',
                        'whs_risk_level': 'high',
                        'insurance_requirements': 'Professional indemnity and public liability',
                        'license_required': True,
                        'white_card_required': True,
                        'sort_order': 4
                    },
                    {
                        'name': 'Carpentry',
                        'description': 'Carpentry and woodwork',
                        'whs_risk_level': 'medium',
                        'insurance_requirements': 'Public liability insurance',
                        'license_required': True,
                        'white_card_required': True,
                        'sort_order': 5
                    },
                    {
                        'name': 'Painting',
                        'description': 'Interior and exterior painting',
                        'whs_risk_level': 'low',
                        'insurance_requirements': 'Public liability insurance',
                        'license_required': False,
                        'white_card_required': True,
                        'sort_order': 6
                    },
                    {
                        'name': 'Landscaping',
                        'description': 'Garden and landscape work',
                        'whs_risk_level': 'low',
                        'insurance_requirements': 'Public liability insurance',
                        'license_required': False,
                        'white_card_required': False,
                        'sort_order': 7
                    },
                    {
                        'name': 'Roofing',
                        'description': 'Roof installation and repairs',
                        'whs_risk_level': 'extreme',
                        'insurance_requirements': 'Comprehensive insurance required',
                        'license_required': True,
                        'white_card_required': True,
                        'sort_order': 8
                    }
                ]
                
                added = 0
                for cat_data in categories:
                    try:
                        # Check if category already exists
                        existing = Category.query.filter_by(name=cat_data['name']).first()
                        if not existing:
                            category = Category(**cat_data)
                            db.session.add(category)
                            added += 1
                            print(f"  ✓ Added: {cat_data['name']} ({cat_data['whs_risk_level']} risk)")
                        else:
                            print(f"  - Skipped: {cat_data['name']} (already exists)")
                    except Exception as e:
                        print(f"  ✗ Error adding {cat_data['name']}: {e}")
                
                # Commit all categories
                try:
                    db.session.commit()
                    print(f"\n✓ Successfully added {added} categories")
                except Exception as e:
                    print(f"\n✗ Error committing categories: {e}")
                    db.session.rollback()
            else:
                print("  Categories already exist, skipping...")
            
            # Step 4: Verify database state
            print("\n4. Verifying database state...")
            
            # List all tables
            try:
                from sqlalchemy import inspect
                inspector = inspect(db.engine)
                tables = inspector.get_table_names()
                print(f"  Tables in database: {', '.join(tables)}")
                
                # Count records in key tables
                table_counts = {}
                for table in ['categories', 'users', 'jobs', 'contracts', 'ratings']:
                    if table in tables:
                        try:
                            result = db.session.execute(f"SELECT COUNT(*) FROM {table}")
                            count = result.scalar()
                            table_counts[table] = count
                        except:
                            table_counts[table] = 'error'
                
                print("\n  Record counts:")
                for table, count in table_counts.items():
                    print(f"    - {table}: {count}")
                
            except Exception as e:
                print(f"  Could not inspect database: {e}")
            
            print("\n" + "="*60)
            print("DATABASE INITIALIZATION COMPLETE")
            print("="*60)
            
            return True
            
    except Exception as e:
        print(f"\n✗ CRITICAL ERROR: {e}")
        import traceback
        traceback.print_exc()
        return False

if __name__ == "__main__":
    success = init_database()
    sys.exit(0 if success else 1)
