"""Car service for managing rental vehicles."""
from flask import current_app
from app import db
from app.models import Car, CarImage, CarStatus, User
from app.services.image_service import delete_image, MAX_PHOTOS_PER_PROPERTY
import uuid


def create_car(owner_id, car_data, images_data=None):
    """
    Create a new car listing.
    
    Args:
        owner_id: UUID of owner
        car_data: Dictionary with car details
        images_data: List of image URLs (optional)
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': dict/None}
    """
    owner = User.query.filter_by(id=str(owner_id)).first()
    if not owner:
        return {'success': False, 'message': 'Owner not found', 'data': None}
    
    # Validate image count
    if images_data and len(images_data) > MAX_PHOTOS_PER_PROPERTY:
        return {
            'success': False,
            'message': f'Maximum {MAX_PHOTOS_PER_PROPERTY} photos allowed per car',
            'data': None
        }
    
    try:
        car = Car(
            owner_id=owner_id,
            title=car_data.get('title'),
            description=car_data.get('description'),
            make=car_data.get('make'),
            model=car_data.get('model'),
            year=car_data.get('year'),
            category=car_data.get('category'),
            color=car_data.get('color'),
            license_plate=car_data.get('license_plate'),
            seats=car_data.get('seats'),
            transmission=car_data.get('transmission'),
            fuel_type=car_data.get('fuel_type'),
            mileage=car_data.get('mileage'),
            engine_capacity=car_data.get('engine_capacity'),
            price_per_day=car_data.get('price_per_day'),
            price_per_week=car_data.get('price_per_week'),
            price_per_month=car_data.get('price_per_month'),
            price_per_year=car_data.get('price_per_year'),
            currency=car_data.get('currency', 'USD'),
            security_deposit=car_data.get('security_deposit'),
            city=car_data.get('city'),
            country=car_data.get('country'),
            pickup_location=car_data.get('pickup_location'),
            latitude=car_data.get('latitude'),
            longitude=car_data.get('longitude'),
            features=car_data.get('features', []),
            insurance_included=car_data.get('insurance_included', False),
            fuel_policy=car_data.get('fuel_policy'),
            minimum_age=car_data.get('minimum_age', 21),
            driving_license_required=car_data.get('driving_license_required', True),
            rental_terms=car_data.get('rental_terms'),
            status=CarStatus.ACTIVE
        )
        
        db.session.add(car)
        db.session.flush()
        
        if images_data:
            for img_data in images_data:
                image = CarImage(
                    car_id=car.id,
                    image_url=img_data.get('image_url'),
                    is_primary=img_data.get('is_primary', False),
                    display_order=img_data.get('display_order', 0),
                    caption=img_data.get('caption')
                )
                db.session.add(image)
        
        db.session.commit()
        
        return {
            'success': True,
            'message': 'Car created successfully',
            'data': car.to_dict_owner()
        }
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Car creation error: {str(e)}")
        return {'success': False, 'message': f'Failed to create car: {str(e)}', 'data': None}


def get_car_by_id(car_id, user_id=None):
    """
    Get car by ID with appropriate detail level.
    
    Args:
        car_id: UUID of car
        user_id: UUID of requesting user (optional)
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': dict/None}
    """
    car = Car.query.filter_by(id=str(car_id)).first()
    
    if not car:
        return {'success': False, 'message': 'Car not found', 'data': None}
    
    if user_id and str(car.owner_id) == str(user_id):
        data = car.to_dict_owner()
    else:
        data = car.to_dict_detail()
    
    return {'success': True, 'message': 'Car retrieved successfully', 'data': data}


def get_cars(filters=None, page=1, per_page=20):
    """
    Get list of cars with filters and pagination.
    
    Args:
        filters: Dictionary with filter criteria
        page: Page number
        per_page: Items per page
        
    Returns:
        dict: {'success': bool, 'data': dict with cars and pagination}
    """
    query = Car.query.filter(
        Car.is_available == True,
        Car.status == CarStatus.ACTIVE
    )
    
    if filters:
        if filters.get('city'):
            query = query.filter(Car.city.ilike(f"%{filters['city']}%"))
        
        if filters.get('country'):
            query = query.filter(Car.country.ilike(f"%{filters['country']}%"))
        
        if filters.get('make'):
            query = query.filter(Car.make.ilike(f"%{filters['make']}%"))
        
        if filters.get('category'):
            query = query.filter_by(category=filters['category'])
        
        if filters.get('min_price'):
            query = query.filter(Car.price_per_day >= filters['min_price'])
        if filters.get('max_price'):
            query = query.filter(Car.price_per_day <= filters['max_price'])
        
        if filters.get('min_year'):
            query = query.filter(Car.year >= filters['min_year'])
        if filters.get('max_year'):
            query = query.filter(Car.year <= filters['max_year'])
        
        if filters.get('transmission'):
            query = query.filter_by(transmission=filters['transmission'])
        
        if filters.get('fuel_type'):
            query = query.filter_by(fuel_type=filters['fuel_type'])
        
        if filters.get('seats'):
            query = query.filter(Car.seats >= filters['seats'])
    
    pagination = query.paginate(page=page, per_page=per_page, error_out=False)
    cars = [car.to_dict_public() for car in pagination.items]
    
    return {
        'success': True,
        'data': {
            'cars': cars,
            'total': pagination.total,
            'page': page,
            'per_page': per_page,
            'pages': pagination.pages,
            'has_next': pagination.has_next,
            'has_prev': pagination.has_prev
        }
    }


def get_user_cars(owner_id):
    """
    Get all cars owned by a user.
    
    Args:
        owner_id: UUID of owner
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': list}
    """
    cars = Car.query.filter_by(owner_id=str(owner_id)).all()
    
    return {
        'success': True,
        'message': f'Retrieved {len(cars)} cars',
        'data': [car.to_dict_owner() for car in cars]
    }


def update_car(car_id, owner_id, car_data):
    """
    Update car details.
    
    Args:
        car_id: UUID of car
        owner_id: UUID of owner (for verification)
        car_data: Dictionary with updated fields
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': dict/None}
    """
    car = Car.query.filter_by(id=str(car_id)).first()
    
    if not car:
        return {'success': False, 'message': 'Car not found', 'data': None}
    
    if str(car.owner_id) != str(owner_id):
        return {'success': False, 'message': 'Unauthorized: Not the owner', 'data': None}
    
    try:
        updatable_fields = [
            'title', 'description', 'category', 'color', 'price_per_day',
            'price_per_week', 'price_per_month', 'price_per_year', 'currency',
            'security_deposit', 'city', 'country', 'pickup_location', 'latitude',
            'longitude', 'mileage', 'features', 'insurance_included', 'fuel_policy',
            'minimum_age', 'rental_terms', 'is_available'
        ]
        
        for field in updatable_fields:
            if field in car_data:
                setattr(car, field, car_data[field])
        
        db.session.commit()
        
        return {
            'success': True,
            'message': 'Car updated successfully',
            'data': car.to_dict_owner()
        }
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Car update error: {str(e)}")
        return {'success': False, 'message': f'Update failed: {str(e)}', 'data': None}


def delete_car(car_id, owner_id):
    """
    Delete a car listing.
    
    Args:
        car_id: UUID of car
        owner_id: UUID of owner (for verification)
        
    Returns:
        dict: {'success': bool, 'message': str}
    """
    car = Car.query.filter_by(id=str(car_id)).first()
    
    if not car:
        return {'success': False, 'message': 'Car not found'}
    
    if str(car.owner_id) != str(owner_id):
        return {'success': False, 'message': 'Unauthorized: Not the owner'}
    
    try:
        for image in car.images:
            delete_image(image.image_url)
        
        db.session.delete(car)
        db.session.commit()
        
        return {'success': True, 'message': 'Car deleted successfully'}
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Car deletion error: {str(e)}")
        return {'success': False, 'message': f'Deletion failed: {str(e)}'}


def add_car_images(car_id, owner_id, images_data):
    """
    Add images to existing car.
    
    Args:
        car_id: UUID of car
        owner_id: UUID of owner
        images_data: List of image dictionaries
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': list/None}
    """
    car = Car.query.filter_by(id=str(car_id)).first()
    
    if not car:
        return {'success': False, 'message': 'Car not found', 'data': None}
    
    if str(car.owner_id) != str(owner_id):
        return {'success': False, 'message': 'Unauthorized: Not the owner', 'data': None}
    
    # Check current image count + new images doesn't exceed limit
    current_image_count = len(car.images)
    new_image_count = len(images_data)
    total_images = current_image_count + new_image_count
    
    if total_images > MAX_PHOTOS_PER_PROPERTY:
        return {
            'success': False,
            'message': f'Cannot add {new_image_count} images. Car already has {current_image_count} images. Maximum {MAX_PHOTOS_PER_PROPERTY} photos allowed per car.',
            'data': None
        }
    
    try:
        added_images = []
        
        for img_data in images_data:
            image = CarImage(
                car_id=car.id,
                image_url=img_data.get('image_url'),
                is_primary=img_data.get('is_primary', False),
                display_order=img_data.get('display_order', 0),
                caption=img_data.get('caption')
            )
            db.session.add(image)
            added_images.append(image)
        
        db.session.commit()
        
        return {
            'success': True,
            'message': f'Added {len(added_images)} images',
            'data': [img.to_dict() for img in added_images]
        }
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Add images error: {str(e)}")
        return {'success': False, 'message': f'Failed to add images: {str(e)}', 'data': None}


def delete_car_image(image_id, owner_id):
    """
    Delete a car image.
    
    Args:
        image_id: UUID of image
        owner_id: UUID of owner
        
    Returns:
        dict: {'success': bool, 'message': str}
    """
    image = CarImage.query.filter_by(id=str(image_id)).first()
    
    if not image:
        return {'success': False, 'message': 'Image not found'}
    
    if str(image.car.owner_id) != str(owner_id):
        return {'success': False, 'message': 'Unauthorized: Not the owner'}
    
    try:
        delete_image(image.image_url)
        
        db.session.delete(image)
        db.session.commit()
        
        return {'success': True, 'message': 'Image deleted successfully'}
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Image deletion error: {str(e)}")
        return {'success': False, 'message': f'Deletion failed: {str(e)}'}