"""
Упрощенная универсальная система уведомлений
Основана на архитектуре django-notifications-hq, адаптирована для Django 5.2+

Ключевые изменения:
- Одна модель Notification вместо 6
- GenericForeignKey для универсальности
- Простой API через сигналы
- Multi-channel поддержка (Web, Email, Push)

TODO: Добавить тесты для моделей:
      - NotificationQuerySet методы (unread, read, mark_all_as_*)
      - Notification.mark_as_read/unread()
      - Notification.timesince()
      - UserChannelPreferences.is_verb_enabled()
      - UserChannelPreferences.is_in_dnd_period()
"""

from django.db import models
from django.conf import settings
from django.utils import timezone
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db.models.query import QuerySet


class NotificationQuerySet(QuerySet):
    """QuerySet с удобными методами фильтрации"""
    
    def unread(self):
        """Непрочитанные уведомления"""
        return self.filter(unread=True)
    
    def read(self):
        """Прочитанные уведомления"""
        return self.filter(unread=False)
    
    def mark_all_as_read(self, recipient=None):
        """Отметить все как прочитанные"""
        qs = self.unread()
        if recipient:
            qs = qs.filter(recipient=recipient)
        
        return qs.update(
            unread=False,
            timestamp_read=timezone.now()
        )
    
    def mark_all_as_unread(self, recipient=None):
        """Отметить все как непрочитанные"""
        qs = self.read()
        if recipient:
            qs = qs.filter(recipient=recipient)
        
        return qs.update(
            unread=True,
            timestamp_read=None
        )
    
    def deleted(self):
        """Удаленные уведомления"""
        return self.filter(deleted=True)
    
    def active(self):
        """Активные (не удаленные) уведомления"""
        return self.filter(deleted=False)
    
    def public(self):
        """Публичные уведомления"""
        return self.filter(public=True)
    
    def for_user(self, user):
        """Уведомления для конкретного пользователя"""
        return self.filter(recipient=user).active()


class Notification(models.Model):
    """
    Универсальная модель уведомления
    
    Структура по образу django-notifications-hq:
    - actor performed verb on action_object at target
    
    Примеры:
    - John (actor) commented (verb) on photo (target)
    - Mary (actor) liked (verb) your comment (action_object) on post (target)
    - System (actor) approved (verb) your request (action_object)
    """
    
    # === Базовые поля ===
    
    recipient = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name='notifications',
        verbose_name='Получатель',
        help_text='Кому адресовано уведомление'
    )
    
    # Кто совершил действие (GenericForeignKey)
    actor_content_type = models.ForeignKey(
        ContentType,
        related_name='notify_actor',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        verbose_name='Тип актора'
    )
    actor_object_id = models.CharField(
        max_length=255,
        null=True,
        blank=True,
        verbose_name='ID актора'
    )
    actor = GenericForeignKey('actor_content_type', 'actor_object_id')
    
    # Что произошло
    verb = models.CharField(
        max_length=255,
        default='notification',
        verbose_name='Действие',
        help_text='Например: liked, commented, approved, mentioned',
        db_index=True
    )
    
    # Объект действия (GenericForeignKey) - опционально
    action_object_content_type = models.ForeignKey(
        ContentType,
        related_name='notify_action_object',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        verbose_name='Тип объекта действия'
    )
    action_object_object_id = models.CharField(
        max_length=255,
        null=True,
        blank=True,
        verbose_name='ID объекта действия'
    )
    action_object = GenericForeignKey(
        'action_object_content_type',
        'action_object_object_id'
    )
    
    # Целевой объект (GenericForeignKey) - опционально
    target_content_type = models.ForeignKey(
        ContentType,
        related_name='notify_target',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        verbose_name='Тип целевого объекта'
    )
    target_object_id = models.CharField(
        max_length=255,
        null=True,
        blank=True,
        verbose_name='ID целевого объекта'
    )
    target = GenericForeignKey('target_content_type', 'target_object_id')
    
    # === Контент ===
    
    description = models.TextField(
        blank=True,
        null=True,
        verbose_name='Описание',
        help_text='Человекочитаемое описание уведомления'
    )
    
    # URL для перехода
    action_url = models.CharField(
        max_length=500,
        blank=True,
        null=True,
        verbose_name='URL действия',
        help_text='Куда перейти при клике на уведомление'
    )
    
    # Дополнительные данные (JSON)
    data = models.JSONField(
        default=dict,
        blank=True,
        verbose_name='Дополнительные данные',
        help_text='Любые метаданные для рендеринга или логики'
    )
    
    # === Статусы ===
    
    unread = models.BooleanField(
        default=True,
        db_index=True,
        verbose_name='Непрочитано'
    )
    
    timestamp_read = models.DateTimeField(
        null=True,
        blank=True,
        verbose_name='Время прочтения'
    )
    
    public = models.BooleanField(
        default=True,
        db_index=True,
        verbose_name='Публичное',
        help_text='Можно показывать другим пользователям'
    )
    
    deleted = models.BooleanField(
        default=False,
        db_index=True,
        verbose_name='Удалено',
        help_text='Мягкое удаление'
    )
    
    emailed = models.BooleanField(
        default=False,
        db_index=True,
        verbose_name='Отправлено на email'
    )
    
    # === Временные метки ===
    
    timestamp = models.DateTimeField(
        default=timezone.now,
        db_index=True,
        verbose_name='Создано'
    )
    
    # === Manager ===
    
    objects = NotificationQuerySet.as_manager()
    
    class Meta:
        ordering = ['-timestamp']
        indexes = [
            models.Index(fields=['recipient', '-timestamp']),
            models.Index(fields=['recipient', 'unread', '-timestamp']),
            models.Index(fields=['verb', '-timestamp']),
            models.Index(fields=['-timestamp']),
        ]
        verbose_name = 'Уведомление'
        verbose_name_plural = 'Уведомления'
        db_table = 'notifications_notification_v2'  # Новая таблица для миграции
    
    def __str__(self):
        actor_str = str(self.actor) if self.actor else 'Система'
        target_str = f' → {self.target}' if self.target else ''
        return f'{actor_str} {self.verb}{target_str}'
    
    # === Методы ===
    
    def mark_as_read(self):
        """Отметить уведомление как прочитанное"""
        if self.unread:
            self.unread = False
            self.timestamp_read = timezone.now()
            self.save(update_fields=['unread', 'timestamp_read'])
    
    def mark_as_unread(self):
        """Отметить уведомление как непрочитанное"""
        if not self.unread:
            self.unread = True
            self.timestamp_read = None
            self.save(update_fields=['unread', 'timestamp_read'])
    
    @property
    def timesince(self, now=None):
        """
        Возвращает человекочитаемое время с момента создания
        Например: "5 минут назад", "2 часа назад"
        """
        from django.utils.timesince import timesince as timesince_
        return timesince_(self.timestamp, now)
    
    @property
    def slug(self):
        """
        Создает slug для уведомления (для URL)
        Формат: id-verb-target
        """
        return f"{self.id or ''}-{self.verb}-{self.target_object_id or ''}"


class UserChannelPreferences(models.Model):
    """
    Настройки каналов доставки для пользователя
    
    Упрощенная модель вместо UserNotificationSettings
    Один пользователь - одна запись с настройками для всех каналов
    """
    
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name='channel_preferences',
        verbose_name='Пользователь'
    )
    
    # === Каналы доставки ===
    
    web_enabled = models.BooleanField(
        default=True,
        verbose_name='Веб уведомления',
        help_text='Показывать в интерфейсе сайта'
    )
    
    email_enabled = models.BooleanField(
        default=False,
        verbose_name='Email уведомления'
    )
    
    push_enabled = models.BooleanField(
        default=False,
        verbose_name='Push уведомления',
        help_text='Web Push для браузера'
    )
    
    # === Email настройки ===
    
    EMAIL_FREQUENCY_CHOICES = [
        ('instant', 'Мгновенно'),
        ('daily', 'Ежедневный дайджест'),
        ('weekly', 'Еженедельный дайджест'),
        ('never', 'Никогда'),
    ]
    
    email_frequency = models.CharField(
        max_length=20,
        choices=EMAIL_FREQUENCY_CHOICES,
        default='instant',
        verbose_name='Частота email'
    )
    
    # === Тихий режим (Do Not Disturb) ===
    
    dnd_enabled = models.BooleanField(
        default=False,
        verbose_name='Режим "Не беспокоить"',
        help_text='Отключить все уведомления в определенное время'
    )
    
    dnd_start_time = models.TimeField(
        null=True,
        blank=True,
        verbose_name='Начало тихого режима',
        help_text='Например, 22:00'
    )
    
    dnd_end_time = models.TimeField(
        null=True,
        blank=True,
        verbose_name='Конец тихого режима',
        help_text='Например, 08:00'
    )
    
    # === Фильтры по типам (verb) ===
    
    disabled_verbs = models.JSONField(
        default=list,
        blank=True,
        verbose_name='Отключенные типы',
        help_text='Список verb для которых не показывать уведомления. Например: ["liked", "followed"]'
    )
    
    class Meta:
        verbose_name = 'Настройки каналов пользователя'
        verbose_name_plural = 'Настройки каналов пользователей'
        db_table = 'notifications_userchannelpreferences'
    
    def __str__(self):
        return f'{self.user.get_short_name()} - настройки каналов'
    
    def is_verb_enabled(self, verb):
        """Проверить, включен ли этот тип уведомлений"""
        return verb not in self.disabled_verbs
    
    def disable_verb(self, verb):
        """Отключить определенный тип уведомлений"""
        if verb not in self.disabled_verbs:
            self.disabled_verbs.append(verb)
            self.save(update_fields=['disabled_verbs'])
    
    def enable_verb(self, verb):
        """Включить определенный тип уведомлений"""
        if verb in self.disabled_verbs:
            self.disabled_verbs.remove(verb)
            self.save(update_fields=['disabled_verbs'])
    
    def is_in_dnd_period(self):
        """Проверить, находимся ли в режиме "Не беспокоить"""
        if not self.dnd_enabled or not self.dnd_start_time or not self.dnd_end_time:
            return False
        
        now = timezone.now().time()
        
        # Простой случай: начало < конец (например, 09:00 - 18:00)
        if self.dnd_start_time < self.dnd_end_time:
            return self.dnd_start_time <= now <= self.dnd_end_time
        
        # Через полночь: начало > конец (например, 22:00 - 08:00)
        return now >= self.dnd_start_time or now <= self.dnd_end_time


# === Web Push устройства управляются через django-push-notifications ===
# Используйте: from push_notifications.models import WebPushDevice