# ============================================================
# 6 Interview Calendar | 7 Interview Rounds | 8 Feedback
# + interviewer self-service (employee login)
# ============================================================
import calendar as pycal
from datetime import datetime, timedelta

from django.db import transaction
from django.db.models import Q
from django.utils import timezone
from rest_framework.authentication import BaseAuthentication  # noqa: F401
from rest_framework.decorators import action
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSet

from Employee.employee_crud_permissions import AdminOrEmployeeJWTAuthentication, actor_label

from .common import (
    RecruitmentAuthMixin, IsAnyEmployee, ok, err, to_datetime, to_date, emp_brief, candidates_qs,
    candidate_brief, employee_by_code, next_seq, set_stage, candidate_by_ref,
)
from .models import InterviewRound, InterviewFeedback

EARLY_STAGES = ["APPLIED", "SCREENING", "SHORTLISTED"]
SCORE_FIELDS = InterviewFeedback.SCORE_FIELDS


def serialize_round(r, request=None):
    fb = getattr(r, "feedback", None) if r.feedback_status == "Submitted" else None
    return {
        "id": r.id,
        "interview_id": r.interview_id,
        "candidate": candidate_brief(r.candidate, request),
        "round_name": r.round_name,
        "round_no": r.round_no,
        "interviewer": emp_brief(r.interviewer, request),
        "scheduled_at": r.scheduled_at,
        "duration_minutes": r.duration_minutes,
        "mode": r.mode,
        "meeting_link": r.meeting_link,
        "status": r.status,
        "feedback_status": r.feedback_status,
        "recommendation": fb.recommendation if fb else None,
        "notes": r.notes,
    }


def serialize_feedback(f, request=None):
    r = f.interview
    return {
        "id": f.id,
        "interview": r.id,                    
        "interview_id": r.interview_id,
        "candidate": candidate_brief(r.candidate, request),
        "round_name": r.round_name,
        "interviewer": emp_brief(r.interviewer, request),
        "scores": {k: getattr(f, k) for k in SCORE_FIELDS},
        "average_score": f.average_score,
        "rating": f.average_score,
        "overall_rating": f.average_score,
        "technical_rating": f.technical_skills,
        "problem_solving_rating": f.problem_solving,
        "communication_rating": f.communication,
        "culture_fit_rating": f.culture_fit,
        "recommendation": f.recommendation,
        "strengths": f.strengths,
        "concerns": f.concerns,
        "comments": f.comments,
        "why_hire": f.why_hire,
        "why_not_hire": f.why_not_hire,
        "submitted_by": f.submitted_by_label,
        "submitted_at": f.created_at,
    }


def _interviewer_busy(company, interviewer, start, minutes, exclude_pk=None):
    end = start + timedelta(minutes=minutes)
    qs = InterviewRound.objects.filter(company=company, interviewer=interviewer, status="Scheduled",
                                       is_active=True, scheduled_at__lt=end)
    if exclude_pk:
        qs = qs.exclude(pk=exclude_pk)
    for r in qs.filter(scheduled_at__gt=start - timedelta(hours=8)):
        if r.scheduled_at + timedelta(minutes=r.duration_minutes) > start:
            return r
    return None


def _notify_interview(r):
    """Invite mail to candidate + interviewer (best effort, never raises)."""
    try:
        from django.conf import settings
        from django.core.mail import send_mail
        when = timezone.localtime(r.scheduled_at).strftime("%d %b %Y, %I:%M %p")
        body = (f"Interview {r.interview_id}: {r.round_name}\nWhen: {when} ({r.duration_minutes} min)\n"
                f"Mode: {r.mode or '-'}\nLink: {r.meeting_link or '-'}\n")
        to = [e for e in (r.candidate.email, r.interviewer.email if r.interviewer else None) if e]
        if not to:
            return False
        send_mail(f"Interview scheduled - {r.round_name}", body,
                  getattr(settings, "DEFAULT_FROM_EMAIL", None), to, fail_silently=False)
        return True
    except Exception:
        return False


ROUND_FLOW = ["HR Screening", "Technical Round 1", "Technical Round 2", "Managerial Round", "HR & Leadership Round"]


# Scores the feedback form does not collect yet. They are optional and stored as 0 when omitted.
OPTIONAL_SCORE_FIELDS = {"domain_knowledge", "leadership"}


def _parse_scores(d):
    scores = {}
    for k in SCORE_FIELDS:
        raw = d.get(k)
        if k in OPTIONAL_SCORE_FIELDS and raw in (None, ""):
            scores[k] = 0
            continue
        try:
            v = int(round(float(raw)))
        except (TypeError, ValueError):
            raise ValueError(f"{k} is required (1-5).")
        if not 1 <= v <= 5:
            raise ValueError(f"{k} must be between 1 and 5.")
        scores[k] = v
    if d.get("recommendation") not in dict(InterviewFeedback.RECO):
        raise ValueError("recommendation must be one of: " + ", ".join(dict(InterviewFeedback.RECO)))
    return scores


@transaction.atomic
def save_feedback(round_obj, d, submitter_emp, actor):
    scores = _parse_scores(d)
    fb, _ = InterviewFeedback.objects.get_or_create(
        interview=round_obj, defaults={"company": round_obj.company, "recommendation": d["recommendation"]})
    for k, v in scores.items():
        setattr(fb, k, v)
    fb.recommendation = d["recommendation"]
    fb.strengths, fb.concerns, fb.comments = d.get("strengths"), d.get("concerns"), d.get("comments")
    if "why_hire" in d:
        fb.why_hire = d.get("why_hire")
    if "why_not_hire" in d:
        fb.why_not_hire = d.get("why_not_hire")
    fb.submitted_by, fb.submitted_by_label, fb.updated_by = submitter_emp, actor, actor
    fb.created_by = fb.created_by or actor
    fb.save()
    round_obj.feedback_status = "Submitted"
    if round_obj.status == "Scheduled":
        round_obj.status = "Completed"
    round_obj.save(update_fields=["feedback_status", "status", "updated_at"])
    # If the candidate was waiting on feedback and nothing else is pending, put them back to INTERVIEW
    # cand = round_obj.candidate
    # if (cand.candidate_status or "").upper() == "FEEDBACK_PENDING" and not InterviewRound.objects.filter(
    #         candidate=cand, is_active=True, feedback_status="Pending").exclude(status="Cancelled").exists():
    #     set_stage(cand, "INTERVIEW", actor, "Feedback received")
    return fb

# ------------------------------------------------------------
# 7. INTERVIEW ROUNDS  /api/recruitment/interviews/
# ------------------------------------------------------------
class InterviewRoundViewSet(RecruitmentAuthMixin, ViewSet):
    permission_action_map = {"cancel": "edit", "complete": "edit", "no_show": "edit",
                             "feedback": "create", "scorecard": "view", "reschedule": "edit",
                             "availability": "view", "next_round": "view"}

    @action(detail=False, methods=["get"])
    def availability(self, request):
        """Busy slots of an interviewer on a date: ?interviewer=EMP00001&date=2026-10-12"""
        p = request.query_params
        try:
            emp = employee_by_code(self.company(), p.get("interviewer"))
            day = to_date(p.get("date")) or timezone.localdate()
        except ValueError as e:
            return err("VALIDATION", str(e))
        if emp is None:
            return err("VALIDATION", "interviewer (employee_code) is required.")
        rows = InterviewRound.objects.filter(company=self.company(), interviewer=emp, is_active=True,
                                             status="Scheduled", scheduled_at__date=day).order_by("scheduled_at")
        return ok("INTERVIEWER_AVAILABILITY", "Booked slots.", {
            "interviewer": emp_brief(emp, request), "date": day,
            "busy": [{"interview_id": r.interview_id, "start": r.scheduled_at,
                      "end": r.scheduled_at + timedelta(minutes=r.duration_minutes),
                      "candidate": r.candidate.name} for r in rows]})

    @action(detail=False, methods=["get"], url_path="next-round")
    def next_round(self, request):
        """Suggested next round for a candidate: ?candidate=<id or CAN-code>"""
        c = candidate_by_ref(self.company(), request.query_params.get("candidate"))
        if c is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        done = c.interview_rounds.filter(is_active=True).exclude(status="Cancelled").count()
        return ok("NEXT_ROUND", "Suggested next round.", {
            "round_no": done + 1,
            "suggested_round_name": ROUND_FLOW[min(done, len(ROUND_FLOW) - 1)],
            "flow": ROUND_FLOW,
            "previous_rounds": [{"interview_id": r.interview_id, "round_name": r.round_name, "status": r.status,
                                 "feedback_status": r.feedback_status}
                                for r in c.interview_rounds.filter(is_active=True)]})

    @action(detail=True, methods=["post"])
    def reschedule(self, request, pk=None):
        if not request.data.get("scheduled_at"):
            return err("VALIDATION", "scheduled_at is required.")
        resp = self.partial_update(request, pk)
        if resp.status_code == 200 and request.data.get("reason"):
            InterviewRound.objects.filter(pk=pk).update(notes=f"Rescheduled: {request.data.get('reason')}")
        return resp

    def _get(self, pk):
        return InterviewRound.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("candidate", "interviewer").first()

    def list(self, request):
        qs = InterviewRound.objects.filter(company=self.company(), is_active=True) \
            .select_related("candidate", "interviewer")
        p = request.query_params
        try:
            if p.get("candidate"):
                qs = qs.filter(candidate_id=p["candidate"])
            if p.get("interviewer"):
                qs = qs.filter(interviewer__employee_code=p["interviewer"])
            if p.get("status"):
                qs = qs.filter(status__iexact=p["status"])
            if p.get("feedback_status"):
                qs = qs.filter(feedback_status__iexact=p["feedback_status"])
            if p.get("date_from"):
                qs = qs.filter(scheduled_at__date__gte=to_date(p["date_from"]))
            if p.get("date_to"):
                qs = qs.filter(scheduled_at__date__lte=to_date(p["date_to"]))
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("INTERVIEW_LIST", "Interview rounds.", [serialize_round(r, request) for r in qs.order_by("-scheduled_at")])

    @transaction.atomic
    def create(self, request):
        d = request.data
        company = self.company()
        cand = candidate_by_ref(company, d.get("candidate"))          # id or CAN-xxx code
        if cand is None:
            return err("NOT_FOUND", "Candidate not found.", 404)
        if (cand.candidate_status or "").upper() in ("REJECTED", "JOINED"):
            return err("INVALID_STATE", "Cannot schedule an interview for a Rejected / Joined candidate.")
        if not d.get("round_name") or not d.get("scheduled_at"):
            return err("VALIDATION", "round_name and scheduled_at are required.")
        try:
            when = to_datetime(d.get("scheduled_at"))
            interviewer = employee_by_code(company, d.get("interviewer"))
            minutes = int(d.get("duration_minutes") or 60)
        except ValueError as e:
            return err("VALIDATION", str(e))
        if when < timezone.now() - timedelta(minutes=5):
            return err("VALIDATION", "scheduled_at cannot be in the past.")
        if interviewer:
            clash = _interviewer_busy(company, interviewer, when, minutes)
            if clash and str(d.get("force")).lower() not in ("1", "true"):
                return err("INTERVIEWER_BUSY",
                           f"{interviewer.name} already has {clash.interview_id} at that time. Send force=true to override.",
                           409)
        r = InterviewRound.objects.create(
            company=company, candidate=cand, interviewer=interviewer, scheduled_at=when,
            interview_id=next_seq(InterviewRound, company, "interview_id", "INT-", width=3, start=801),
            round_name=d.get("round_name"), duration_minutes=minutes,
            round_no=cand.interview_rounds.count() + 1, mode=d.get("mode"),
            meeting_link=d.get("meeting_link"), notes=d.get("notes"),
            created_by=self.actor(), updated_by=self.actor())
        target = "SCREENING" if "screen" in r.round_name.lower() else "INTERVIEW"
        stage = (cand.candidate_status or "").upper()
        if stage in EARLY_STAGES or stage == "FEEDBACK_PENDING":
            set_stage(cand, target, self.actor(), f"{r.round_name} scheduled ({r.interview_id})")
        mailed = _notify_interview(r) if str(d.get("notify")).lower() in ("1", "true", "yes") else None
        return ok("INTERVIEW_SCHEDULED", "Interview scheduled.", serialize_round(r, request),
                  status=201, email_sent=mailed)

    def retrieve(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        return ok("INTERVIEW_DETAIL", "Interview.", serialize_round(r, request))

    @transaction.atomic
    def partial_update(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        if r.status != "Scheduled":
            return err("INVALID_STATE", f"A {r.status} interview cannot be changed.")
        d = request.data
        try:
            if d.get("scheduled_at"):
                r.scheduled_at = to_datetime(d["scheduled_at"])
            if d.get("duration_minutes"):
                r.duration_minutes = int(d["duration_minutes"])
            if "interviewer" in d:
                r.interviewer = employee_by_code(r.company, d.get("interviewer"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        if r.interviewer and ("scheduled_at" in d or "interviewer" in d):
            clash = _interviewer_busy(r.company, r.interviewer, r.scheduled_at, r.duration_minutes, r.pk)
            if clash and str(d.get("force")).lower() not in ("1", "true"):
                return err("INTERVIEWER_BUSY", f"{r.interviewer.name} already has {clash.interview_id} at that time.", 409)
        for f in ("round_name", "mode", "meeting_link", "notes"):
            if f in d:
                setattr(r, f, d.get(f))
        r.updated_by = self.actor()
        r.save()
        return ok("INTERVIEW_UPDATED", "Interview updated.", serialize_round(r, request))

    update = partial_update

    def destroy(self, request, pk=None):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        if r.feedback_status == "Submitted":
            return err("IN_USE", "Interview has feedback. Cancel it instead of deleting.")
        r.is_active = False
        r.save(update_fields=["is_active", "updated_at"])
        return ok("INTERVIEW_DELETED", "Interview deleted.")

    def _set_status(self, request, pk, status, code):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        if r.status != "Scheduled":
            return err("INVALID_STATE", f"Interview is already {r.status}.")
        r.status, r.updated_by = status, self.actor()
        r.save()
        if status == "Completed" and r.feedback_status == "Pending" \
                and (r.candidate.candidate_status or "").upper() == "INTERVIEW":
            set_stage(r.candidate, "FEEDBACK_PENDING", self.actor(), f"{r.interview_id} completed")
        return ok(code, f"Interview marked {status}.", serialize_round(r, request))

    @action(detail=True, methods=["post"])
    def cancel(self, request, pk=None):
        return self._set_status(request, pk, "Cancelled", "INTERVIEW_CANCELLED")

    @action(detail=True, methods=["post"])
    def complete(self, request, pk=None):
        return self._set_status(request, pk, "Completed", "INTERVIEW_COMPLETED")

    @action(detail=True, methods=["post"], url_path="no-show")
    def no_show(self, request, pk=None):
        return self._set_status(request, pk, "No Show", "INTERVIEW_NO_SHOW")

    @action(detail=True, methods=["get", "post"])
    def feedback(self, request, pk=None):
        """HR/Admin view or submit the scorecard for a round."""
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        if request.method == "GET":
            fb = getattr(r, "feedback", None) if r.feedback_status == "Submitted" else None
            return ok("SCORECARD", "Scorecard.", serialize_feedback(fb, request) if fb else None)
        if r.status == "Cancelled":
            return err("INVALID_STATE", "Cancelled interview cannot receive feedback.")
        try:
            fb = save_feedback(r, request.data, r.interviewer, self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("FEEDBACK_SAVED", "Feedback saved.", serialize_feedback(fb, request), status=201)


# ------------------------------------------------------------
# 8. FEEDBACK LIST  GET /api/recruitment/feedback/
# ------------------------------------------------------------
class FeedbackListView(RecruitmentAuthMixin, APIView):

    def get(self, request):
        qs = InterviewFeedback.objects.filter(company=self.company(), is_active=True) \
            .select_related("interview", "interview__candidate", "interview__interviewer")
        p = request.query_params
        if p.get("candidate"):
            qs = qs.filter(interview__candidate_id=p["candidate"])
        if p.get("recommendation"):
            qs = qs.filter(recommendation__iexact=p["recommendation"])
        return ok("FEEDBACK_LIST", "Interview feedback & scorecards.",
                  [serialize_feedback(f, request) for f in qs.order_by("-created_at")])


# ------------------------------------------------------------
# 6. INTERVIEW CALENDAR
#    GET /api/recruitment/calendar/?year=2026&month=9
#    or  ?date_from=YYYY-MM-DD&date_to=YYYY-MM-DD
# ------------------------------------------------------------
class InterviewCalendarView(RecruitmentAuthMixin, APIView):

    def get(self, request):
        p = request.query_params
        today = timezone.localdate()
        try:
            if p.get("date_from") or p.get("date_to"):
                start = to_date(p.get("date_from")) or today
                end = to_date(p.get("date_to")) or (start + timedelta(days=30))
            else:
                year, month = int(p.get("year") or today.year), int(p.get("month") or today.month)
                start = datetime(year, month, 1).date()
                end = datetime(year, month, pycal.monthrange(year, month)[1]).date()
        except ValueError as e:
            return err("VALIDATION", str(e))
        qs = InterviewRound.objects.filter(company=self.company(), is_active=True,
                                           scheduled_at__date__gte=start, scheduled_at__date__lte=end) \
            .select_related("candidate", "interviewer")
        if p.get("interviewer"):
            qs = qs.filter(interviewer__employee_code=p["interviewer"])
        if p.get("status"):
            qs = qs.filter(status__iexact=p["status"])
        days = {}
        for r in qs.order_by("scheduled_at"):
            key = timezone.localtime(r.scheduled_at).date().isoformat()
            days.setdefault(key, []).append(serialize_round(r, request))
        return ok("INTERVIEW_CALENDAR", "Interview calendar.",
                  {"from": start, "to": end,
                   "days": [{"date": k, "count": len(v), "interviews": v} for k, v in sorted(days.items())]})


# ------------------------------------------------------------
# EMPLOYEE CONNECTION - interviewer self service (employee login)
#   GET  /api/recruitment/my-interviews/
#   POST /api/recruitment/my-interviews/<id>/feedback/
#   GET  /api/recruitment/interviewers/   (picker: employees for dropdowns)
# ------------------------------------------------------------
class MyInterviewsView(APIView):
    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAnyEmployee]

    def get(self, request):
        qs = InterviewRound.objects.filter(company=request.user.company, interviewer=request.user,
                                           is_active=True).select_related("candidate", "interviewer")
        if request.query_params.get("feedback_status"):
            qs = qs.filter(feedback_status__iexact=request.query_params["feedback_status"])
        if request.query_params.get("status"):
            qs = qs.filter(status__iexact=request.query_params["status"])
        return ok("MY_INTERVIEWS", "Interviews assigned to you.",
                  [serialize_round(r, request) for r in qs.order_by("scheduled_at")])


class MyInterviewFeedbackView(APIView):
    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsAnyEmployee]

    def post(self, request, pk):
        r = InterviewRound.objects.filter(company=request.user.company, interviewer=request.user,
                                          pk=pk, is_active=True).select_related("candidate").first()
        if r is None:
            return err("NOT_FOUND", "Interview not found or not assigned to you.", 404)
        if r.status == "Cancelled":
            return err("INVALID_STATE", "Interview was cancelled.")
        if r.scheduled_at > timezone.now() + timedelta(minutes=15):
            return err("TOO_EARLY", "Feedback can be submitted only once the interview has started.")
        try:
            fb = save_feedback(r, request.data, request.user, actor_label(request.user))
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("FEEDBACK_SAVED", "Feedback submitted.", serialize_feedback(fb, request), status=201)


class InterviewerPickerView(RecruitmentAuthMixin, APIView):
    """Active employees for hiring manager / interviewer / recruiter dropdowns."""

    def get(self, request):
        from Employee.models import EmployeeDT
        qs = EmployeeDT.objects.filter(company=self.company(), is_active=True)
        s = request.query_params.get("search")
        if s:
            qs = qs.filter(Q(name__icontains=s) | Q(employee_code__icontains=s) | Q(Designation__icontains=s))
        return ok("EMPLOYEE_PICKER", "Employees.", [emp_brief(e, request) for e in qs.order_by("name")[:200]])


# ------------------------------------------------------------
# 8. FEEDBACK - FULL CRUD  /api/recruitment/feedback/
#    POST   {"interview": <round id>, scores..., "recommendation": ...}
#    GET    list / <id>/        PATCH <id>/        DELETE <id>/
# ------------------------------------------------------------
class FeedbackViewSet(RecruitmentAuthMixin, ViewSet):

    def _get(self, pk):
        return InterviewFeedback.objects.filter(company=self.company(), pk=pk, is_active=True) \
            .select_related("interview", "interview__candidate", "interview__interviewer").first()

    def list(self, request):
        return FeedbackListView.get(self, request)

    def create(self, request):
        d = request.data
        r = InterviewRound.objects.filter(
            company=self.company(), is_active=True,
            pk=d.get("interview") if str(d.get("interview")).isdigit() else -1).select_related("candidate").first()
        if r is None:
            return err("NOT_FOUND", "Interview not found.", 404)
        if r.status == "Cancelled":
            return err("INVALID_STATE", "Cancelled interview cannot receive feedback.")
        if InterviewFeedback.objects.filter(interview=r).exists():
            return err("DUPLICATE", "Feedback already exists for this round. Use PATCH.", 409)
        try:
            fb = save_feedback(r, d, r.interviewer, self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("FEEDBACK_SAVED", "Feedback saved.", serialize_feedback(fb, request), status=201)

    def retrieve(self, request, pk=None):
        fb = self._get(pk)
        if fb is None:
            return err("NOT_FOUND", "Feedback not found.", 404)
        return ok("FEEDBACK_DETAIL", "Scorecard.", serialize_feedback(fb, request))

    def partial_update(self, request, pk=None):
        fb = self._get(pk)
        if fb is None:
            return err("NOT_FOUND", "Feedback not found.", 404)
        merged = {k: getattr(fb, k) for k in SCORE_FIELDS}
        merged.update({"recommendation": fb.recommendation, "strengths": fb.strengths,
                       "concerns": fb.concerns, "comments": fb.comments})
        merged.update({k: v for k, v in request.data.items()})
        try:
            fb = save_feedback(fb.interview, merged, fb.submitted_by, self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("FEEDBACK_UPDATED", "Feedback updated.", serialize_feedback(fb, request))

    update = partial_update

    @transaction.atomic
    def destroy(self, request, pk=None):
        fb = self._get(pk)
        if fb is None:
            return err("NOT_FOUND", "Feedback not found.", 404)
        r = fb.interview
        fb.delete()
        r.feedback_status = "Pending"
        r.save(update_fields=["feedback_status", "updated_at"])
        return ok("FEEDBACK_DELETED", "Feedback deleted. Round is Feedback Pending again.")
