"""House service for managing rental properties."""
from flask import current_app
from app import db
from app.models import House, HouseImage, HouseStatus, User
from app.services.image_service import delete_image, MAX_PHOTOS_PER_PROPERTY
import uuid


def create_house(owner_id, house_data, images_data=None):
    """
    Create a new house listing.
    
    Args:
        owner_id: UUID of owner
        house_data: Dictionary with house 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 house',
            'data': None
        }
    
    try:
        house = House(
            owner_id=owner_id,
            title=house_data.get('title'),
            description=house_data.get('description'),
            category=house_data.get('category'),
            price_per_day=house_data.get('price_per_day'),
            price_per_week=house_data.get('price_per_week'),
            price_per_month=house_data.get('price_per_month'),
            price_per_year=house_data.get('price_per_year'),
            currency=house_data.get('currency', 'USD'),
            address=house_data.get('address'),
            city=house_data.get('city'),
            country=house_data.get('country'),
            latitude=house_data.get('latitude'),
            longitude=house_data.get('longitude'),
            bedrooms=house_data.get('bedrooms'),
            bathrooms=house_data.get('bathrooms'),
            max_guests=house_data.get('max_guests'),
            square_feet=house_data.get('square_feet'),
            floor_number=house_data.get('floor_number'),
            features=house_data.get('features', []),
            house_rules=house_data.get('house_rules'),
            status=HouseStatus.ACTIVE  # Set to ACTIVE for immediate listing
        )
        
        db.session.add(house)
        db.session.flush()
        
        if images_data:
            for img_data in images_data:
                image = HouseImage(
                    house_id=house.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': 'House created successfully',
            'data': house.to_dict_owner()
        }
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"House creation error: {str(e)}")
        return {'success': False, 'message': f'Failed to create house: {str(e)}', 'data': None}


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


def get_houses(filters=None, page=1, per_page=20):
    """
    Get list of houses with filters and pagination.
    
    Args:
        filters: Dictionary of filter criteria
        page: Page number
        per_page: Items per page
        
    Returns:
        dict: {'success': bool, 'data': dict with houses and pagination}
    """
    query = House.query.filter(
        House.is_available == True,
        House.status == HouseStatus.ACTIVE
    )
    
    if filters:
        if filters.get('city'):
            query = query.filter(House.city.ilike(f"%{filters['city']}%"))
        if filters.get('country'):
            query = query.filter(House.country.ilike(f"%{filters['country']}%"))
        if filters.get('category'):
            query = query.filter(House.category.ilike(f"%{filters['category']}%"))
        if filters.get('min_price') is not None:
            query = query.filter(House.price_per_day >= filters['min_price'])
        if filters.get('max_price') is not None:
            query = query.filter(House.price_per_day <= filters['max_price'])
        if filters.get('bedrooms') is not None:
            query = query.filter(House.bedrooms >= filters['bedrooms'])
        if filters.get('max_guests') is not None:
            query = query.filter(House.max_guests >= filters['max_guests'])
    
    pagination = query.paginate(page=page, per_page=per_page, error_out=False)
    houses = [house.to_dict_public() for house in pagination.items]
    
    return {
        'success': True,
        'data': {
            'houses': houses,
            '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_houses(owner_id):
    """
    Get all houses owned by a user.
    
    Args:
        owner_id: UUID of owner
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': list}
    """
    houses = House.query.filter_by(owner_id=str(owner_id)).all()
    
    return {
        'success': True,
        'message': f'Retrieved {len(houses)} houses',
        'data': [house.to_dict_owner() for house in houses]
    }


def update_house(house_id, owner_id, house_data):
    """
    Update house details.
    
    Args:
        house_id: UUID of house
        owner_id: UUID of owner (for verification)
        house_data: Dictionary with updated fields
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': dict/None}
    """
    house = House.query.filter_by(id=str(house_id)).first()
    
    if not house:
        return {'success': False, 'message': 'House not found', 'data': None}
    
    if str(house.owner_id) != str(owner_id):
        return {'success': False, 'message': 'Unauthorized: Not the owner', 'data': None}
    
    try:
        updatable_fields = [
            'title', 'description', 'category', 'price_per_day', 'price_per_week',
            'price_per_month', 'price_per_year', 'currency', 'address', 'city',
            'country', 'latitude', 'longitude', 'bedrooms', 'bathrooms',
            'max_guests', 'square_feet', 'floor_number', 'features', 'house_rules',
            'is_available'
        ]
        
        for field in updatable_fields:
            if field in house_data:
                setattr(house, field, house_data[field])
        
        db.session.commit()
        
        return {
            'success': True,
            'message': 'House updated successfully',
            'data': house.to_dict_owner()
        }
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"House update error: {str(e)}")
        return {'success': False, 'message': f'Update failed: {str(e)}', 'data': None}


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


def add_house_images(house_id, owner_id, images_data):
    """
    Add images to existing house.
    
    Args:
        house_id: UUID of house
        owner_id: UUID of owner
        images_data: List of image dictionaries
        
    Returns:
        dict: {'success': bool, 'message': str, 'data': list/None}
    """
    house = House.query.filter_by(id=str(house_id)).first()
    
    if not house:
        return {'success': False, 'message': 'House not found', 'data': None}
    
    if str(house.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(house.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. House already has {current_image_count} images. Maximum {MAX_PHOTOS_PER_PROPERTY} photos allowed per house.',
            'data': None
        }
    
    try:
        added_images = []
        
        for img_data in images_data:
            image = HouseImage(
                house_id=house.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_house_image(image_id, owner_id):
    """
    Delete a house image.
    
    Args:
        image_id: UUID of image
        owner_id: UUID of owner
        
    Returns:
        dict: {'success': bool, 'message': str}
    """
    image = HouseImage.query.filter_by(id=str(image_id)).first()
    
    if not image:
        return {'success': False, 'message': 'Image not found'}
    
    if str(image.house.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)}'}