"""Admin-only API endpoints for managing users, doctors, reports, knowledge."""
from django.utils import timezone
from rest_framework.views import APIView

from core.models import (
    AppUser, Consultation, FeedPost, KnowledgeContent,
    KnowledgeTopic, Notification, PeriodLog, UserFeedback,
)
from .auth_utils import ok, err
from .permissions import IsAdminAppUser
from .serializers import (
    KnowledgeContentSerializer, KnowledgeTopicSerializer,
    UserFeedbackSerializer, UserPublicSerializer,
)


# ── Users ──────────────────────────────────────────────────────────────────────

class AdminUsersView(APIView):
    permission_classes = [IsAdminAppUser]

    def get(self, request):
        role = request.query_params.get('role')
        status = request.query_params.get('status')
        qs = AppUser.objects.all()
        if role:
            qs = qs.filter(role=role)
        if status:
            qs = qs.filter(status=status)
        return ok(UserPublicSerializer(qs[:200], many=True).data)


class AdminBanUserView(APIView):
    permission_classes = [IsAdminAppUser]

    def post(self, request):
        user_id = request.data.get('userId') or request.data.get('user_id')
        action = request.data.get('action', 'ban')  # 'ban' or 'unban'
        if not user_id:
            return err('userId is required.', 400)
        new_status = 'banned' if action == 'ban' else 'active'
        updated = AppUser.objects.filter(id=user_id).update(
            status=new_status, updated_at=timezone.now(),
        )
        if not updated:
            return err('User not found.', 404)
        return ok(message=f'User {new_status}.')


# ── Doctors ────────────────────────────────────────────────────────────────────

class AdminDoctorsView(APIView):
    permission_classes = [IsAdminAppUser]

    def get(self, request):
        doctors = AppUser.objects.filter(role='doctor')
        return ok(UserPublicSerializer(doctors, many=True).data)

    def post(self, request):
        from .auth_views import _user_dict
        from .auth_utils import hash_password
        d = request.data
        email = (d.get('email') or '').strip().lower()
        if AppUser.objects.filter(email=email).exists():
            return err('Email already registered.', 409)
        doctor = AppUser.objects.create(
            name=d.get('name', ''),
            email=email,
            password=hash_password(d.get('password', 'changeme123')),
            phone=d.get('phone', ''),
            bio=d.get('bio', ''),
            role='doctor',
            status='inactive',  # pending approval
            created_at=timezone.now(),
            updated_at=timezone.now(),
        )
        return ok(_user_dict(doctor), 'Doctor created.', 201)


class AdminApproveDoctorView(APIView):
    permission_classes = [IsAdminAppUser]

    def post(self, request, doctor_id):
        updated = AppUser.objects.filter(
            id=doctor_id, role='doctor',
        ).update(status='active', updated_at=timezone.now())
        if not updated:
            return err('Doctor not found.', 404)
        # Notify doctor
        Notification.objects.create(
            user_id=doctor_id,
            title='Account Approved',
            message='Your doctor account has been approved. You can now accept consultations.',
            type='alert',
            is_read=False,
            created_at=timezone.now(),
        )
        return ok(message='Doctor approved.')


class AdminRejectDoctorView(APIView):
    permission_classes = [IsAdminAppUser]

    def post(self, request, doctor_id):
        updated = AppUser.objects.filter(
            id=doctor_id, role='doctor',
        ).update(status='inactive', updated_at=timezone.now())
        if not updated:
            return err('Doctor not found.', 404)
        return ok(message='Doctor deactivated.')


# ── Reports ────────────────────────────────────────────────────────────────────

class AdminReportsView(APIView):
    permission_classes = [IsAdminAppUser]

    def get(self, request):
        total_users = AppUser.objects.filter(role='user').count()
        total_doctors = AppUser.objects.filter(role='doctor').count()
        active_doctors = AppUser.objects.filter(role='doctor', status='active').count()
        pending_doctors = AppUser.objects.filter(role='doctor', status='inactive').count()
        total_consultations = Consultation.objects.count()
        completed_consultations = Consultation.objects.filter(status='completed').count()
        total_posts = FeedPost.objects.count()
        total_period_logs = PeriodLog.objects.count()
        return ok({
            'users': {'total': total_users},
            'doctors': {
                'total': total_doctors,
                'active': active_doctors,
                'pending': pending_doctors,
            },
            'consultations': {
                'total': total_consultations,
                'completed': completed_consultations,
            },
            'content': {
                'feedPosts': total_posts,
                'periodLogs': total_period_logs,
            },
        })


# ── Knowledge (admin CRUD) ─────────────────────────────────────────────────────

class AdminKnowTopicsView(APIView):
    permission_classes = [IsAdminAppUser]

    def get(self, request):
        topics = KnowledgeTopic.objects.all()
        return ok(KnowledgeTopicSerializer(topics, many=True).data)

    def post(self, request):
        d = request.data
        topic = KnowledgeTopic.objects.create(
            title=d.get('title', ''),
            description=d.get('description', ''),
            status=d.get('status', 'active'),
            created_by=request.app_user,
            created_at=timezone.now(),
            updated_at=timezone.now(),
        )
        return ok(KnowledgeTopicSerializer(topic).data, 'Topic created.', 201)


class AdminKnowTopicDetailView(APIView):
    permission_classes = [IsAdminAppUser]

    def put(self, request, topic_id):
        updated = KnowledgeTopic.objects.filter(id=topic_id).update(
            **{k: v for k, v in request.data.items()
               if k in ('title', 'description', 'status')},
            updated_at=timezone.now(),
        )
        if not updated:
            return err('Topic not found.', 404)
        return ok(message='Topic updated.')

    def delete(self, request, topic_id):
        deleted, _ = KnowledgeTopic.objects.filter(id=topic_id).delete()
        if not deleted:
            return err('Topic not found.', 404)
        return ok(message='Topic deleted.')


class AdminKnowContentsView(APIView):
    permission_classes = [IsAdminAppUser]

    def get(self, request):
        contents = KnowledgeContent.objects.all()
        return ok(KnowledgeContentSerializer(contents, many=True).data)

    def post(self, request):
        d = request.data
        content = KnowledgeContent.objects.create(
            topic_id=d.get('topicId') or d.get('topic_id'),
            title=d.get('title', ''),
            content=d.get('content', ''),
            status=d.get('status', 'active'),
            created_by=request.app_user,
            created_at=timezone.now(),
            updated_at=timezone.now(),
        )
        return ok(KnowledgeContentSerializer(content).data, 'Content created.', 201)


class AdminKnowContentDetailView(APIView):
    permission_classes = [IsAdminAppUser]

    def put(self, request, content_id):
        updated = KnowledgeContent.objects.filter(id=content_id).update(
            **{k: v for k, v in request.data.items()
               if k in ('title', 'content', 'status')},
            updated_at=timezone.now(),
        )
        if not updated:
            return err('Content not found.', 404)
        return ok(message='Content updated.')

    def delete(self, request, content_id):
        deleted, _ = KnowledgeContent.objects.filter(id=content_id).delete()
        if not deleted:
            return err('Content not found.', 404)
        return ok(message='Content deleted.')
