"""LDAP ORM модели для работы с Active Directory через django-ldapdb.

Эти модели используются ТОЛЬКО для записи (POST/PUT/DELETE) в LDAP.
Для чтения (GET) используются обычные Django модели (Employee, Department).

Преимущества ORM подхода:
- Замена низкоуровневых ldap3 операций на Django ORM
- Автоматическая валидация и типизация
- Унифицированный API для CRUD операций
- Меньше кода, больше удобства

ВАЖНО: Миксины расширяют django-ldapdb
=======================================

django-ldapdb (версия 1.5.1) изначально НЕ поддерживает некоторые операции,
но мы добавили их через кастомные миксины:

✅ ModifyDN (rename/move) — перемещение объектов между OU
   - РЕШЕНО: ModifyDnMixin выполняет modify_dn
     при изменении base_dn
   - Использование: user.base_dn = new_dn; user.save()
   - См. employees.ldap.mixins.ModifyDnMixin

✅ Автоматическое управление LdapSyncState
   - РЕШЕНО: LdapSyncStateMixin автоматически
     создает/обновляет/удаляет sync state
   - Работает на save() и delete()
   - См. employees.ldap.mixins.LdapSyncStateMixin

Что требует низкоуровневого ldap3:

1. Создание объектов с динамическим DN
   - Создание пользователей: ldap3.Connection.add() с явным DN
   - DN формируется на основе department_dn или LDAP_USERS_BASE
   - См. services.user_service.UserService._create_user_in_ldap()

2. Транзакционное создание с перебором CN (collision handling)
   - При создании пользователя перебираются варианты CN до успеха
   - См. services.user_service.UserService._try_add_with_cn_list()

Что МОЖНО делать через ORM с миксинами:
- CREATE: через сервисы (UserService.create_user)
- READ: поиск объектов (.objects.get(dn=...))
- UPDATE: изменение атрибутов (.save())
- MOVE: изменение base_dn + save() — автоматический modify_dn! 🎉
- DELETE: .delete() — автоматическое удаление sync state
- BATCH UPDATE: массовое обновление атрибутов (.save() в цикле)

Архитектура использования (с миксинами):
========================================

CREATE пользователя:
  from employees.ldap.services import UserService
  service = UserService()
  employee = service.create_user(employee)  # создание + LdapSyncState

UPDATE пользователя:
  ldap_user = LdapUser.objects.get(dn=dn)
  ldap_user.display_name = "New Name"
  ldap_user.save()  # автообновление LdapSyncState через миксин

MOVE пользователя (перевод в отдел) — НОВОЕ С МИКСИНОМ:
  ldap_user = LdapUser.objects.get(dn=old_dn)
  ldap_user.base_dn = "OU=NewDept,OU=Departments,DC=..."
  ldap_user.save()  # ModifyDnMixin автоматически выполнит modify_dn!

DELETE пользователя:
  ldap_user = LdapUser.objects.get(dn=dn)
  ldap_user.delete()  # автоудаление LdapSyncState через миксин

Структура DN в Active Directory:
=================================

Пользователи (зависит от статуса):
  - Активные по отделам:
    CN=Иванов Иван,OU=IT,OU=Departments,OU=company,DC=robotail,DC=local
  - Уволенные:
    CN=Иванов Иван,OU=Dismissed,OU=company,DC=robotail,DC=local

Группы (зависит от типа):
  - Глобальные группы:
    CN=Developers,OU=Groups,OU=company,DC=robotail,DC=local
  - Группы OU (внутри OU):
    CN=DEP_IT,OU=IT,OU=Departments,OU=company,DC=robotail,DC=local
  - Роли отделов:
    CN=ROLE_Manager,OU=IT,OU=Departments,OU=company,DC=robotail,DC=local

Организационные единицы:
  - Отделы:
    OU=IT,OU=Departments,OU=company,DC=robotail,DC=local
  - Вспомогательные контейнеры:
    OU=Roles,OU=IT,OU=Departments,OU=company,DC=robotail,DC=local

base_dn моделей:
================

base_dn используется ТОЛЬКО для SUBTREE поиска
через .objects.filter()
и НЕ определяет местоположение создаваемых/перемещаемых объектов.

- LdapUser.base_dn = "OU=company,DC=..." — покрывает все отделы и Dismissed
- LdapGroup.base_dn = "OU=Groups,..." — покрывает только глобальные группы
- LdapOrganizationalUnit.base_dn = "OU=Departments,..." — покрывает OU отделов
"""

import datetime as _dt

from django.conf import settings
from django.utils import timezone as _dj_tz


class _UtcCompat(_dt.tzinfo):
    """pytz-compatible UTC wrapper for django-ldapdb.

    django-ldapdb still expects timezone.utc to provide pytz-like
    `localize()` and `normalize()` methods. Some Django/Python combinations
    expose `timezone.utc`, but without these methods. In that case ORM
    save/update paths for LDAP models crash deep inside field preparation.
    """

    def localize(self, dt):
        """pytz-style localize method."""
        return dt.replace(tzinfo=_dt.timezone.utc)

    def normalize(self, dt):
        """pytz-style normalize method - same as localize for UTC."""
        return dt.replace(tzinfo=_dt.timezone.utc)

    def utcoffset(self, dt):
        return _dt.timedelta(0)

    def tzname(self, dt):
        return "UTC"

    def dst(self, dt):
        return _dt.timedelta(0)

    def __repr__(self):
        return "UTC"


# Compatibility: django-ldapdb 1.5.1 expects timezone.utc with pytz methods.
if not hasattr(_dj_tz, "utc") or not all(
    hasattr(_dj_tz.utc, attr) for attr in ("localize", "normalize")
):
    _dj_tz.utc = _UtcCompat()

from ldapdb.models import Model as LdapModel  # noqa: E402
from ldapdb.models.fields import (  # noqa: E402
    CharField,
    DateTimeField,
    ImageField,
    IntegerField,
    ListField,
)

# Миксины для расширения функциональности LDAP моделей
from .mixins import LdapSyncStateMixin, ModifyDnMixin  # noqa: E402


def get_users_base():
    """Получает base DN для пользователей из settings.

    Возвращает корневой DN, который покрывает все возможные местоположения
    пользователей для SUBTREE search:
    - OU=Departments (активные сотрудники по отделам)
    - OU=Dismissed (уволенные)
    - Любые другие OU под OU=company

    Приоритет:
    1. LDAP_USER_BASE или LDAP_USERS_BASE (если задан в settings)
    2. Fallback: OU=company,DC=robotail,DC=local
    """
    return getattr(
        settings,
        "LDAP_USER_BASE",
        getattr(settings, "LDAP_USERS_BASE", "OU=company,DC=robotail,DC=local"),
    )


def get_base_dn():
    """Получает корневой base DN из settings.

    Используется для операций, которым нужен охват всего домена.

    Приоритет:
    1. LDAP_BASE_DN (если задан)
    2. Fallback: LDAP_USERS_BASE или DC=robotail,DC=local
    """
    return getattr(
        settings,
        "LDAP_BASE_DN",
        getattr(settings, "LDAP_USERS_BASE", "DC=robotail,DC=local"),
    )


def get_groups_base():
    """Получает base DN для глобальных групп из settings.

    Глобальные группы располагаются в:
      CN=<GroupName>,OU=Groups,OU=company,DC=robotail,DC=local

    Приоритет:
    1. LDAP_GROUPS_BASE (если задан)
    2. Fallback: OU=Groups,DC=robotail,DC=local
    """
    return getattr(
        settings,
        "LDAP_GROUPS_BASE",
        "OU=Groups,DC=robotail,DC=local",
    )


def get_departments_base():
    """Получает base DN для отделов (OU) из settings.

    Отделы располагаются в фиксированном контейнере:
      OU=<DeptName>,OU=Departments,OU=company,DC=robotail,DC=local

    Приоритет:
    1. LDAP_DEPARTMENTS_BASE (если задан)
    2. Fallback: OU=Departments,DC=robotail,DC=local
    """
    return getattr(
        settings,
        "LDAP_DEPARTMENTS_BASE",
        "OU=Departments,DC=robotail,DC=local",
    )


class LdapUser(LdapSyncStateMixin, ModifyDnMixin, LdapModel):
    """LDAP модель для пользователя Active Directory.

    Использует objectClass: top, person, organizationalPerson, user.
    Только для WRITE операций (POST/PUT/DELETE).

    Миксины:
    - LdapSyncStateMixin: автоматически обновляет LdapSyncState при save/delete
    - ModifyDnMixin: поддержка перемещения между OU через base_dn изменение

    ВАЖНО О base_dn:
    - base_dn используется только для SUBTREE поиска через .objects.filter()
    - НЕ определяет местоположение создаваемых/перемещаемых объектов
    - Реально пользователи находятся в разных OU:
      • CN=User,OU=<Dept>,OU=Departments,OU=company,... (активные)
      • CN=User,OU=Dismissed,OU=company,... (уволенные)
    - При изменении base_dn ModifyDnMixin автоматически выполнит modify_dn!

    Операции через ORM:
    - CREATE: используйте UserService.create_user() (создание + sync state)
    - UPDATE: изменение атрибутов через .save() (автообновление sync state)
    - MOVE: user.base_dn = new_dn; user.save() (автоматический modify_dn!)
    - DELETE: .delete() (автоматическое удаление sync state)

    Модель используется для:
    - UPDATE: изменение атрибутов существующих объектов через .save()
    - READ: поиск через .objects.get(dn=...) для последующего обновления
    """

    # Конфигурация LdapSyncStateMixin
    _sync_model_name = "employee"
    _sync_pk_field = "employee_number"

    # Базовая конфигурация
    # base_dn покрывает все местоположения
    # пользователей для SUBTREE search
    base_dn = get_users_base()
    object_classes = ["top", "person", "organizationalPerson", "user"]

    # RDN атрибут для построения Distinguished Name
    # Пример: cn=Ivan Ivanov → dn=CN=Ivan Ivanov,OU=...,DC=...
    rdn_attributes = ["cn"]

    # Основные атрибуты
    # dn: ldapdb.models.Model primary_key (DN)
    cn = CharField(db_column="cn")

    # Идентификация
    sam_account_name = CharField(db_column="sAMAccountName")
    user_principal_name = CharField(db_column="userPrincipalName")

    # Персональные данные
    given_name = CharField(db_column="givenName")
    sn = CharField(db_column="sn")  # surname (фамилия)
    display_name = CharField(db_column="displayName")
    mail = CharField(db_column="mail")

    # Контакты
    telephone_number = CharField(db_column="telephoneNumber", blank=True)
    mobile = CharField(db_column="mobile", blank=True)

    # Управление учетной записью
    user_account_control = IntegerField(db_column="userAccountControl")

    # Пароль (write-only атрибут AD)
    # ВАЖНО: unicodePwd - специальный атрибут Active Directory
    # - Write-only: можно записать, но нельзя прочитать
    # - Требует SSL/TLS соединения
    # - Требует специальной кодировки: UTF-16-LE с кавычками
    # - Используйте метод set_password() вместо прямой записи
    unicode_pwd = CharField(db_column="unicodePwd", blank=True)

    # Дополнительная информация
    description = CharField(db_column="description", blank=True)
    thumbnail_photo = ImageField(db_column="thumbnailPhoto", blank=True)

    # ID сотрудника (для связи с Django Employee.pk)
    employee_number = CharField(db_column="employeeNumber", blank=True)

    # Членство в группах
    member_of = ListField(db_column="memberOf", blank=True)

    # Временные метки
    when_created = DateTimeField(db_column="whenCreated")
    when_changed = DateTimeField(db_column="whenChanged")

    class Meta:
        managed = False  # Django не управляет схемой LDAP

    def __str__(self):
        return f"{self.display_name} ({self.sam_account_name})"

    def __repr__(self):
        return f"<LdapUser: {self.sam_account_name}>"

    def set_password(self, new_password: str) -> None:
        """Устанавливает новый пароль для пользователя.

        Через AD extended operation.

        Использует Microsoft-специфичное расширение modify_password
        для корректной работы с политиками паролей AD.
        Это более надежный способ, чем прямая
        запись в unicodePwd.

        Args:
            new_password: Новый пароль (plaintext)

        Raises:
            ValueError: Если пароль пустой или не соответствует политике
            DirectoryLdapError: Если операция не удалась

        Example:
            >>> ldap_user = LdapUser.objects.get(dn='CN=...')
            >>> ldap_user.set_password('NewSecurePass123!')
            >>> # Пароль изменён в AD, НЕ требуется .save()
        """
        from .infrastructure.connections import _ldap
        from .services.user_password_service import UserPasswordService

        service = UserPasswordService()
        with _ldap() as conn:
            service.set_password(conn, self.dn, new_password)

    def change_password(self, old_password: str, new_password: str) -> None:
        """Меняет пароль пользователя (требует знания старого пароля).

        Используется для самостоятельной смены пароля пользователем.

        Args:
            old_password: Текущий пароль
            new_password: Новый пароль

        Raises:
            ValueError: Если новый пароль не соответствует политике
            DirectoryLdapError: Если старый пароль неверен
                или операция не удалась

        Example:
            >>> ldap_user = LdapUser.objects.get(dn='CN=...')
            >>> ldap_user.change_password('OldPass123', 'NewSecurePass123!')
            >>> # Пароль изменён в AD, НЕ требуется .save()
        """
        from .infrastructure.connections import _ldap
        from .services.user_password_service import UserPasswordService

        service = UserPasswordService()
        with _ldap() as conn:
            service.change_password(conn, self.dn, old_password, new_password)


class LdapGroup(ModifyDnMixin, LdapModel):
    """LDAP модель для глобальных групп Active Directory.

    Использует objectClass: top, group.
    Только для WRITE операций (POST/PUT/DELETE).

    Миксины:
    - ModifyDnMixin: поддержка перемещения между OU через base_dn изменение

    ВАЖНО О base_dn:
    - base_dn = LDAP_GROUPS_BASE — сканирует ТОЛЬКО OU=Groups
    - Для групп отделов (DEP_*): используйте LdapOrganizationalUnitGroup
    - Для должностей (POS_*): используйте PositionService
    - При изменении base_dn ModifyDnMixin автоматически выполнит modify_dn!

    Операции через django-ldapdb:
    - CREATE: создание через GroupService.create() (ORM)
    - UPDATE: изменение атрибутов через .save()
        - MOVE: group.base_dn = new_dn; group.save()
            (автоматический modify_dn!)
    - RENAME: переименование через GroupService.rename() (low-level ldap3)
    - DELETE: удаление через .delete() (ORM)

    Расположение групп по типам:
        - Глобальные:  CN=<Name>,OU=Groups,...
            ← эта модель
        - Отделы:      CN=DEP_*,OU=<Dept>,OU=Departments
            ← LdapOrganizationalUnitGroup
        - Должности:   CN=POS_*,OU=Positions,...
            ← PositionService
        - Роли:        CN=ROLE_*,OU=<Dept>,OU=Departments
            ← через GroupService
    """

    # Базовая конфигурация: только OU=Groups
    base_dn = get_groups_base()
    object_classes = ["top", "group"]

    # RDN атрибут для построения Distinguished Name
    # Пример: cn=Developers → dn=CN=Developers,OU=Groups,DC=...
    rdn_attributes = ["cn"]

    # Основные атрибуты
    # dn: ldapdb.models.Model primary_key (DN)
    cn = CharField(db_column="cn")

    # Идентификация
    # objectGUID исключен (проблемы с бинарными данными)
    sam_account_name = CharField(db_column="sAMAccountName")

    # Описание
    description = CharField(db_column="description", blank=True)

    # Члены группы
    member = ListField(db_column="member", blank=True)
    member_of = ListField(db_column="memberOf", blank=True)

    # Временные метки
    when_created = DateTimeField(db_column="whenCreated")
    when_changed = DateTimeField(db_column="whenChanged")

    class Meta:
        managed = False

    def __str__(self):
        return f"Group: {self.cn}"

    def __repr__(self):
        return f"<LdapGroup: {self.cn}>"

    # ==================== Membership Methods ==================== #

    def list_members(self) -> list[str]:
        """Возвращает список DN участников группы."""
        return list(self.member or [])

    def add_member(self, member_dn: str) -> None:
        """Добавляет участника в глобальную группу."""
        current = self.member or []
        if member_dn in current:
            return

        from ldap3 import MODIFY_ADD

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            ok = conn.modify(self.dn, {"member": [(MODIFY_ADD, [member_dn])]})
            if not ok:
                result_str = str(conn.result)
                if "attributeOrValueExists" not in result_str:
                    raise RuntimeError(f"add_member failed: {conn.result}")

    def remove_member(self, member_dn: str) -> None:
        """Удаляет участника из глобальной группы."""
        from ldap3 import MODIFY_DELETE

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            ok = conn.modify(self.dn, {"member": [(MODIFY_DELETE, [member_dn])]})
            if not ok:
                result_str = str(conn.result)
                if "noSuchAttribute" not in result_str:
                    raise RuntimeError(f"remove_member failed: {conn.result}")

    def sync_members(self, desired_dns: list[str]) -> dict:
        """Синхронизирует состав группы к точному списку."""
        current = set(self.member or [])
        desired = set(desired_dns)

        to_add = desired - current
        to_remove = current - desired

        from ldap3 import MODIFY_ADD, MODIFY_DELETE

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            if to_remove:
                conn.modify(self.dn, {"member": [(MODIFY_DELETE, list(to_remove))]})
            if to_add:
                conn.modify(self.dn, {"member": [(MODIFY_ADD, list(to_add))]})

        return {
            "added": len(to_add),
            "removed": len(to_remove),
        }


class LdapOrganizationalUnitGroup(ModifyDnMixin, LdapModel):
    """LDAP модель группы организационной единицы (DEP_*).

    Каждая OU в LDAP имеет агрегаторную группу,
    содержащую всех активных сотрудников этой OU:
      CN=DEP_IT,OU=IT,OU=Departments,OU=company,DC=robotail,DC=local

    Миксины:
    - ModifyDnMixin: перемещение при переименовании OU

    ВАЖНО О base_dn:
    - base_dn = LDAP_DEPARTMENTS_BASE — SUBTREE поиск найдёт
      все DEP_* группы внутри всех OU
    - objectClass фильтрация: ищет только group (не OU)

    Операции:
    - READ: .objects.filter(cn__startswith='DEP_')
    - UPDATE: изменение description/member через .save()
    - MOVE: group.base_dn = new_ou_dn; group.save()
    - DELETE: .delete()
    - CREATE: ensure() на LdapOrganizationalUnit (low-level ldap3)

    Управление членством:
    - add_member(user_dn) → добавить пользователя
    - remove_member(user_dn) → удалить пользователя
    - sync_members(user_dns) → привести к точному списку
    - list_members() → текущий список DN участников
    """

    # Базовая конфигурация: ищем группы внутри OU отделов
    base_dn = get_departments_base()
    object_classes = ["top", "group"]

    rdn_attributes = ["cn"]

    # Основные атрибуты
    cn = CharField(db_column="cn")
    sam_account_name = CharField(db_column="sAMAccountName")
    description = CharField(db_column="description", blank=True)

    # Члены группы
    member = ListField(db_column="member", blank=True)
    member_of = ListField(db_column="memberOf", blank=True)

    # Временные метки
    when_created = DateTimeField(db_column="whenCreated")
    when_changed = DateTimeField(db_column="whenChanged")

    class Meta:
        managed = False

    def __str__(self):
        return f"OUGroup: {self.cn}"

    def __repr__(self):
        return f"<LdapOrganizationalUnitGroup: {self.cn}>"

    # ==================== Membership Methods ==================== #

    def list_members(self) -> list[str]:
        """Возвращает список DN участников группы."""
        return list(self.member or [])

    def add_member(self, member_dn: str) -> None:
        """Добавляет участника в группу отдела.

        Args:
            member_dn: DN пользователя.

        Raises:
            RuntimeError: Если операция не удалась.
        """
        current = self.member or []
        if member_dn in current:
            return

        from ldap3 import MODIFY_ADD

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            ok = conn.modify(self.dn, {"member": [(MODIFY_ADD, [member_dn])]})
            if not ok:
                result_str = str(conn.result)
                if "attributeOrValueExists" not in result_str:
                    raise RuntimeError(f"add_member failed: {conn.result}")

    def remove_member(self, member_dn: str) -> None:
        """Удаляет участника из группы отдела.

        Args:
            member_dn: DN пользователя.

        Raises:
            RuntimeError: Если операция не удалась.
        """
        from ldap3 import MODIFY_DELETE

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            ok = conn.modify(self.dn, {"member": [(MODIFY_DELETE, [member_dn])]})
            if not ok:
                result_str = str(conn.result)
                if "noSuchAttribute" not in result_str:
                    raise RuntimeError(f"remove_member failed: {conn.result}")

    def sync_members(self, desired_dns: list[str]) -> dict:
        """Синхронизирует состав группы к точному списку.

        Добавляет недостающих, удаляет лишних.

        Args:
            desired_dns: Целевой список DN участников.

        Returns:
            dict: {'added': int, 'removed': int}
        """
        current = set(self.member or [])
        desired = set(desired_dns)

        to_add = desired - current
        to_remove = current - desired

        from ldap3 import MODIFY_ADD, MODIFY_DELETE

        from .infrastructure.connections import _ldap

        with _ldap() as conn:
            if to_remove:
                conn.modify(self.dn, {"member": [(MODIFY_DELETE, list(to_remove))]})
            if to_add:
                conn.modify(self.dn, {"member": [(MODIFY_ADD, list(to_add))]})

        return {
            "added": len(to_add),
            "removed": len(to_remove),
        }


class LdapOrganizationalUnit(ModifyDnMixin, LdapModel):
    """LDAP модель для Organizational Unit (отдел).

    Использует objectClass: top, organizationalUnit.
    Только для WRITE операций (POST/PUT/DELETE).

    Миксины:
    - ModifyDnMixin: поддержка перемещения между контейнерами через base_dn

    ВАЖНО О base_dn:
    - base_dn используется только для SUBTREE поиска
    - OU отделов располагаются под LDAP_DEPARTMENTS_BASE:
      OU=<DeptName>,OU=Departments,OU=company,...
    - При изменении base_dn ModifyDnMixin автоматически выполнит modify_dn!

    Операции через django-ldapdb:
    - CREATE: создание через .save() — работает с ORM
    - UPDATE: изменение через .save() (например, managedBy)
    - MOVE: ou.base_dn = new_dn; ou.save() (автоматический modify_dn!)
    - DELETE: удаление через ldap3.Connection.delete()

    Структура отдела в LDAP:
    OU=<DeptName>,OU=Departments,...  ← LdapOrganizationalUnit
      ├─ CN=DEP_<DeptName>            ← LdapOrganizationalUnitGroup (все члены)
      ├─ CN=ROLE_Manager              ← LdapGroup (роль)
      └─ CN=User1, CN=User2, ...      ← LdapUser (пользователи)

    Методы работы с группой OU (DEP_*):
    - get_department_group_dn() → DN группы OU
    - get_department_group() → LdapOrganizationalUnitGroup или None
    - ensure_department_group() →
      создаёт/возвращает LdapOrganizationalUnitGroup
    """

    # Базовая конфигурация
    base_dn = get_departments_base()
    object_classes = ["top", "organizationalUnit"]

    # RDN атрибут для построения Distinguished Name
    # Пример: ou=IT → dn=OU=IT,OU=Departments,DC=...
    rdn_attributes = ["ou"]

    # Основные атрибуты
    # dn: ldapdb.models.Model primary_key (DN)
    ou = CharField(db_column="ou")

    # Идентификация
    # objectGUID исключен из-за проблем с декодированием бинарных данных

    # Описание
    description = CharField(db_column="description", blank=True)

    # Управление (managedBy - DN руководителя)
    managed_by = CharField(db_column="managedBy", blank=True)

    # Временные метки
    when_created = DateTimeField(db_column="whenCreated")
    when_changed = DateTimeField(db_column="whenChanged")

    class Meta:
        managed = False

    def __str__(self):
        return f"OU: {self.ou}"

    def __repr__(self):
        return f"<LdapOrganizationalUnit: {self.ou}>"

    # ==================== Department Group Methods ==================== #

    def get_department_group_dn(self) -> str:
        """Возвращает ожидаемый DN группы отдела DEP_*.

        Группа отдела находится внутри OU отдела:
        CN=DEP_<DeptName>,OU=<DeptName>,OU=Departments,...

        Returns:
            str: DN группы отдела.
        """
        return f"CN=DEP_{self.ou},{self.dn}"

    def get_department_group(self):
        """Возвращает группу OU (DEP_*), если существует.

        Returns:
            LdapOrganizationalUnitGroup | None
        """
        try:
            return LdapOrganizationalUnitGroup.objects.get(
                dn=self.get_department_group_dn()
            )
        except LdapOrganizationalUnitGroup.DoesNotExist:
            return None

    def ensure_department_group(self):
        """Создаёт или возвращает группу OU (DEP_*).

        Если группа существует — возвращает её.
        Если нет — создаёт через low-level ldap3.

        Returns:
            LdapOrganizationalUnitGroup: Группа OU.

        Raises:
            RuntimeError: Если создание группы не удалось.
        """
        group = self.get_department_group()
        if group:
            return group

        from .infrastructure.connections import _ldap
        from .utils.ldap_utils import group_type
        from .utils.text_utils import esc_rdn

        cn = f"DEP_{self.ou}"
        group_dn = f"CN={esc_rdn(cn)},{self.dn}"

        with _ldap() as conn:
            attrs = {
                "sAMAccountName": cn[:20],
                "description": f"{self.ou} department members",
                "groupType": group_type("global", security_enabled=True),
            }
            ok = conn.add(group_dn, ["top", "group"], attrs)
            if not ok:
                res = str(conn.result)
                if "entryAlreadyExists" not in res:
                    raise RuntimeError(f"Failed to create dept group: {conn.result}")

        return LdapOrganizationalUnitGroup.objects.get(dn=group_dn)


__all__ = [
    "LdapUser",
    "LdapGroup",
    "LdapOrganizationalUnitGroup",
    "LdapOrganizationalUnit",
]