# ============================================================
# ADDITIVE: Candidate REGISTRATION + AUTO-SAVE (draft) + resume
#
# HR / Admin sends the usual candidate link (candidate-links/ - already existing).
# The candidate opens it, REGISTERS (email + password) and then fills everything:
# profile, education, experience, documents.  Every step is auto-saved; after logging
# in again (same or another day / device) the form resumes at the first incomplete step.
#
#   Public base : /api/recruitment/hiring-plus/public/candidate/<token>/
#     status/                 GET   registered? (no login)          -> show Register or Login screen
#     register/               POST  {email, password}               -> {session}
#     login/                  POST  {email, password}               -> {session}
#     me/                     GET   snapshot + drafts + resume_step           [session]
#     home/                   GET / PATCH  same as the old portal home         [session]
#     draft/                  GET   all drafts                                 [session]
#     draft/<step>/           PUT   auto-save one step (any partial data)      [session]
#                             DELETE discard one step                          [session]
#     draft/commit/           POST  {"steps":["profile","career"]} -> write into the real candidate rows [session]
#     education/ experience/ documents/ submit/   same as the old portal, but gated by the session
#   Send the session as header   X-Candidate-Session: <session>
#
# The old no-login portal URLs keep working untouched.  Everything the candidate saves lands in
# the SAME rows HR / Admin read (EmployeeDT, CandidateEducation, EmployeeDocument ...).
# ============================================================
import re

from datetime import timedelta

from django.contrib.auth.hashers import check_password, make_password
from django.core import signing
from django.db import transaction
from django.utils import timezone
from rest_framework import status as http
from rest_framework.exceptions import APIException
from rest_framework.throttling import SimpleRateThrottle

from .common import err, ok
from .models_register import CandidatePortalAccount, CandidatePortalDraft
from .portal_identity import apply_identity, sync_identity      # ADDITIVE: real name/email sync (was used but never imported)
from .views_candidates import apply_personal
from .views_portal import (Locked, PortalBase, PortalDocumentItem, PortalDocuments, PortalEducationItem,
                           PortalEducationList, PortalExperienceItem, PortalExperienceList, PortalHome, PortalSubmit,
                           apply_career, clean_profile, log_activity, missing_items, snapshot)

SALT = "candidate-portal-session"
SESSION_DAYS = 7
MAX_FAILS, LOCK_MINUTES = 5, 15
MAX_DRAFT_BYTES = 100 * 1024
STEP_RE = re.compile(r"^[a-z][a-z0-9_]{0,39}$")
COMMITTABLE = ("profile", "career")
SECTION_ORDER = ("profile", "education", "documents")


class CandidateSessionRequired(APIException):
    status_code = http.HTTP_401_UNAUTHORIZED
    default_detail = "Please log in to continue."
    default_code = "CANDIDATE_LOGIN_REQUIRED"


class AuthThrottle(SimpleRateThrottle):
    rate = "20/min"
    scope = "candidate_portal_auth"

    def get_cache_key(self, request, view):
        return f"throttle_{self.scope}_{self.get_ident(request)}"


def _mask_email(e):
    e = e or ""
    if "@" not in e:
        return ""
    u, d = e.split("@", 1)
    return (u[:1] + "***" + (u[-1:] if len(u) > 2 else "")) + "@" + d


def _strong(pw):
    if not isinstance(pw, str) or len(pw) < 8 or len(pw) > 128:
        return "Password must be 8 to 128 characters."
    if not (re.search(r"[A-Za-z]", pw) and re.search(r"\d", pw)):
        return "Password must contain at least one letter and one number."
    return None


def _issue(acc, link):
    return signing.dumps({"a": acc.id, "l": link.id, "p": acc.password[-10:]}, salt=SALT)


def _session_from(request, token):
    raw = request.META.get("HTTP_X_CANDIDATE_SESSION") or ""
    auth = request.META.get("HTTP_AUTHORIZATION") or ""
    if not raw and auth.lower().startswith("candidate "):
        raw = auth.split(" ", 1)[1].strip()
    if not raw:
        raise CandidateSessionRequired()
    try:
        p = signing.loads(raw, salt=SALT, max_age=SESSION_DAYS * 86400)
    except signing.BadSignature:
        raise CandidateSessionRequired("Your session has expired. Please log in again.")
    acc = CandidatePortalAccount.objects.filter(pk=p.get("a"), is_active=True).select_related("candidate").first()
    from .models_portal import CandidatePortalLink
    link = CandidatePortalLink.objects.filter(pk=p.get("l"), token=token, is_active=True).first()
    if acc is None or link is None or acc.candidate_id != link.candidate_id or acc.password[-10:] != p.get("p"):
        raise CandidateSessionRequired("Your session is not valid for this link. Please log in again.")
    return acc


class SessionGate:
    """Mix in BEFORE a PortalBase view: the same endpoint, but it needs a registered candidate's session."""

    def initial(self, request, *args, **kwargs):
        super().initial(request, *args, **kwargs)
        self.account = _session_from(request, kwargs.get("token"))


# ============================================================
# status / register / login
# ============================================================
class _AuthBase(PortalBase):
    throttle_classes = [AuthThrottle]


class RegisterStatus(PortalBase):
    def get(self, request, token):
        l, c, e = self._ctx(token)
        if e:
            return e
        reg = CandidatePortalAccount.objects.filter(candidate=c).exists()
        return ok("REGISTER_STATUS", "Link is valid.", {
            "registered": reg, "next": "login" if reg else "register",
            "company": getattr(l.company, "Registered_Company_Name", None) or str(l.company),
            "candidate_name": c.name, "email_hint": _mask_email(l.sent_to or c.email),
            "expires_at": l.expires_at})


class Register(_AuthBase):
    @transaction.atomic
    def post(self, request, token):
        l, c, e = self._ctx(token, write=True)
        if e:
            return e
        email = str(request.data.get("email") or "").strip().lower()
        pw = request.data.get("password")
        allowed = {x.strip().lower() for x in (c.email, l.sent_to, getattr(c, "Personal_Email", None)) if x}
        if email not in allowed:
            return err("EMAIL_MISMATCH", "Please register with the e-mail address HR used to invite you.", 403)
        bad = _strong(pw)
        if bad:
            return err("WEAK_PASSWORD", bad)
        if request.data.get("confirm_password") not in (None, pw):
            return err("VALIDATION", "Password and confirm password do not match.")
        if CandidatePortalAccount.objects.filter(candidate=c).exists():
            return err("ALREADY_REGISTERED", "You are already registered. Please log in.", 409)
        acc = CandidatePortalAccount.objects.create(
            company=l.company, candidate=c, link=l, email=email, password=make_password(pw),
            last_login_at=timezone.now(), created_by=f"candidate-link:{l.pk}", updated_by=f"candidate-link:{l.pk}")
        sync_identity(c, l, request.data)          # ADDITIVE: registered e-mail / name replace the placeholder
        log_activity(l, c, "REGISTERED", {}, request, edit=False)
        return ok("REGISTERED", "Registration complete. You can now fill your details.",
                  {"session": _issue(acc, l), "session_valid_days": SESSION_DAYS, "email": email}, status=201)


class Login(_AuthBase):
    def post(self, request, token):
        l, c, e = self._ctx(token)
        if e:
            return e
        email = str(request.data.get("email") or "").strip().lower()
        acc = CandidatePortalAccount.objects.filter(candidate=c, is_active=True).first()
        now = timezone.now()
        if acc is None:
            return err("NOT_REGISTERED", "You are not registered yet. Please register first.", 404)
        if acc.locked_until and acc.locked_until > now:
            return err("LOCKED", "Too many wrong attempts. Please try again after some time.", 429)
        if acc.email != email or not check_password(str(request.data.get("password") or ""), acc.password):
            acc.failed_attempts += 1
            if acc.failed_attempts >= MAX_FAILS:
                acc.locked_until, acc.failed_attempts = now + timedelta(minutes=LOCK_MINUTES), 0
            acc.save(update_fields=["failed_attempts", "locked_until", "updated_at"])
            return err("BAD_CREDENTIALS", "E-mail or password is wrong.", 401)
        acc.failed_attempts, acc.locked_until, acc.last_login_at = 0, None, now
        acc.link = l
        acc.save(update_fields=["failed_attempts", "locked_until", "last_login_at", "link", "updated_at"])
        sync_identity(c, l)                        # ADDITIVE: heal old placeholder rows on next login
        log_activity(l, c, "LOGIN", {}, request, edit=False)
        return ok("LOGGED_IN", "Welcome back.", {"session": _issue(acc, l), "session_valid_days": SESSION_DAYS})


# ============================================================
# me (resume) + drafts
# ============================================================
def _ser_draft(d):
    return {"step": d.step, "data": d.data, "version": d.client_version, "saved_at": d.updated_at}


def resume_step(c, link):
    miss = missing_items(c, link)
    sections = {m["section"] for m in miss}
    for s in SECTION_ORDER:
        if s in sections:
            return s
    return "submit"


class Me(SessionGate, PortalBase):
    def get(self, request, token):
        l, c, e = self._ctx(token)
        if e:
            return e
        now = timezone.now()
        l.first_opened_at, l.last_opened_at = l.first_opened_at or now, now
        l.save(update_fields=["first_opened_at", "last_opened_at", "updated_at"])
        drafts = CandidatePortalDraft.objects.filter(candidate=c, is_active=True)
        return ok("CANDIDATE_ME", "Your application.", {
            "snapshot": snapshot(l, c), "drafts": {d.step: _ser_draft(d) for d in drafts},
            "resume_step": resume_step(c, l), "email": self.account.email})


class DraftList(SessionGate, PortalBase):
    def get(self, request, token):
        l, c, e = self._ctx(token)
        if e:
            return e
        return ok("DRAFTS", "Auto-saved drafts.",
                  [_ser_draft(d) for d in CandidatePortalDraft.objects.filter(candidate=c, is_active=True)])


class DraftItem(SessionGate, PortalBase):
    def put(self, request, token, step):
        l, c, e = self._ctx(token, write=True)
        if e:
            return e
        if not STEP_RE.match(step):
            return err("VALIDATION", "Step name must be lowercase letters, digits or underscore.")
        data = request.data.get("data")
        if not isinstance(data, dict):
            return err("VALIDATION", "'data' must be an object with the form values.")
        import json
        if len(json.dumps(data, default=str)) > MAX_DRAFT_BYTES:
            return err("VALIDATION", "Draft is too large.")
        stripped = [k for k in ("aadhaar_number", "pan_number") if data.pop(k, None) is not None]
        # identity numbers are never kept in a draft copy - save them with PATCH home/ (validated + masked)
        try:
            ver = int(request.data.get("version") or 0)
        except (TypeError, ValueError):
            return err("VALIDATION", "version must be a number.")
        d, _ = CandidatePortalDraft.objects.get_or_create(
            candidate=c, step=step, defaults={"company": l.company, "created_by": f"candidate-link:{l.pk}"})
        if ver and ver < d.client_version:                   # an older tab / delayed request - keep the newer one
            return ok("DRAFT_IGNORED", "A newer draft already exists.", _ser_draft(d), ignored=True)
        d.data, d.client_version, d.is_active = data, ver or d.client_version + 1, True
        d.updated_by = f"candidate-link:{l.pk}"
        d.save()
        sync_identity(c, l, data)                  # ADDITIVE: real name / e-mail typed in the form
        l.last_edit_at = timezone.now()
        l.save(update_fields=["last_edit_at", "updated_at"])
        return ok("DRAFT_SAVED", "Auto-saved.", _ser_draft(d), ignored=False, not_stored=stripped)

    def delete(self, request, token, step):
        l, c, e = self._ctx(token, write=True)
        if e:
            return e
        n, _ = CandidatePortalDraft.objects.filter(candidate=c, step=step).delete()
        return ok("DRAFT_DELETED", "Draft discarded." if n else "No draft for this step.", None)


class DraftCommit(SessionGate, PortalBase):
    """Turn the saved draft(s) into real candidate data (same validation as the normal save)."""

    @transaction.atomic
    def post(self, request, token):
        l, c, e = self._ctx(token, write=True)
        if e:
            return e
        steps = request.data.get("steps") or list(COMMITTABLE)
        if not isinstance(steps, list) or any(s not in COMMITTABLE for s in steps):
            return err("VALIDATION", f"steps can only contain: {', '.join(COMMITTABLE)}.")
        drafts = {d.step: d for d in CandidatePortalDraft.objects.filter(candidate=c, step__in=steps)}
        if not drafts:
            return err("NOT_FOUND", "Nothing saved for these steps.", 404)
        merged = {}
        for s in steps:
            if s in drafts:
                merged.update(drafts[s].data)
        try:
            cleaned, changed = clean_profile(c, merged)
            apply_personal(c, cleaned, None)
            changed += apply_identity(c, merged)  
            changed += apply_career(c, merged)
        except Locked as x:
            transaction.set_rollback(True)
            return err("LOCKED", str(x), 403)
        except ValueError as x:
            transaction.set_rollback(True)
            return err("VALIDATION", str(x))
        c.updated_by = f"candidate-link:{l.pk}"
        c.save()
        if changed:
            log_activity(l, c, "PROFILE_UPDATED", {"fields": sorted(set(changed)), "via": "draft"}, request)
        CandidatePortalDraft.objects.filter(pk__in=[d.pk for d in drafts.values()]).delete()
        return ok("DRAFT_COMMITTED", "Saved to your application.", {"snapshot": snapshot(l, c),
                                                                    "resume_step": resume_step(c, l)})


# ============================================================
# gated mirrors of the existing portal endpoints 
# ============================================================
class GHome(SessionGate, PortalHome):
    pass


class GSubmit(SessionGate, PortalSubmit):
    pass


class GEducationList(SessionGate, PortalEducationList):
    pass


class GEducationItem(SessionGate, PortalEducationItem):
    pass


class GExperienceList(SessionGate, PortalExperienceList):
    pass


class GExperienceItem(SessionGate, PortalExperienceItem):
    pass


class GDocuments(SessionGate, PortalDocuments):
    pass


class GDocumentItem(SessionGate, PortalDocumentItem):
    pass
