from apps.calls.repositories import MessageRepository
from apps.calls.serializers import MessageCreateSerializer
from .twilio_sms_service import SmsService
from .notification_service import NotificationService
import logging
import pytz
from django.utils import timezone


logger = logging.getLogger(__name__)

class MessageService:

    @staticmethod
    def list_messages(user, qs=None):
        if qs is None:
            qs = MessageRepository.base_queryset()

        if user.is_superuser:
            return qs.order_by("-created_at")

        return MessageRepository.list_for_user(user).order_by("-created_at")

    @staticmethod
    def get_message(user, msg_id):
        return MessageRepository.get_by_id(msg_id, user)

    @staticmethod
    def mark_as_read(user, msg_id):
        msg = MessageService.get_message(user, msg_id)

        if msg is None:
            return None   

        return MessageRepository.mark_as_read(msg)

    @staticmethod
    def handle_appointment_message(appointment):
        """
        Creates a message for the appointment and sends notification.
        """

        if appointment is None:
            logger.error("Cannot create message — appointment is None")
            return None

        recipient = appointment.company.default_transfer_staff

        if recipient is None:
            logger.error("Recipient user not found for appointment %s", appointment.id)
            return None

        # 🔹 Convert UTC → Pacific time + split date/time
        try:
            pacific = pytz.timezone("America/Los_Angeles")
            scheduled_dt = timezone.localtime(appointment.scheduled_date, pacific)

            date_str = scheduled_dt.strftime("%Y-%m-%d")
            time_str = scheduled_dt.strftime("%I:%M %p")

        except Exception as exc:
            logger.exception("Failed converting time for appointment %s: %s", appointment.id, exc)
            date_str = str(appointment.scheduled_date)
            time_str = ""

        body = (
            f"New appointment created by Maya.\n"
            f"Date: {date_str}\n"
            f"Time: {time_str} Pacific Time\n"
            f"Name: {appointment.name}"
        )

        payload = {
            "recipient": recipient.id,
            "customer_name": appointment.name,
            "customer_number": appointment.appointment_phone,
            "subject": "Appointment Message",
            "body": body,
        }

        serializer = MessageCreateSerializer(data=payload)
        serializer.is_valid(raise_exception=True)

        message = MessageRepository.create_message(**serializer.validated_data)
        logger.info(
            "Message created (id=%s) for appointment (id=%s)",
            message.id,
            appointment.id,
        )
        NotificationService.send_message_notification(
            user=recipient,
            title=serializer.validated_data['subject'],
            message=serializer.validated_data['body']
        )
        logger.info(
            "Notification sent to user (id=%s) for message (id=%s)",
            recipient.id,
            message.id,
        )

        # Send SMS using Twilio
        sms_text = (
            f"New Appointment from Maya:\n"
            f"Name: {appointment.name}\n"
            f"Phone: {appointment.appointment_phone}\n"
            f"Date: {date_str}\n"
            f"Time: {time_str} Pacific Time"
        )

        SmsService.send_sms(
            to_number=appointment.company.bdc_number,
            message=sms_text
        )

        logger.info("date and time of appointment are %s %s", date_str, time_str)

        return message