import time
import logging
from django.core.signing import TimestampSigner, BadSignature, SignatureExpired
from django.contrib.auth.tokens import PasswordResetTokenGenerator
from django.core.mail import EmailMessage, get_connection
from django.utils import timezone
from django.conf import settings
from .models import EmailJob

import random
import datetime

logger = logging.getLogger(__name__)

signer = TimestampSigner()
pwd_reset_token_generator = PasswordResetTokenGenerator()

def generate_verification_code():
    """Generate a random secure 6-digit code."""
    return f"{random.randint(100000, 999999)}"

def generate_verification_token(user):
    """
    Generate signed token for email verification, valid for 24h.
    Uses user id and a salt. Kept for backwards compatibility and tests.
    """
    return signer.sign(f"{user.id}:{user.email}")

def verify_verification_token(token, max_age=86400):
    """
    Verify verification token. Returns (user_id, email) or (None, None).
    max_age=86400 (24 hours).
    """
    try:
        data = signer.unsign(token, max_age=max_age)
        user_id_str, email = data.split(':', 1)
        return int(user_id_str), email
    except (BadSignature, SignatureExpired, ValueError):
        return None, None

def dispatch_email_job(job):
    """
    Attempt immediate sending of an EmailJob row so user receives it instantly.
    If it fails, leaves the job as 'pending' for the background cron to retry.
    """
    try:
        try:
            from django.core.mail import mailers
            connection = mailers.default
        except (ImportError, AttributeError):
            connection = get_connection()

        job.attempts += 1
        msg = EmailMessage(
            subject=job.subject,
            body=job.body_text,
            to=[job.to_email],
            connection=connection,
        )
        msg.send(fail_silently=False)
        job.status = 'sent'
        job.sent_at = timezone.now()
        job.last_error = ''
        job.save(update_fields=['status', 'sent_at', 'attempts', 'last_error'])
        return True
    except Exception as exc:
        job.last_error = str(exc)
        if job.attempts >= 3:
            job.status = 'failed'
        job.save(update_fields=['status', 'attempts', 'last_error'])
        logger.warning(f"Immediate email delivery attempt failed for {job.to_email}: {exc}")
        return False

def queue_verification_email(user, immediate=True):
    code = generate_verification_code()
    # Code valid for 24 hours
    user.verification_code = code
    user.verification_code_expires_at = timezone.now() + datetime.timedelta(hours=24)
    user.save(update_fields=['verification_code', 'verification_code_expires_at'])

    token = generate_verification_token(user)

    subject = "Your verification code"
    body = (
        f"Hello {user.username},\n\n"
        f"Your 6-digit verification code is:\n\n"
        f"    {code}\n\n"
        f"Enter this code on the verification screen to verify your email address.\n"
        f"This code will expire in 24 hours.\n\n"
        f"Thank you!"
    )
    
    job = EmailJob.objects.create(
        to_email=user.email,
        subject=subject,
        body_text=body,
        status='pending'
    )
    if immediate:
        dispatch_email_job(job)
    return job

def queue_password_reset_email(user, immediate=True):
    token = pwd_reset_token_generator.make_token(user)
    signed_payload = signer.sign(f"{user.id}:{token}")
    link = f"{settings.SITE_URL}/reset-password?token={signed_payload}"
    subject = "Password Reset Request"
    body = f"Hello {user.username},\n\nYou requested a password reset. Please use the following link to reset your password:\n\n{link}\n\nThis link is valid for 1 hour.\n\nIf you did not make this request, you can safely ignore this email."
    
    job = EmailJob.objects.create(
        to_email=user.email,
        subject=subject,
        body_text=body,
        status='pending'
    )
    if immediate:
        dispatch_email_job(job)
    return job

def verify_password_reset_token(token_string, max_age=3600):
    """
    Verify reset token within 1 hour.
    Returns (user_id, user_token) or (None, None).
    """
    try:
        data = signer.unsign(token_string, max_age=max_age)
        user_id_str, user_token = data.split(':', 1)
        return int(user_id_str), user_token
    except (BadSignature, SignatureExpired, ValueError):
        return None, None


# ==========================================
# Phase 2 Additions
# ==========================================

from django.core.cache import cache
from accounts.models import UserSession, BlockedEmailDomain
from core.security_services import log_security_event, log_audit


def record_failed_login(user, request=None):
    """
    Increment failed_login_count.
    After 5 failed logins for one account in 15 minutes, lock for 15 minutes.
    Each further lock doubles the wait, up to 24 hours.
    Lock writes 'account_locked'.
    Returns locked_until datetime if locked, else None.
    """
    if not user:
        return None

    user.failed_login_count = (user.failed_login_count or 0) + 1
    locked_until = None

    if user.failed_login_count >= 5:
        lock_count = (user.lock_count or 0) + 1
        user.lock_count = lock_count

        # Base wait 15 minutes, doubles each lock (15, 30, 60, 120, ... max 24 hours = 1440 min)
        wait_minutes = min(15 * (2 ** (lock_count - 1)), 1440)
        locked_until = timezone.now() + datetime.timedelta(minutes=wait_minutes)
        user.locked_until = locked_until
        user.failed_login_count = 0  # reset window counter on lock

        log_security_event(
            event_type='account_locked',
            request=request,
            user=user,
            meta={'lock_count': lock_count, 'wait_minutes': wait_minutes, 'locked_until': locked_until.isoformat()}
        )

    user.save(update_fields=['failed_login_count', 'lock_count', 'locked_until'])
    return locked_until


def reset_failed_login(user):
    """Reset failed login count on successful authentication."""
    if user and (user.failed_login_count != 0 or user.locked_until is not None):
        user.failed_login_count = 0
        user.locked_until = None
        user.save(update_fields=['failed_login_count', 'locked_until'])


def is_account_locked(user):
    """Check if account is currently locked. Returns (is_locked, locked_until)."""
    if not user or not user.locked_until:
        return False, None

    if timezone.now() < user.locked_until:
        return True, user.locked_until

    # Lock expired
    user.locked_until = None
    user.save(update_fields=['locked_until'])
    return False, None


def track_session(user, request):
    """Upsert UserSession record for current request session."""
    if not user or not request or not hasattr(request, 'session'):
        return None

    session_key = request.session.session_key
    if not session_key:
        request.session.save()
        session_key = request.session.session_key

    user_agent = request.META.get('HTTP_USER_AGENT', 'Unknown')[:60]

    session_obj, created = UserSession.objects.update_or_create(
        session_key=session_key,
        defaults={
            'user': user,
            'device_label': user_agent,
            'last_seen_at': timezone.now()
        }
    )
    return session_obj


def list_sessions(user):
    return UserSession.objects.filter(user=user).order_by('-last_seen_at')


def revoke_other_sessions(user, current_session_key):
    """Revoke all sessions for user except current_session_key."""
    from django.contrib.sessions.models import Session
    other_user_sessions = UserSession.objects.filter(user=user).exclude(session_key=current_session_key)
    keys_to_delete = list(other_user_sessions.values_list('session_key', flat=True))

    Session.objects.filter(session_key__in=keys_to_delete).delete()
    other_user_sessions.delete()


def change_password(user, current_password, new_password, current_session_key=None):
    """
    Change user password. Requires correct current password. Ends other sessions.
    Returns (True, None) or (False, error_code).
    """
    if not user.check_password(current_password):
        return False, 'invalid_current_password'

    user.set_password(new_password)
    user.save(update_fields=['password'])

    if current_session_key:
        revoke_other_sessions(user, current_session_key)

    log_audit(
        actor=user,
        action='password_change',
        target_type='user',
        target_id=str(user.id),
        details={'session_revoked': True}
    )
    return True, None


def is_disposable_domain(email):
    """Check if email domain is in BlockedEmailDomain."""
    if not email or '@' not in email:
        return False
    domain = email.split('@', 1)[1].lower().strip()
    return BlockedEmailDomain.objects.filter(domain=domain).exists()


def add_blocked_domain(actor, domain):
    domain = domain.lower().strip()
    obj, created = BlockedEmailDomain.objects.get_or_create(domain=domain, defaults={'created_by': actor})
    if created:
        log_audit(
            actor=actor,
            action='add_blocked_domain',
            target_type='blocked_domain',
            target_id=str(obj.id),
            details={'domain': domain}
        )
    return obj


def remove_blocked_domain(actor, domain_obj):
    domain_name = domain_obj.domain
    domain_id = domain_obj.id
    domain_obj.delete()
    log_audit(
        actor=actor,
        action='remove_blocked_domain',
        target_type='blocked_domain',
        target_id=str(domain_id),
        details={'domain': domain_name}
    )


def warn_user(user, warning_text):
    """Store warning for user in cache (7 days TTL). Displayed once on next page load."""
    cache.set(f'user_warning:{user.id}', warning_text, timeout=604800)


def get_and_clear_warning(user):
    """Get pending warning if any and immediately delete it from cache."""
    key = f'user_warning:{user.id}'
    warning = cache.get(key)
    if warning:
        cache.delete(key)
    return warning


def suspend_user(actor, user, reason=""):
    """Suspend user account and revoke sessions."""
    user.is_suspended = True
    user.save(update_fields=['is_suspended'])
    from django.contrib.sessions.models import Session
    user_sessions = UserSession.objects.filter(user=user)
    Session.objects.filter(session_key__in=user_sessions.values_list('session_key', flat=True)).delete()
    user_sessions.delete()

    log_audit(
        actor=actor,
        action='user_suspend',
        target_type='user',
        target_id=str(user.id),
        details={'reason': reason}
    )


def unsuspend_user(actor, user, reason=""):
    """Unsuspend user account."""
    user.is_suspended = False
    user.save(update_fields=['is_suspended'])
    log_audit(
        actor=actor,
        action='user_unsuspend',
        target_type='user',
        target_id=str(user.id),
        details={'reason': reason}
    )
