# backend\communications\signals.py
from django.conf import settings
from django.core.files.base import ContentFile
from django.db.models import F
from django.db.models.signals import post_save, pre_save
from django.dispatch import receiver
from django.utils.module_loading import import_string
import logging

logger = logging.getLogger(__name__)


# NOTE: Project-specific chat creation signals should be in your project's app
# Example: employees/signals.py - create_main_department_chat()


def _get_image_compressor():
    """
    Получает функцию сжатия изображений из настроек или использует дефолтную.
    
    Settings:
        COMMUNICATIONS_IMAGE_COMPRESSOR (str): Путь к функции сжатия.
            По умолчанию: 'common.image_utils.compress_avatar' (проектно-специфичный)
            Для standalone: None (отключает сжатие)
            Пример: 'myapp.utils.compress_image'
    
    Returns:
        callable or None: Функция сжатия или None если отключено
    """
    compressor_path = getattr(
        settings,
        'COMMUNICATIONS_IMAGE_COMPRESSOR',
        'common.image_utils.compress_avatar'  # backward compatibility
    )
    
    if compressor_path is None:
        return None
    
    try:
        return import_string(compressor_path)
    except (ImportError, AttributeError) as e:
        logger.warning(
            f"Failed to import image compressor '{compressor_path}': {e}. "
            "Avatar compression disabled. Set COMMUNICATIONS_IMAGE_COMPRESSOR=None "
            "to suppress this warning."
        )
        return None


@receiver(pre_save, sender='communications.Chat')
def compress_and_cleanup_chat_avatar(sender, instance, **kwargs):
    """
    Сжимает новый аватар чата и удаляет старый файл.
    
    Использует COMMUNICATIONS_IMAGE_COMPRESSOR из settings.
    Если compressor не настроен - пропускает сжатие.
    """
    if not instance.avatar:
        return
    
    compress_avatar = _get_image_compressor()

    # Если это новый объект (нет pk), просто сжимаем
    if not instance.pk:
        if compress_avatar:
            try:
                compressed = compress_avatar(instance.avatar.read())
                if compressed:
                    instance.avatar.save(
                        instance.avatar.name,
                        ContentFile(compressed),
                        save=False
                    )
            except Exception as e:
                logger.error(f"Error compressing new chat avatar: {e}")
        return

    # Проверяем, изменился ли файл аватара
    try:
        old_instance = sender.objects.get(pk=instance.pk)
    except sender.DoesNotExist:
        return

    old_avatar = old_instance.avatar
    new_avatar = instance.avatar

    # Если путь изменился - это новый файл
    if old_avatar and new_avatar and old_avatar.name != new_avatar.name:
        try:
            # Сжимаем новый аватар (если compressor настроен)
            if compress_avatar:
                compressed = compress_avatar(new_avatar.read())
                if compressed:
                    new_avatar.save(
                        new_avatar.name,
                        ContentFile(compressed),
                        save=False
                    )

            # Удаляем старый файл
            if old_avatar.name:
                old_avatar.delete(save=False)
                logger.info(
                    f"Deleted old chat avatar: {old_avatar.name}"
                )
        except Exception as e:
            logger.error(f"Error processing chat avatar: {e}")


@receiver(post_save, sender='communications.Message')
def increment_unread_count_on_new_message(sender, instance, created, **kwargs):
    """
    Инкрементирует unread_count для всех участников чата (кроме автора)
    при создании нового сообщения.
    
    Денормализация: вместо подсчета COUNT(*) в реальном времени,
    обновляем кешированный счетчик инкрементом.
    """
    if not created or instance.is_deleted:
        return
    
    from communications.models import ChatReadState
    
    try:
        # Получаем всех участников чата
        chat = instance.chat
        participants = chat.get_participants().exclude(id=instance.author_id)
        
        # Инкрементируем счетчик для существующих ChatReadState
        # Только для тех, кто еще не прочитал это сообщение
        updated_count = ChatReadState.objects.filter(
            chat=chat,
            user__in=participants
        ).exclude(
            # Пропускаем тех, кто уже прочитал дальше этого сообщения
            last_read_message_id__gte=instance.id
        ).update(
            unread_count=F('unread_count') + 1
        )
        
        # Создаем ChatReadState для участников, у которых его еще нет
        existing_users = ChatReadState.objects.filter(
            chat=chat,
            user__in=participants
        ).values_list('user_id', flat=True)
        
        new_users = participants.exclude(id__in=existing_users)
        
        if new_users.exists():
            # Создаем ChatReadState с unread_count=1 для новых участников
            ChatReadState.objects.bulk_create([
                ChatReadState(
                    chat=chat,
                    user=user,
                    last_read_message=None,
                    unread_count=1
                )
                for user in new_users
            ], ignore_conflicts=True)
            
            logger.info(
                f"[increment_unread] Created {new_users.count()} new ChatReadState for msg={instance.id}"
            )
        
        logger.debug(
            f"[increment_unread] Updated {updated_count} ChatReadState for msg={instance.id} in chat={chat.id}"
        )
        
    except Exception as e:
        logger.error(f"Error incrementing unread_count for message {instance.id}: {e}", exc_info=True)