from django.contrib.auth import get_user_model
from rest_framework import generics, filters
from apps.permissions.permissions import CompanyPermission
from rest_framework.exceptions import NotFound

from django.db.models.functions import Concat, Coalesce
from apps.permissions.models import UserCompanyRole
from apps.companies.models import Company
from apps.core.serializers.companyuserlist import CompanyUserSerializer
from rest_framework import generics
from utils.paginations import LimitOffsetPagination
from django.db.models import F, Value, Prefetch, Count


User = get_user_model()


class CompanyUsersView(generics.ListAPIView):
    """List all users in a specific company"""
    serializer_class = CompanyUserSerializer
    pagination_class = LimitOffsetPagination
    filter_backends = [filters.OrderingFilter, filters.SearchFilter]

    ordering_fields = ['full_name', 'email', 'profile__phone_number', 'companies_count']
    ordering = ['-created_at']

    search_fields = [
        'full_name',
        'email',
        'profile__phone_number',
    ]

    def get_permissions(self):
        return [CompanyPermission('view_users')]

    def get_company(self):
        """Get company based on user type and parameters."""
        user = self.request.user
        company_id = self.request.query_params.get('company_id')

        target_company_id = company_id or getattr(user.active_company, 'id', None)

        if not target_company_id:
            raise NotFound("No company id provided or user has no active company.")

        try:
            company = Company.objects.get(id=target_company_id)
        except Company.DoesNotExist:
            raise NotFound("Company not found.")

        return company

    def get_serializer_context(self):
        context = super().get_serializer_context()
        try:
            company = self.get_company()
        except NotFound:
            company = None
        context['company'] = company
        return context

    def get_queryset(self):
        """Get users from the specified company - assumes company is valid"""
        user = self.request.user
        company_id = self.request.query_params.get('company_id')

        if getattr(user, "user_type", None) == "super_admin" and company_id is None:
            return User.objects.select_related('profile').all()

        company = self.get_company()

        role_prefetch = Prefetch(
            'company_roles',
            queryset=UserCompanyRole.objects
            .select_related('role', 'company')
            .filter(is_active=True),
            to_attr='_cached_roles'
        )

        queryset = company.users.annotate(
            full_name=Concat(
                Coalesce(F('profile__first_name'), Value('')),
                Value(' '),
                Coalesce(F('profile__last_name'), Value('')),
            ),
            companies_count=Count('companies')
        ).select_related(
            'profile'
        ).prefetch_related(
            role_prefetch
        )

        if company and company.id:
            queryset = queryset.filter(companies=company)

        return queryset