from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.permissions import IsAuthenticated
from rest_framework_simplejwt.views import TokenObtainPairView
from django.utils import timezone
from django.core.mail import send_mail
from django.conf import settings
import datetime

from .models import User, Role, LoginHistory, ClientInvitation
from .serializers import (UserSerializer, UserCreateSerializer, RoleSerializer,
                          LoginHistorySerializer, ChangePasswordSerializer)


class CustomTokenObtainPairView(TokenObtainPairView):
    def post(self, request, *args, **kwargs):
        response = super().post(request, *args, **kwargs)
        if response.status_code == 200:
            # Pull role + client in the same query so UserSerializer doesn't
            # lazy-load them (avoids 2 extra round-trips per login).
            user = User.objects.select_related('role', 'client').get(
                username=request.data.get('username'))
            # X-Forwarded-For may be "client, proxy1, proxy2" behind LiteSpeed/
            # Cloudflare — keep the first entry (the real client IP).
            xff = request.META.get('HTTP_X_FORWARDED_FOR', '')
            ip = (xff.split(',')[0].strip() if xff
                  else request.META.get('REMOTE_ADDR', ''))[:45] or None
            LoginHistory.objects.create(
                user=user,
                ip_address=ip,
                user_agent=request.META.get('HTTP_USER_AGENT', '')[:500]
            )
            user.last_login_ip = ip
            user.save(update_fields=['last_login_ip'])
            response.data['user'] = UserSerializer(user).data
        return response


class RoleViewSet(viewsets.ModelViewSet):
    queryset = Role.objects.all()
    serializer_class = RoleSerializer


class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.select_related('role', 'client').all()
    filterset_fields = ['role__name', 'client', 'is_active', 'department']
    search_fields = ['username', 'first_name', 'last_name', 'email']

    def get_queryset(self):
        # A client-portal user may only manage users belonging to their own
        # client — never see staff accounts or other clients' users.
        from core.scoping import scope_to_client
        return scope_to_client(super().get_queryset(), self.request.user)

    def get_serializer_class(self):
        if self.action == 'create':
            return UserCreateSerializer
        return UserSerializer

    @action(detail=False, methods=['get'])
    def me(self, request):
        return Response(UserSerializer(request.user).data)

    @action(detail=False, methods=['post'])
    def change_password(self, request):
        serializer = ChangePasswordSerializer(data=request.data, context={'request': request})
        if serializer.is_valid():
            request.user.set_password(serializer.validated_data['new_password'])
            request.user.save()
            return Response({'detail': 'Password changed successfully.'})
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    @action(detail=False, methods=['get'])
    def agents(self, request):
        agents = User.objects.filter(role__name='agent', is_active=True)
        return Response(UserSerializer(agents, many=True).data)

    @action(detail=False, methods=['get'])
    def login_history(self, request):
        history = LoginHistory.objects.filter(user=request.user)[:50]
        return Response(LoginHistorySerializer(history, many=True).data)


class ClientLoginLogsView(APIView):
    """Return login history for all users belonging to a given client."""
    permission_classes = [IsAuthenticated]

    def get(self, request, client_id):
        from clients.models import Client
        from django.shortcuts import get_object_or_404
        client = get_object_or_404(Client, pk=client_id)

        qs = LoginHistory.objects.filter(user__client=client).select_related('user')

        # filters
        from_date = request.query_params.get('from_date')
        to_date   = request.query_params.get('to_date')
        success   = request.query_params.get('success')
        user_id   = request.query_params.get('user_id')

        if from_date:
            qs = qs.filter(created_at__date__gte=from_date)
        if to_date:
            qs = qs.filter(created_at__date__lte=to_date)
        if success in ('true', 'false'):
            qs = qs.filter(success=success == 'true')
        if user_id:
            qs = qs.filter(user_id=user_id)

        qs = qs[:200]
        data = LoginHistorySerializer(qs, many=True).data
        # enrich with username
        for item, log in zip(data, qs):
            item['username']   = log.user.username if log.user else '—'
            item['full_name']  = log.user.get_full_name() if log.user else '—'
        return Response(data)


class ClientEmailReportsView(APIView):
    """Email report data for a client: by-day matrix, by-category, by-agent."""
    permission_classes = [IsAuthenticated]

    def get(self, request, client_id):
        from clients.models import Client
        from tickets.models import Ticket, TicketComment
        from django.shortcuts import get_object_or_404
        from django.db.models import Count, Q
        from datetime import date, timedelta

        client = get_object_or_404(Client, pk=client_id)

        # date range — default last 14 days
        to_date   = request.query_params.get('to_date')
        from_date = request.query_params.get('from_date')
        try:
            to_dt   = date.fromisoformat(to_date)   if to_date   else date.today()
            from_dt = date.fromisoformat(from_date) if from_date else to_dt - timedelta(days=13)
        except ValueError:
            to_dt   = date.today()
            from_dt = to_dt - timedelta(days=13)

        base_qs = Ticket.objects.filter(client=client)

        # apply date filter only if provided
        if from_date:
            base_qs = base_qs.filter(created_at__date__gte=from_dt)
        if to_date:
            base_qs = base_qs.filter(created_at__date__lte=to_dt)

        # ── 1. Ticket Types by Day (pivot matrix) — group by channel ──────────
        # collect all actual dates from tickets
        all_dates_qs = base_qs.values_list('created_at__date', flat=True).distinct()
        actual_days = sorted(set(d.isoformat() for d in all_dates_qs if d))

        # also include the default 14-day range so the matrix has structure
        range_days = [(from_dt + timedelta(days=i)).isoformat() for i in range((to_dt - from_dt).days + 1)]
        days = sorted(set(actual_days + range_days))

        # group by channel (always populated) + category name
        channels = list(base_qs.values_list('channel', flat=True).distinct().order_by())
        channels = sorted(set(c or 'other' for c in channels))
        categories_set = list(base_qs.values_list('category__name', flat=True).distinct().order_by())
        categories_set = sorted(set(c or 'Uncategorized' for c in categories_set))

        # use channel as primary type label
        type_labels = channels if channels else ['other']

        day_qs = (
            base_qs.values('created_at__date', 'channel')
            .annotate(count=Count('id'))
        )
        matrix = {d: {t: 0 for t in type_labels} for d in days}
        day_totals = {d: 0 for d in days}
        for row in day_qs:
            d_obj = row['created_at__date']
            if not d_obj:
                continue
            d = d_obj.isoformat()
            t = row['channel'] or 'other'
            if d not in matrix:
                matrix[d] = {tl: 0 for tl in type_labels}
                day_totals[d] = 0
            if t not in matrix[d]:
                matrix[d][t] = 0
            if t not in type_labels:
                type_labels.append(t)
                for dk in matrix:
                    matrix[dk].setdefault(t, 0)
            matrix[d][t] += row['count']
            day_totals[d] = day_totals.get(d, 0) + row['count']

        # ── 2. Campaign / Category Summary — group by channel + category ───────
        campaign_qs = (
            base_qs.values('channel', 'category__name')
            .annotate(emails_handled=Count('id'))
            .order_by('-emails_handled')
        )
        campaigns = [
            {
                'name': f"{r['channel'] or 'other'}" + (f" — {r['category__name']}" if r['category__name'] else ''),
                'emails_handled': r['emails_handled'],
            }
            for r in campaign_qs
        ]

        # ── 3. Agent Metrics ──────────────────────────────────────────────────
        agent_qs = (
            base_qs
            .values('assigned_agent__username', 'assigned_agent__first_name', 'assigned_agent__last_name')
            .annotate(
                tickets=Count('id'),
                replies=Count('comments', filter=Q(comments__comment_type='public')),
            )
            .order_by('-tickets')
        )
        agents = [
            {
                'agent': (f"{r['assigned_agent__first_name']} {r['assigned_agent__last_name']}".strip()
                          or r['assigned_agent__username'] or 'Unassigned'),
                'tickets': r['tickets'],
                'replies': r['replies'],
            }
            for r in agent_qs
        ]

        return Response({
            'days': days,
            'categories': type_labels,
            'matrix': matrix,
            'day_totals': day_totals,
            'campaigns': campaigns,
            'agents': agents,
            'from_date': from_dt.isoformat(),
            'to_date': to_dt.isoformat(),
            'total': base_qs.count(),
        })


class ClientInviteView(APIView):
    """Admin-only: send an invitation email to a client contact."""

    def post(self, request):
        from clients.models import Client

        if not (request.user.is_authenticated and (
            request.user.is_superuser or
            request.user.role and request.user.role.name in [
                Role.SYSTEM_ADMIN, Role.CLIENT_ADMIN, Role.OPERATIONS_MANAGER
            ]
        )):
            return Response({'error': 'Permission denied.'}, status=status.HTTP_403_FORBIDDEN)

        client_id = request.data.get('client_id')
        email     = (request.data.get('email') or '').strip().lower()

        if not client_id or not email:
            return Response({'error': 'client_id and email are required.'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            client = Client.objects.get(id=client_id, is_active=True)
        except Client.DoesNotExist:
            return Response({'error': 'Client not found.'}, status=status.HTTP_404_NOT_FOUND)

        # Expire any previous unused invitations for this email+client
        ClientInvitation.objects.filter(client=client, email=email, is_used=False).update(
            expires_at=timezone.now()
        )

        invite = ClientInvitation.objects.create(
            client=client,
            email=email,
            invited_by=request.user,
            expires_at=timezone.now() + datetime.timedelta(days=7),
        )

        # Use the request's origin so the link always matches the current tunnel/domain
        origin = request.headers.get('Origin') or request.headers.get('Referer', '').rstrip('/')
        if origin and origin.startswith('http'):
            from urllib.parse import urlparse
            parsed = urlparse(origin)
            frontend_url = f"{parsed.scheme}://{parsed.netloc}"
        else:
            frontend_url = getattr(settings, 'FRONTEND_URL', 'http://localhost:5173').rstrip('/')
        register_url = f"{frontend_url}/client-register?token={invite.token}"

        # Send invitation email
        try:
            send_mail(
                subject=f"You're invited to {client.name}'s Client Portal — Altria CRM",
                message=(
                    f"Hello,\n\n"
                    f"You have been invited to access the Altria CRM client portal for {client.name}.\n\n"
                    f"Click the link below to create your account:\n{register_url}\n\n"
                    f"This link expires in 7 days.\n\n"
                    f"If you did not expect this invitation, please ignore this email.\n\n"
                    f"— Altria Call Center"
                ),
                html_message=(
                    f"""<div style="font-family:Inter,sans-serif;max-width:520px;margin:0 auto;padding:32px 24px;background:#f8fafc;border-radius:16px">
                    <div style="background:linear-gradient(135deg,#6366f1,#4f46e5);border-radius:12px;padding:24px;text-align:center;margin-bottom:24px">
                      <h1 style="color:#fff;margin:0;font-size:22px">Altria CRM</h1>
                      <p style="color:rgba(255,255,255,0.75);margin:6px 0 0;font-size:13px">Client Portal Invitation</p>
                    </div>
                    <h2 style="color:#0f172a;font-size:18px;margin:0 0 8px">You've been invited!</h2>
                    <p style="color:#475569;font-size:14px;line-height:1.6">
                      You have been granted access to the <strong>{client.name}</strong> client portal on Altria CRM.
                      Click the button below to create your account.
                    </p>
                    <div style="text-align:center;margin:28px 0">
                      <a href="{register_url}" style="background:linear-gradient(135deg,#6366f1,#4f46e5);color:#fff;padding:13px 32px;border-radius:10px;text-decoration:none;font-weight:700;font-size:15px;display:inline-block">
                        Create My Account →
                      </a>
                    </div>
                    <p style="color:#94a3b8;font-size:12px;text-align:center">This invitation expires in 7 days. If you did not expect this, please ignore it.</p>
                    </div>"""
                ),
                from_email=getattr(settings, 'DEFAULT_FROM_EMAIL', 'noreply@altriacallcenter.com'),
                recipient_list=[email],
                fail_silently=False,
            )
            email_sent = True
        except Exception as e:
            email_sent = False

        return Response({
            'token':      str(invite.token),
            'email':      email,
            'client':     client.name,
            'expires_at': invite.expires_at.isoformat(),
            'register_url': register_url,
            'email_sent': email_sent,
        }, status=status.HTTP_201_CREATED)


class ClientInviteVerifyView(APIView):
    """Public: verify an invitation token and return client info."""
    permission_classes = []

    def get(self, request):
        token = request.query_params.get('token', '')
        try:
            invite = ClientInvitation.objects.select_related('client').get(token=token)
        except (ClientInvitation.DoesNotExist, Exception):
            return Response({'error': 'Invalid invitation link.'}, status=status.HTTP_404_NOT_FOUND)

        if not invite.is_valid():
            return Response({'error': 'This invitation has already been used or has expired.'}, status=status.HTTP_410_GONE)

        return Response({
            'client_name': invite.client.name,
            'client_tier': invite.client.tier,
            'email':       invite.email,
        })


class ClientInviteRegisterView(APIView):
    """Public: complete registration via invitation token."""
    permission_classes = []

    def post(self, request):
        from rest_framework_simplejwt.tokens import RefreshToken

        token      = (request.data.get('token') or '').strip()
        username   = (request.data.get('username') or '').strip()
        password   = request.data.get('password', '')
        contact_name = (request.data.get('contact_name') or '').strip()
        email      = (request.data.get('email') or '').strip()

        errors = {}
        if not token:            errors['token']        = 'Invitation token is missing.'
        if not contact_name:     errors['contact_name'] = 'Your name is required.'
        if not username:         errors['username']     = 'Username is required.'
        if len(password) < 8:   errors['password']     = 'Password must be at least 8 characters.'
        if errors:
            return Response(errors, status=status.HTTP_400_BAD_REQUEST)

        # Verify token
        try:
            invite = ClientInvitation.objects.select_related('client').get(token=token)
        except ClientInvitation.DoesNotExist:
            return Response({'token': 'Invalid invitation link.'}, status=status.HTTP_400_BAD_REQUEST)

        if not invite.is_valid():
            return Response({'token': 'This invitation has already been used or has expired.'}, status=status.HTTP_400_BAD_REQUEST)

        if User.objects.filter(username=username).exists():
            return Response({'username': 'Username already taken.'}, status=status.HTTP_400_BAD_REQUEST)

        role, _ = Role.objects.get_or_create(
            name=Role.CLIENT_REVIEWER,
            defaults={'display_name': 'Client Reviewer', 'permissions': {}},
        )

        parts = contact_name.split(None, 1)
        user = User(
            username=username,
            email=email or invite.email,
            first_name=parts[0],
            last_name=parts[1] if len(parts) > 1 else '',
            client=invite.client,
            role=role,
            is_active=True,
        )
        user.set_password(password)
        user.save()

        # Mark invitation as used
        invite.is_used  = True
        invite.used_at  = timezone.now()
        invite.save(update_fields=['is_used', 'used_at'])

        refresh = RefreshToken.for_user(user)
        return Response({
            'access':  str(refresh.access_token),
            'refresh': str(refresh),
            'user':    UserSerializer(user).data,
        }, status=status.HTTP_201_CREATED)



class SystemConfigView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        from .models import SystemConfig
        cfg = SystemConfig.get()
        # allow ?provider=groq to check key for a specific provider
        provider = request.query_params.get('provider', cfg.ai_provider)
        keys = cfg.ai_keys or {}
        key = keys.get(provider, '')
        masked = f"{key[:6]}...{key[-4:]}" if key and len(key) > 10 else ''
        return Response({
            'ai_enabled':     cfg.ai_enabled,
            'ai_provider':    cfg.ai_provider,
            'ai_model':       cfg.ai_model,
            'ai_base_url':    cfg.ai_base_url,
            'api_key_set':    bool(key),
            'api_key_masked': masked,
            'report_emails':  cfg.report_emails or '',
            'autoreply_enabled':    cfg.autoreply_enabled,
            'autoreply_confidence': cfg.autoreply_confidence,
        })

    def post(self, request):
        from .models import SystemConfig
        cfg = SystemConfig.get()
        is_admin = request.user.is_superuser or getattr(getattr(request.user, 'role', None), 'name', None) == 'system_admin'

        # Report recipients can be managed by any logged-in user (it's set on the
        # network-config page). Everything else (AI/provider) stays admin-only.
        ai_fields = ['ai_enabled', 'ai_provider', 'ai_model', 'ai_base_url', 'ai_api_key',
                     'autoreply_enabled', 'autoreply_confidence']
        if any(f in request.data for f in ai_fields) and not is_admin:
            return Response({'error': 'Admin only'}, status=403)

        if 'ai_enabled'  in request.data: cfg.ai_enabled  = bool(request.data['ai_enabled'])
        if 'ai_provider' in request.data: cfg.ai_provider = request.data['ai_provider']
        if 'ai_model'    in request.data: cfg.ai_model    = request.data['ai_model']
        if 'ai_base_url' in request.data: cfg.ai_base_url = request.data['ai_base_url']
        if 'autoreply_enabled' in request.data: cfg.autoreply_enabled = bool(request.data['autoreply_enabled'])
        if 'autoreply_confidence' in request.data:
            try:
                cfg.autoreply_confidence = max(0, min(101, int(request.data['autoreply_confidence'])))
            except (ValueError, TypeError):
                pass
        if 'ai_api_key'  in request.data:
            val = request.data['ai_api_key'].strip()
            if val and '...' not in val:
                keys = cfg.ai_keys or {}
                keys[cfg.ai_provider] = val
                cfg.ai_keys = keys
        if 'report_emails' in request.data:
            raw = (request.data['report_emails'] or '').replace(';', ',')
            cfg.report_emails = ', '.join([e.strip() for e in raw.split(',') if e.strip()])
        if request.data.get('request_speedtest'):
            cfg.speedtest_requested = True
        cfg.save()
        return Response({'ok': True})



class SystemConfigTestView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request):
        if not (request.user.is_superuser or getattr(getattr(request.user, 'role', None), 'name', None) == 'system_admin'):
            return Response({'error': 'Admin only'}, status=403)
        from .models import SystemConfig
        cfg = SystemConfig.get()
        provider = cfg.ai_provider
        key = (cfg.ai_keys or {}).get(provider, '') or cfg.ai_api_key or ''
        if not key:
            return Response({'ok': False, 'error': f'No API key saved for {provider}.'}, status=400)
        if not cfg.ai_enabled:
            return Response({'ok': False, 'error': 'AI Assistant is disabled — turn on the toggle first.'}, status=400)
        try:
            import urllib.request, json as _json
            if provider == 'groq':
                url = 'https://api.groq.com/openai/v1/chat/completions'
                body = _json.dumps({'model': cfg.ai_model, 'messages': [{'role': 'user', 'content': 'Say OK'}], 'max_tokens': 5}).encode()
                req = urllib.request.Request(url, data=body, headers={'Content-Type': 'application/json', 'Authorization': f'Bearer {key}'})
            elif provider == 'gemini':
                url = f'https://generativelanguage.googleapis.com/v1beta/models/{cfg.ai_model}:generateContent?key={key}'
                body = _json.dumps({'contents': [{'parts': [{'text': 'Say OK'}]}]}).encode()
                req = urllib.request.Request(url, data=body, headers={'Content-Type': 'application/json'})
            elif provider == 'anthropic':
                import anthropic
                client = anthropic.Anthropic(api_key=key)
                msg = client.messages.create(model=cfg.ai_model, max_tokens=5, messages=[{'role': 'user', 'content': 'Say OK'}])
                return Response({'ok': True, 'message': f'Connected! Claude replied: "{msg.content[0].text.strip()}"'})
            elif provider == 'openai':
                url = 'https://api.openai.com/v1/chat/completions'
                body = _json.dumps({'model': cfg.ai_model, 'messages': [{'role': 'user', 'content': 'Say OK'}], 'max_tokens': 5}).encode()
                req = urllib.request.Request(url, data=body, headers={'Content-Type': 'application/json', 'Authorization': f'Bearer {key}'})
            else:
                return Response({'ok': False, 'error': f'Unknown provider: {provider}'}, status=400)
            with urllib.request.urlopen(req, timeout=15) as resp:
                data = _json.loads(resp.read())
            if provider == 'gemini':
                text = data['candidates'][0]['content']['parts'][0]['text'].strip()
            else:
                text = data['choices'][0]['message']['content'].strip()
            return Response({'ok': True, 'message': f'Connected! {provider.title()} replied: "{text[:80]}"'})
        except urllib.error.HTTPError as e:
            body = e.read().decode()[:300]
            return Response({'ok': False, 'error': f'HTTP {e.code} from {provider}: {body}'}, status=400)
        except Exception as e:
            return Response({'ok': False, 'error': str(e)}, status=400)
