import datetime
from django.utils import timezone
from django.contrib.auth import login, logout, get_user_model
from django.contrib.sessions.models import Session
from django.views.decorators.csrf import ensure_csrf_cookie
from django.utils.decorators import method_decorator
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import AllowAny, IsAuthenticated

from core.exceptions import format_error_response
from core.permissions import IsVerified, IsNotSuspended
from messaging.models import Inbox
from .models import Profile, EmailJob
from .serializers import (
    RegisterSerializer, LoginSerializer, UserSerializer,
    ProfileSerializer, ChangeUsernameSerializer, ChangeEmailSerializer,
    DeleteAccountSerializer, UserSessionSerializer, BlockedEmailDomainSerializer
)
from .services import (
    queue_verification_email, verify_verification_token,
    queue_password_reset_email, verify_password_reset_token,
    pwd_reset_token_generator, is_disposable_domain, track_session,
    list_sessions, revoke_other_sessions, change_password,
    add_blocked_domain, remove_blocked_domain, get_and_clear_warning
)

User = get_user_model()

class CSRFTokenView(APIView):
    permission_classes = [AllowAny]

    @method_decorator(ensure_csrf_cookie)
    def get(self, request):
        return Response({"detail": "CSRF cookie set"})


class RegisterView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        email_input = request.data.get('email', '')
        if is_disposable_domain(email_input):
            return format_error_response("email_domain_blocked", "Email domain is blocked.", status_code=status.HTTP_400_BAD_REQUEST)

        serializer = RegisterSerializer(data=request.data)
        if not serializer.is_valid():
            # Check for non_field_errors == registration_failed
            if "non_field_errors" in serializer.errors:
                return format_error_response("registration_failed", "Registration failed.", status_code=status.HTTP_400_BAD_REQUEST)
            # Otherwise field errors
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Validation failed.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        user = User.objects.create_user(
            username=data['username'],
            email=data['email'],
            password=data['password']
        )
        first_name = (data.get('first_name') or '').strip()
        last_name = (data.get('last_name') or '').strip()
        full_name = f"{first_name} {last_name}".strip()
        display_name = full_name if full_name else user.username

        Profile.objects.create(user=user, display_name=display_name[:50])
        Inbox.objects.create(owner=user, slug=user.username)
        queue_verification_email(user)

        # Log user in so session is established (allows unverified user to change email / resend)
        login(request, user)
        track_session(user, request)

        return Response({
            "message": "User registered successfully. Verification email queued.",
            "user": {
                "id": user.id,
                "username": user.username,
                "email": user.email
            }
        }, status=status.HTTP_201_CREATED)


class LoginView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        serializer = LoginSerializer(data=request.data, context={'request': request})
        if not serializer.is_valid():
            errors = serializer.errors
            # Check if locked_until is present in field errors dict
            if 'locked_until' in errors:
                locked_val = str(errors['locked_until'][0] if isinstance(errors['locked_until'], list) else errors['locked_until'])
                resp = format_error_response("invalid_credentials", "Invalid credentials provided.", status_code=status.HTTP_401_UNAUTHORIZED)
                resp.data['error']['locked_until'] = locked_val
                return resp

            non_field = errors.get('non_field_errors', [])
            if non_field:
                err_item = non_field[0]
                if isinstance(err_item, dict) and err_item.get('code') == 'invalid_credentials':
                    locked_until = err_item.get('locked_until')
                    resp = format_error_response("invalid_credentials", "Invalid credentials provided.", status_code=status.HTTP_401_UNAUTHORIZED)
                    if locked_until:
                        resp.data['error']['locked_until'] = locked_until
                    return resp
                err_msg = str(err_item)
                if err_msg == 'account_suspended':
                    return format_error_response("account_suspended", "Your account has been suspended.", status_code=status.HTTP_403_FORBIDDEN)
            return format_error_response("invalid_credentials", "Invalid credentials provided.", status_code=status.HTTP_401_UNAUTHORIZED)

        user = serializer.validated_data['user']
        login(request, user)
        # Mobile clients stay logged in indefinitely (10 years) until explicit logout.
        # Web clients default to 7-day inactivity sliding session.
        is_mobile = request.data.get('remember_me') or 'Dart' in request.META.get('HTTP_USER_AGENT', '')
        if is_mobile:
            request.session.set_expiry(10 * 365 * 24 * 60 * 60)  # 10 years
        else:
            request.session.set_expiry(7 * 24 * 60 * 60)         # 7 days

        track_session(user, request)
        return Response({
            "message": "Logged in successfully.",
            "user": UserSerializer(user).data
        })


class LogoutView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request):
        logout(request)
        return Response({"message": "Logged out successfully."})


class VerifyEmailView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        code = request.data.get('code')
        token = request.data.get('token')
        email = request.data.get('email')

        # 1. Verification by 6-digit code
        if code:
            code_str = str(code).strip()
            # If email is provided, prioritize it (useful when switching/verifying multiple users or in test clients)
            user = None
            if email:
                user = User.objects.filter(email=email.strip().lower()).first()
            elif request.user.is_authenticated:
                user = request.user

            if not user:
                return format_error_response(
                    "missing_email",
                    "Email address or active session is required to verify code.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

            if user.email_verified:
                return format_error_response(
                    "already_verified",
                    "Email is already verified.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

            if not user.verification_code or user.verification_code != code_str:
                return format_error_response(
                    "invalid_code",
                    "Invalid 6-digit verification code.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

            if user.verification_code_expires_at and user.verification_code_expires_at < timezone.now():
                return format_error_response(
                    "expired_code",
                    "Verification code has expired. Please request a new one.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

            # Code matches and is valid
            user.email_verified = True
            user.verification_code = None
            user.verification_code_expires_at = None
            user.save(update_fields=['email_verified', 'verification_code', 'verification_code_expires_at'])
            return Response({"message": "Email verified successfully."})

        # 2. Legacy verification by token (for backwards compatibility)
        if token:
            user_id, email_token = verify_verification_token(token)
            if not user_id:
                return format_error_response("invalid_or_expired_token", "Verification token is invalid or expired.", status_code=status.HTTP_400_BAD_REQUEST)

            user = User.objects.filter(id=user_id, email=email_token).first()
            if not user:
                return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

            if user.email_verified:
                return format_error_response("already_verified", "Token already used or expired.", status_code=status.HTTP_400_BAD_REQUEST)

            user.email_verified = True
            user.verification_code = None
            user.verification_code_expires_at = None
            user.save(update_fields=['email_verified', 'verification_code', 'verification_code_expires_at'])
            return Response({"message": "Email verified successfully."})

        return format_error_response("code_required", "Verification code is required.", status_code=status.HTTP_400_BAD_REQUEST)


class ResendVerificationView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        user = None
        if request.user.is_authenticated:
            user = request.user
        else:
            email = request.data.get('email')
            if email:
                user = User.objects.filter(email=email.strip().lower()).first()

        if not user:
            return format_error_response("user_not_found", "User not found or email required.", status_code=status.HTTP_400_BAD_REQUEST)

        if user.email_verified:
            return format_error_response("already_verified", "Email is already verified.", status_code=status.HTTP_400_BAD_REQUEST)

        # Check 5 minutes rule
        five_mins_ago = timezone.now() - datetime.timedelta(minutes=5)
        recent_job = EmailJob.objects.filter(
            to_email=user.email,
            subject="Your verification code",
            created_at__gte=five_mins_ago
        ).exists() or EmailJob.objects.filter(
            to_email=user.email,
            subject="Verify your email address",
            created_at__gte=five_mins_ago
        ).exists()

        if recent_job:
            return format_error_response("rate_limited", "Verification email was sent recently. Please wait 5 minutes before resending.", status_code=status.HTTP_429_TOO_MANY_REQUESTS)

        queue_verification_email(user)
        return Response({"message": "Verification email queued."})


class ChangeEmailView(APIView):
    permission_classes = [IsAuthenticated, IsNotSuspended]

    def post(self, request):
        user = request.user
        serializer = ChangeEmailSerializer(data=request.data)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Invalid email address.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        new_email = serializer.validated_data['email']
        user.email = new_email
        user.email_verified = False
        user.save(update_fields=['email', 'email_verified'])

        # Queue verification for the new email
        queue_verification_email(user)

        return Response({
            "message": "Email address updated and verification email queued.",
            "email": new_email
        })


class PasswordResetRequestView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        email = (request.data.get('email') or '').strip().lower()
        if email:
            user = User.objects.filter(email=email).first()
            if user:
                queue_password_reset_email(user)

        # Always return identical response to prevent enumeration
        return Response({
            "message": "If that email address is in our system, we have queued a password reset link."
        })


class PasswordResetConfirmView(APIView):
    permission_classes = [AllowAny]

    def post(self, request):
        token = request.data.get('token')
        new_password = request.data.get('password')

        if not token or not new_password:
            return format_error_response("validation_error", "Token and new password are required.", status_code=status.HTTP_400_BAD_REQUEST)

        user_id, pwd_token = verify_password_reset_token(token)
        if not user_id:
            return format_error_response("invalid_or_expired_token", "Password reset token is invalid or expired.", status_code=status.HTTP_400_BAD_REQUEST)

        user = User.objects.filter(id=user_id).first()
        if not user or not pwd_reset_token_generator.check_token(user, pwd_token):
            return format_error_response("invalid_or_expired_token", "Password reset token is invalid or expired.", status_code=status.HTTP_400_BAD_REQUEST)

        if len(new_password) < 10:
            return format_error_response("validation_error", "Password must be at least 10 characters.", fields={"password": "Password must be at least 10 characters."}, status_code=status.HTTP_400_BAD_REQUEST)

        user.set_password(new_password)
        user.save()

        # Invalidate all existing sessions
        for session in Session.objects.all():
            data = session.get_decoded()
            if str(data.get('_auth_user_id')) == str(user.id):
                session.delete()

        return Response({"message": "Password has been successfully reset. Please log in with your new password."})


from rest_framework.parsers import MultiPartParser, FormParser, JSONParser

class MeView(APIView):
    permission_classes = [IsAuthenticated, IsNotSuspended]
    parser_classes = [MultiPartParser, FormParser, JSONParser]

    def get(self, request):
        return Response(UserSerializer(request.user, context={'request': request}).data)

    def patch(self, request):
        profile, _ = Profile.objects.get_or_create(user=request.user)
        serializer = ProfileSerializer(profile, data=request.data, partial=True, context={'request': request})
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Invalid profile data.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)
        serializer.save()
        return Response(UserSerializer(request.user, context={'request': request}).data)



class ChangeUsernameView(APIView):
    permission_classes = [IsVerified]

    def post(self, request):
        user = request.user
        # 30-day rule check
        if user.username_changed_at:
            days_since = (timezone.now() - user.username_changed_at).days
            if days_since < 30:
                return format_error_response(
                    "username_change_cooldown",
                    f"Username can only be changed once every 30 days. Please wait {30 - days_since} more days.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

        serializer = ChangeUsernameSerializer(data=request.data)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Invalid username.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        new_username = serializer.validated_data['username']
        user.username = new_username
        user.username_changed_at = timezone.now()
        user.save(update_fields=['username', 'username_changed_at'])

        # Update inbox slug as well per F4
        inbox = Inbox.objects.filter(owner=user).first()
        if inbox:
            inbox.slug = new_username
            inbox.save(update_fields=['slug'])

        return Response({
            "message": "Username changed successfully.",
            "username": new_username
        })


class DeleteAccountView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request):
        user = request.user

        # Acceptance Criteria 42 safeguard: last remaining active admin cannot delete account
        if user.role == 'admin':
            admin_count = User.objects.filter(role='admin', is_active=True).count()
            if admin_count <= 1:
                return format_error_response(
                    "last_admin_demotion",
                    "The last remaining admin account cannot be deleted.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

        serializer = DeleteAccountSerializer(data=request.data)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Password is required to delete account.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        password = serializer.validated_data['password']
        if not user.check_password(password):
            return format_error_response("invalid_credentials", "Incorrect password.", status_code=status.HTTP_400_BAD_REQUEST)

        # Invalidate sessions before deleting user
        user_id_str = str(user.id)
        for session in Session.objects.all():
            try:
                data = session.get_decoded()
                if str(data.get('_auth_user_id')) == user_id_str:
                    session.delete()
            except Exception:
                pass

        logout(request)
        user.delete()

        return Response({"message": "Account deleted successfully."})


# ==========================================
# Phase 2 Accounts Views
# ==========================================

from core.permissions import IsAdminRole


class SessionsView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        sessions = list_sessions(request.user)
        serializer = UserSessionSerializer(sessions, many=True, context={'request': request})
        return Response({'results': serializer.data})


class RevokeOtherSessionsView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request):
        current_session_key = request.session.session_key
        revoke_other_sessions(request.user, current_session_key)
        return Response({"message": "All other sessions have been signed out."})


class ChangePasswordView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request):
        current_password = request.data.get('current_password')
        new_password = request.data.get('new_password')

        if not current_password:
            return format_error_response("validation_error", "Current password is required.", fields={'current_password': 'required'}, status_code=status.HTTP_400_BAD_REQUEST)

        if not new_password or len(new_password) < 10:
            return format_error_response("validation_error", "New password must be at least 10 characters.", fields={'new_password': 'too_short'}, status_code=status.HTTP_400_BAD_REQUEST)

        from django.contrib.auth.password_validation import validate_password
        from django.core.exceptions import ValidationError as DjangoValidationError
        try:
            validate_password(new_password, user=request.user)
        except DjangoValidationError as e:
            return format_error_response("validation_error", list(e.messages)[0], fields={'new_password': list(e.messages)[0]}, status_code=status.HTTP_400_BAD_REQUEST)

        current_session_key = request.session.session_key
        success, err = change_password(request.user, current_password, new_password, current_session_key=current_session_key)
        if not success:
            return format_error_response("invalid_current_password", "Current password does not match.", fields={'current_password': 'invalid'}, status_code=status.HTTP_400_BAD_REQUEST)

        # Keep current session logged in
        login(request, request.user)
        return Response({"message": "Password changed successfully."})


class BlockedDomainsView(APIView):
    permission_classes = [IsAdminRole]

    def get(self, request):
        from accounts.models import BlockedEmailDomain
        domains = BlockedEmailDomain.objects.all().order_by('-created_at')
        serializer = BlockedEmailDomainSerializer(domains, many=True)
        return Response({'results': serializer.data})

    def post(self, request):
        domain = request.data.get('domain', '').strip().lower()
        if not domain or '.' not in domain:
            return format_error_response("validation_error", "A valid domain name is required.", fields={'domain': 'invalid'}, status_code=status.HTTP_400_BAD_REQUEST)

        obj = add_blocked_domain(request.user, domain)
        return Response(BlockedEmailDomainSerializer(obj).data, status=status.HTTP_201_CREATED)


class BlockedDomainDetailView(APIView):
    permission_classes = [IsAdminRole]

    def delete(self, request, pk):
        from accounts.models import BlockedEmailDomain
        from django.shortcuts import get_object_or_404
        domain_obj = get_object_or_404(BlockedEmailDomain, pk=pk)
        remove_blocked_domain(request.user, domain_obj)
        return Response(status=status.HTTP_204_NO_CONTENT)


class MeWarningView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        warning = get_and_clear_warning(request.user)
        return Response({'warning': warning})


class SuggestedUsersView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        """Returns up to 8 suggested users excluding the current user."""
        current_user = request.user
        users = (
            User.objects.filter(is_active=True, email_verified=True)
            .exclude(id=current_user.id)
            .select_related('profile')
            .order_by('-date_joined')[:8]
        )
        data = []
        for u in users:
            disp_name = (
                getattr(u, 'display_name', '')
                or (hasattr(u, 'profile') and u.profile and u.profile.display_name)
                or u.username
            )
            bio = (hasattr(u, 'profile') and u.profile and u.profile.bio) or 'Member of chithie'
            data.append({
                'id': u.id,
                'username': u.username,
                'display_name': disp_name,
                'note': bio[:40] if bio else 'Member of chithie',
            })
        return Response({'results': data})


class PublicUserProfileView(APIView):
    permission_classes = [AllowAny]

    def get(self, request, username):
        """Public profile view for any user by username."""
        user_obj = (
            User.objects.filter(username__iexact=username, is_active=True)
            .select_related('profile')
            .first()
        )
        if not user_obj:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        if getattr(user_obj, 'is_suspended', False):
            return format_error_response("user_suspended", "This user profile is currently unavailable.", status_code=status.HTTP_404_NOT_FOUND)

        # Look up inbox settings if available
        inbox_exists = False
        anonymous_enabled = True
        try:
            inbox = Inbox.objects.filter(owner=user_obj).first()
            if inbox:
                inbox_exists = True
                anonymous_enabled = inbox.anonymous_enabled
        except Exception:
            pass

        avatar_url = None
        cover_url = None
        display_name = user_obj.username
        bio = ''

        if hasattr(user_obj, 'profile') and user_obj.profile:
            display_name = user_obj.profile.display_name or user_obj.username
            bio = user_obj.profile.bio or ''
            if user_obj.profile.avatar:
                avatar_url = request.build_absolute_uri(user_obj.profile.avatar.url)
            if user_obj.profile.cover:
                cover_url = request.build_absolute_uri(user_obj.profile.cover.url)

        return Response({
            'username': user_obj.username,
            'display_name': display_name,
            'bio': bio,
            'avatar_url': avatar_url,
            'cover_url': cover_url,
            'date_joined': user_obj.date_joined,
            'anonymous_enabled': anonymous_enabled,
            'inbox_exists': inbox_exists,
        })




