"""Public legal content + authenticated User Agreement accept APIs."""

import hashlib
import re

from django.utils import timezone
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny, IsAuthenticated

from accounts.legal import (
    get_active_privacy_policy,
    get_active_user_agreement,
    legal_document_payload,
    legal_gate_payload,
    legal_snapshot_account_type,
    mark_user_agreement_accepted,
    user_display_full_name,
    user_phone,
)
from accounts.models import LegalDocument, UserAgreementAcceptance, UserRole
from api.media_urls import build_absolute_media_url
from api.pdf_agreement import save_acceptance_pdf
from api.response import api_response
from api.storage_utils import ensure_upload_dir

_SIGNATURE_MAX_BYTES = 2 * 1024 * 1024
_SIGNATURE_EXTENSIONS = {'.png', '.jpg', '.jpeg'}
_SIGNATURE_MIME = {'image/png', 'image/jpeg', 'image/jpg'}
_AGREEMENT_TEXT_MAX_BYTES = 500_000
_SHA256_HEX_RE = re.compile(r'^[0-9a-fA-F]{64}$')


def _client_ip(request):
    forwarded = (request.META.get('HTTP_X_FORWARDED_FOR') or '').split(',')[0].strip()
    return forwarded or request.META.get('REMOTE_ADDR') or None


def _truthy_accepted(value) -> bool:
    if value is True:
        return True
    if value is False or value is None:
        return False
    return str(value).strip().lower() in {'1', 'true', 'yes', 'on'}


def _validate_signature_file(uploaded):
    if not uploaded:
        return 'Signature image is required.'
    name = (getattr(uploaded, 'name', '') or '').lower()
    ext = ''
    if '.' in name:
        ext = '.' + name.rsplit('.', 1)[-1]
    ctype = (getattr(uploaded, 'content_type', None) or '').lower()
    size = int(getattr(uploaded, 'size', 0) or 0)
    if size > _SIGNATURE_MAX_BYTES:
        return 'Signature must be 2 MB or smaller.'
    if ext and ext not in _SIGNATURE_EXTENSIONS:
        return 'Signature must be a PNG or JPEG image.'
    if ctype and ctype not in _SIGNATURE_MIME:
        return 'Signature MIME type must be image/png or image/jpeg.'
    if not ext and not ctype:
        return 'Signature must be a PNG or JPEG image.'
    return None


def _parse_agreement_text(raw):
    """Return (text, error_dict_or_None, http_status_or_None)."""
    if raw is None:
        return None, {'agreement_text': 'This field is required.'}, 400
    text = str(raw)
    if not text.strip():
        return None, {'agreement_text': 'Agreement text cannot be empty.'}, 400
    if len(text.encode('utf-8')) > _AGREEMENT_TEXT_MAX_BYTES:
        return None, {'agreement_text': 'Agreement text must be 500 KB or smaller.'}, 413
    return text, None, None


def _resolve_text_hash(text: str, client_hash) -> str:
    provided = (str(client_hash).strip() if client_hash is not None else '')
    if provided and _SHA256_HEX_RE.match(provided):
        return provided.lower()
    return hashlib.sha256(text.encode('utf-8')).hexdigest()


def _user_can_accept_agreement(user) -> bool:
    try:
        return user.role.role in (UserRole.Role.SHIPPER, UserRole.Role.TRANSPORTER)
    except UserRole.DoesNotExist:
        return False


def _acceptance_response_data(request, user, acceptance):
    gate = legal_gate_payload(user, request=request)
    signature_url = None
    pdf_url = None
    if acceptance.signature_file:
        signature_url = build_absolute_media_url(request, acceptance.signature_file.url)
    if acceptance.pdf_file:
        pdf_url = build_absolute_media_url(request, acceptance.pdf_file.url)
    return {
        'user_id': user.id,
        'account_type': acceptance.account_type_at_accept or legal_snapshot_account_type(user),
        'user_agreement_accepted': gate['user_agreement_accepted'],
        'user_agreement_accepted_at': gate['user_agreement_accepted_at'],
        'user_agreement_version': gate['user_agreement_version'],
        'signature_url': signature_url,
        'pdf_url': pdf_url,
        'agreement_text_stored': bool((acceptance.agreement_text_snapshot or '').strip()),
    }


@api_view(['GET'])
@permission_classes([AllowAny])
def legal_user_agreement(request):
    locale = (request.query_params.get('locale') or 'en').strip() or 'en'
    doc = get_active_user_agreement(locale=locale)
    if not doc and locale != 'en':
        doc = get_active_user_agreement(locale='en')
    if not doc:
        return api_response(404, 'User agreement not found.', error='Not found.')
    return api_response(200, 'OK', data=legal_document_payload(doc))


@api_view(['GET'])
@permission_classes([AllowAny])
def legal_privacy_policy(request):
    locale = (request.query_params.get('locale') or 'en').strip() or 'en'
    doc = get_active_privacy_policy(locale=locale)
    if not doc and locale != 'en':
        doc = get_active_privacy_policy(locale='en')
    if not doc:
        return api_response(404, 'Privacy policy not found.', error='Not found.')
    return api_response(200, 'OK', data=legal_document_payload(doc))


@api_view(['GET'])
@permission_classes([AllowAny])
def legal_documents_list(request):
    """Optional list filter: ?type=USER_AGREEMENT|PRIVACY_POLICY&active=1"""
    doc_type = (request.query_params.get('type') or '').strip().upper()
    active_only = (request.query_params.get('active') or '1').strip() not in {'0', 'false', 'False'}
    qs = LegalDocument.objects.all()
    if doc_type:
        qs = qs.filter(doc_type=doc_type)
    if active_only:
        qs = qs.filter(is_active=True)
    data = [legal_document_payload(d) for d in qs.order_by('doc_type', '-effective_at', '-id')]
    return api_response(200, 'OK', data=data)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def legal_user_agreement_accept(request):
    if not _user_can_accept_agreement(request.user):
        return api_response(
            403,
            'Only shipper and transporter accounts can accept the user agreement.',
            error='Forbidden.',
        )

    active = get_active_user_agreement()
    if not active:
        return api_response(404, 'No active user agreement is published.', error='Not found.')

    version = (request.data.get('agreement_version') or '').strip()
    if not version:
        return api_response(400, 'Validation failed.', error={'agreement_version': 'This field is required.'})
    if version != active.version:
        return api_response(
            400,
            'Validation failed.',
            error={
                'agreement_version': (
                    f'Must match the active agreement version ({active.version}).'
                ),
            },
        )

    if not _truthy_accepted(request.data.get('accepted')):
        return api_response(
            400,
            'Validation failed.',
            error={'accepted': 'You must set accepted=true to continue.'},
        )

    existing = UserAgreementAcceptance.objects.filter(
        user=request.user,
        agreement_document=active,
    ).first()
    if existing and request.user.role.user_agreement_accepted and (
        request.user.role.user_agreement_version == active.version
    ):
        return api_response(
            200,
            'User agreement already accepted.',
            data=_acceptance_response_data(request, request.user, existing),
        )

    agreement_text, text_error, text_status = _parse_agreement_text(
        request.data.get('agreement_text'),
    )
    if text_error:
        return api_response(
            text_status or 400,
            'Validation failed.' if (text_status or 400) == 400 else 'Payload too large.',
            error=text_error,
        )

    signature = request.FILES.get('signature') or request.data.get('signature')
    sig_error = _validate_signature_file(signature)
    if sig_error and not existing:
        return api_response(400, 'Validation failed.', error={'signature': sig_error})
    if sig_error and existing and not existing.signature_file:
        return api_response(400, 'Validation failed.', error={'signature': sig_error})

    title = (request.data.get('agreement_title') or '').strip()[:255]
    text_hash = _resolve_text_hash(agreement_text, request.data.get('agreement_text_hash'))

    now = timezone.now()
    date_path = now.strftime('%Y/%m/%d')
    ensure_upload_dir(f'agreements/signatures/{date_path}')
    ensure_upload_dir(f'agreements/pdfs/{date_path}')

    if existing:
        acceptance = existing
        if signature and not sig_error:
            acceptance.signature_file = signature
        acceptance.accepted_at = now
        acceptance.agreement_version = active.version
        acceptance.agreement_text_snapshot = agreement_text
        acceptance.agreement_title_snapshot = title
        acceptance.agreement_text_hash = text_hash
        acceptance.full_name_at_accept = user_display_full_name(request.user)
        acceptance.email_at_accept = request.user.email or ''
        acceptance.phone_at_accept = user_phone(request.user)
        acceptance.account_type_at_accept = legal_snapshot_account_type(request.user)
        acceptance.ip_address = _client_ip(request)
        acceptance.user_agent = (request.META.get('HTTP_USER_AGENT') or '')[:512]
        acceptance.save()
    else:
        acceptance = UserAgreementAcceptance(
            user=request.user,
            agreement_document=active,
            agreement_version=active.version,
            agreement_text_snapshot=agreement_text,
            agreement_title_snapshot=title,
            agreement_text_hash=text_hash,
            accepted_at=now,
            signature_file=signature,
            full_name_at_accept=user_display_full_name(request.user),
            email_at_accept=request.user.email or '',
            phone_at_accept=user_phone(request.user),
            account_type_at_accept=legal_snapshot_account_type(request.user),
            ip_address=_client_ip(request),
            user_agent=(request.META.get('HTTP_USER_AGENT') or '')[:512],
        )
        acceptance.save()

    mark_user_agreement_accepted(request.user, active, when=now)
    try:
        save_acceptance_pdf(acceptance)
        acceptance.refresh_from_db()
    except Exception:
        # Accept still succeeds if PDF generation fails; admin can regenerate.
        pass

    return api_response(
        200,
        'User agreement accepted successfully.',
        data=_acceptance_response_data(request, request.user, acceptance),
    )
