"""
Chat Service — REST API Views.
"""
import logging

from rest_framework import status, viewsets
from rest_framework.decorators import action
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView

from apps.core.auth.models import User

from .models import (
    Channel,
    ChannelMember,
    Message,
    UserPresence,
)
from .serializers import (
    AddMemberSerializer,
    ChannelCreateSerializer,
    ChannelDetailSerializer,
    ChannelListSerializer,
    ChannelMemberSerializer,
    DirectChatSerializer,
    EditMessageSerializer,
    MarkReadSerializer,
    MessageSerializer,
    SearchMessageSerializer,
    SendMessageSerializer,
    SetPresenceSerializer,
    UserPresenceSerializer,
)
from .services import ChannelService, MessageService, PresenceService

logger = logging.getLogger('apps')


# ══════════════════════════════════════════════════════════════
# Channel API
# ══════════════════════════════════════════════════════════════

class ChannelViewSet(viewsets.ModelViewSet):
    """مدیریت کانال‌های چت."""
    permission_classes = [IsAuthenticated]
    filterset_fields = ['channel_type', 'visibility', 'is_archived']
    search_fields = ['name', 'description']
    ordering_fields = ['last_message_at', 'created_at', 'name']
    ordering = ['-last_message_at']

    def get_queryset(self):
        return ChannelService.list_user_channels(
            user=self.request.user,
            tenant=self.request.user.tenant,
        )

    def get_serializer_class(self):
        if self.action == 'retrieve':
            return ChannelDetailSerializer
        if self.action == 'create':
            return ChannelCreateSerializer
        return ChannelListSerializer

    def create(self, request):
        serializer = ChannelCreateSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        d = serializer.validated_data

        channel = ChannelService.create_channel(
            tenant=request.user.tenant,
            user=request.user,
            name=d['name'],
            channel_type=d['channel_type'],
            visibility=d.get('visibility', 'private'),
            description=d.get('description', ''),
            member_ids=d.get('member_ids', []),
            source_type=d.get('source_type', ''),
            source_id=d.get('source_id'),
        )
        return Response(
            {'data': ChannelDetailSerializer(channel, context={'request': request}).data},
            status=status.HTTP_201_CREATED,
        )

    def update(self, request, *args, **kwargs):
        channel = self.get_object()
        channel = ChannelService.update_channel(channel, **request.data)
        return Response(
            {'data': ChannelDetailSerializer(channel, context={'request': request}).data},
        )

    # --- Members ---
    @action(detail=True, methods=['get'])
    def members(self, request, pk=None):
        """لیست اعضای کانال."""
        channel = self.get_object()
        members = ChannelService.get_members(channel)
        return Response({'data': ChannelMemberSerializer(members, many=True).data})

    @action(detail=True, methods=['post'], url_path='add-member')
    def add_member(self, request, pk=None):
        """اضافه کردن عضو."""
        channel = self.get_object()
        serializer = AddMemberSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        user = User.objects.get(
            id=serializer.validated_data['user_id'],
            tenant=request.user.tenant,
        )
        member = ChannelService.add_member(
            tenant=request.user.tenant,
            channel=channel,
            user=user,
            role=serializer.validated_data.get('role', 'member'),
        )
        return Response({'data': ChannelMemberSerializer(member).data})

    @action(detail=True, methods=['post'], url_path='remove-member')
    def remove_member(self, request, pk=None):
        """خروج عضو از کانال."""
        channel = self.get_object()
        user_id = request.data.get('user_id', request.user.id)
        try:
            user = User.objects.get(id=user_id, tenant=request.user.tenant)
        except User.DoesNotExist:
            return Response(
                {'error': {'code': 'user_not_found', 'message': 'کاربر یافت نشد.'}},
                status=status.HTTP_404_NOT_FOUND,
            )
        ChannelService.remove_member(channel, user)
        return Response({'data': {'message': 'عضو از کانال خارج شد.'}})

    @action(detail=True, methods=['post'])
    def archive(self, request, pk=None):
        """آرشیو کردن کانال."""
        channel = self.get_object()
        channel = ChannelService.update_channel(channel, is_archived=True)
        return Response({'data': {'message': 'کانال آرشیو شد.'}})

    # --- Messages ---
    @action(detail=True, methods=['get'])
    def messages(self, request, pk=None):
        """لیست پیام‌های کانال."""
        channel = self.get_object()
        before = request.query_params.get('before')
        limit = min(int(request.query_params.get('limit', 50)), 100)

        messages = MessageService.get_messages(channel, before=before, limit=limit)
        return Response({'data': MessageSerializer(messages, many=True).data})

    @action(detail=True, methods=['post'], url_path='send')
    def send_message(self, request, pk=None):
        """ارسال پیام."""
        channel = self.get_object()
        serializer = SendMessageSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        d = serializer.validated_data

        message = MessageService.send_message(
            tenant=request.user.tenant,
            channel=channel,
            sender=request.user,
            content=d['content'],
            message_type=d.get('message_type', 'text'),
            reply_to_id=d.get('reply_to'),
            attachments=d.get('attachments'),
        )
        return Response(
            {'data': MessageSerializer(message).data},
            status=status.HTTP_201_CREATED,
        )

    @action(detail=True, methods=['post'], url_path='mark-read')
    def mark_read(self, request, pk=None):
        """علامت خوانده‌شدن."""
        channel = self.get_object()
        serializer = MarkReadSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        try:
            message = Message.objects.get(
                id=serializer.validated_data['message_id'],
                channel=channel,
            )
        except Message.DoesNotExist:
            return Response(
                {'error': {'code': 'message_not_found', 'message': 'پیام یافت نشد.'}},
                status=status.HTTP_404_NOT_FOUND,
            )

        MessageService.mark_read(
            tenant=request.user.tenant,
            channel=channel,
            user=request.user,
            message=message,
        )
        return Response({'data': {'message': 'خوانده شد.'}})

    @action(detail=True, methods=['post'])
    def search(self, request, pk=None):
        """جستجو در پیام‌ها."""
        channel = self.get_object()
        serializer = SearchMessageSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        messages = MessageService.search_messages(
            channel=channel,
            query=serializer.validated_data['query'],
        )
        return Response({'data': MessageSerializer(messages, many=True).data})


# ══════════════════════════════════════════════════════════════
# Direct Chat API
# ══════════════════════════════════════════════════════════════

class DirectChatView(APIView):
    """دریافت/ایجاد چت خصوصی بین دو کاربر."""
    permission_classes = [IsAuthenticated]

    def post(self, request):
        serializer = DirectChatSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        try:
            other_user = User.objects.get(
                id=serializer.validated_data['user_id'],
                tenant=request.user.tenant,
            )
        except User.DoesNotExist:
            return Response(
                {'error': {'code': 'user_not_found', 'message': 'کاربر یافت نشد.'}},
                status=status.HTTP_404_NOT_FOUND,
            )

        channel = ChannelService.get_or_create_direct(
            tenant=request.user.tenant,
            user1=request.user,
            user2=other_user,
        )
        return Response(
            {'data': ChannelDetailSerializer(channel, context={'request': request}).data},
        )


# ══════════════════════════════════════════════════════════════
# Message Actions API
# ══════════════════════════════════════════════════════════════

class MessageViewSet(viewsets.GenericViewSet):
    """عملیات روی پیام‌ها (ویرایش/حذف)."""
    permission_classes = [IsAuthenticated]
    serializer_class = MessageSerializer

    def get_queryset(self):
        return Message.objects.filter(
            tenant=self.request.user.tenant,
            is_deleted=False,
        )

    @action(detail=True, methods=['patch'])
    def edit(self, request, pk=None):
        """ویرایش پیام."""
        message = self.get_object()
        if message.sender != request.user:
            return Response(
                {'error': {'code': 'forbidden', 'message': 'فقط فرستنده می‌تواند ویرایش کند.'}},
                status=status.HTTP_403_FORBIDDEN,
            )
        serializer = EditMessageSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        message = MessageService.edit_message(message, serializer.validated_data['content'])
        return Response({'data': MessageSerializer(message).data})

    @action(detail=True, methods=['delete'], url_path='soft-delete')
    def soft_delete(self, request, pk=None):
        """حذف نرم پیام."""
        message = self.get_object()
        if message.sender != request.user:
            return Response(
                {'error': {'code': 'forbidden', 'message': 'فقط فرستنده می‌تواند حذف کند.'}},
                status=status.HTTP_403_FORBIDDEN,
            )
        MessageService.delete_message(message)
        return Response({'data': {'message': 'پیام حذف شد.'}})


# ══════════════════════════════════════════════════════════════
# Presence API
# ══════════════════════════════════════════════════════════════

class PresenceViewSet(viewsets.GenericViewSet):
    """مدیریت حضور آنلاین."""
    permission_classes = [IsAuthenticated]
    serializer_class = UserPresenceSerializer

    def get_queryset(self):
        return UserPresence.objects.filter(tenant=self.request.user.tenant)

    @action(detail=False, methods=['get'], url_path='online')
    def online_users(self, request):
        """لیست کاربران آنلاین."""
        users = PresenceService.get_online_users(tenant=request.user.tenant)
        return Response({'data': UserPresenceSerializer(users, many=True).data})

    @action(detail=False, methods=['post'], url_path='set-status')
    def set_status(self, request):
        """تنظیم وضعیت حضور."""
        serializer = SetPresenceSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        PresenceService.set_status(
            tenant=request.user.tenant,
            user=request.user,
            status_value=serializer.validated_data['status'],
            custom_status=serializer.validated_data.get('custom_status', ''),
        )
        return Response({'data': {'message': 'وضعیت تنظیم شد.'}})

    @action(detail=False, methods=['get'])
    def me(self, request):
        """وضعیت فعلی من."""
        presence = PresenceService.get_user_presence(request.user)
        if presence:
            return Response({'data': UserPresenceSerializer(presence).data})
        return Response({'data': None})
