# ============================================================
# ADDITIVE: Document & Letter Issuance Center - letterhead, prefilled form, PDF preview, regenerate
# Mounted at /api/people/letter-center/...   (People/letter_center_urls.py)
# Rights (Employees module): GET = view | preview-pdf = create | letterhead POST / regenerate = edit.  Company scoped (B2B).
#
#   GET  letterhead/                    the company's letterhead settings + what is really used (company master / letterhead)
#   POST letterhead/                    edit (JSON or multipart: logo, stamp, signature files; remove_logo / remove_stamp / remove_signature)
#   GET  letterhead/preview/            sample PDF in the current letterhead (check logo, CIN, footer, stamp)
#   GET  variables/                     ?letter_type=&recipient_code=|candidate_id=  the "Generate New Letter" form, every value read from the models
#   POST preview/                       final text of a letter (markup + plain), nothing saved
#   POST preview-pdf/                   the real PDF of a letter, nothing saved
#   POST letters/<id>/regenerate/       re-render an already issued letter in the CURRENT letterhead
#   GET  markup/                        how to write / change a letter body
#   GET  defaults/                      the standard bodies of the 9 letter types (start of a custom template)
# ============================================================
import io
import re

from django.core.files.base import ContentFile
from django.http import HttpResponse
from django.utils import timezone
from rest_framework import status as http
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.views import APIView

from . import letter_data as ld
from . import letter_format as lf
from .common import PeopleAuthMixin, emp_brief, emp_by_code, err, iso, ok, to_bool
from .letters import BASE_PLACEHOLDERS, LEGACY_TEMPLATES, TEMPLATES, issue_letter, render_pdf, resolve_template  # noqa: F401
from .models import CompanyLetterhead, EmployeeLetter, LetterTemplate
from .views_vault import CARD_MAP, CARDS, candidate_by_ref, file_url, offer_defaults

CIN_RE = re.compile(r"^[LU]\d{5}[A-Z]{2}\d{4}[A-Z]{3}\d{6}$")
MAX_IMAGE_BYTES = 1_500_000
TEXT_FIELDS = {"legal_name": 200, "footer_name": 200, "short_name": 120, "website": 200, "place": 80,
               "signatory_name": 150, "signatory_title": 100}
MULTILINE = {"registered_office": 500, "footer_address": 500}
POLICY_INT = {"probation_months": (0, 24), "notice_probation_days": (0, 180), "notice_confirmed_days": (0, 365),
              "leave_in_probation_days": (0, 30)}
POLICY_TXT = {"salary_disbursal": 80, "employment_status": 60}


def one_line(v):
    return re.sub(r"\s+", " ", str(v or "")).strip()


def image_info(request, company, lh, kind):
    f = getattr(lh, kind, None) if lh else None
    if f and getattr(f, "name", None):
        return {"url": file_url(request, f), "from": "letterhead"}
    if kind == "logo" and getattr(company, "Company_logo", None) and getattr(company.Company_logo, "name", None):
        return {"url": file_url(request, company.Company_logo), "from": "company master"}
    return {"url": None, "from": "none"}


def letterhead_payload(request, company):
    lh = CompanyLetterhead.objects.filter(company=company).first()
    ctx = lf.letterhead_context(company)
    raw = {k: (getattr(lh, k, "") if lh else "") for k in list(TEXT_FIELDS) + list(MULTILINE) + ["cin"]}
    master = {"legal_name": company.Registered_Company_Name, "short_name": company.Registered_Company_Name,
              "website": company.Website, "registered_office": company.REGISTERED_OFFICE_add or company.Company_address}
    eff = {k: ctx[k] for k in ("legal_name", "footer_name", "short_name", "cin", "website", "registered_office",
                              "footer_address", "place", "signatory_name", "signatory_title")}
    origin = {k: ("letterhead" if raw.get(k) else ("company master" if master.get(k) and eff.get(k) else
                                                   "default" if eff.get(k) else "not set")) for k in eff}
    reg, bold, scale, rupee = lf.fonts()
    return {
        "settings": {**raw, "header_style": ctx["header_style"], "footer_enabled": ctx["footer_enabled"],
                     "page_size": ctx["page_size"], "body_font_size": ctx["font_size"], "show_ref_no": ctx["show_ref_no"],
                     "policy_defaults": ctx["policy"], "configured": lh is not None,
                     "updated_by": getattr(lh, "updated_by", None), "updated_at": iso(getattr(lh, "updated_at", None))},
        "effective": eff, "source": origin,
        "images": {k: image_info(request, company, lh, k) for k in ("logo", "stamp", "signature")},
        "choices": {"header_style": [{"value": v, "label": l} for v, l in CompanyLetterhead.HEADER],
                    "page_size": [{"value": v, "label": l} for v, l in CompanyLetterhead.PAGE]},
        "limits": {"image_types": ["png", "jpg", "jpeg"], "image_max_bytes": MAX_IMAGE_BYTES, "image_max_pixels": 4000,
                   "font_size": [8, 14]},
        "font": {"family": reg, "supports_rupee_sign": rupee},
    }


def check_image(f):
    ext = (f.name.rsplit(".", 1)[-1] if "." in f.name else "").lower()
    if ext not in ("png", "jpg", "jpeg"):
        raise ValueError("Images must be PNG or JPG.")
    if f.size > MAX_IMAGE_BYTES:
        raise ValueError(f"Image is too large (max {MAX_IMAGE_BYTES // 1000} KB).")
    try:
        from PIL import Image
        im = Image.open(f)
        im.verify()
        f.seek(0)
        w, h = Image.open(f).size
        f.seek(0)
    except Exception:                                            # noqa: BLE001
        raise ValueError("The file is not a valid image.")
    if w > 4000 or h > 4000:
        raise ValueError("Image is too large (max 4000 x 4000 pixels).")


class LetterheadView(PeopleAuthMixin, APIView):
    permission_action = "view"
    parser_classes = [JSONParser, MultiPartParser, FormParser]

    def get(self, request):
        return ok("LETTERHEAD", "Letterhead settings.", letterhead_payload(request, self.company()))

    def post(self, request):
        from .common import people_allows
        if not people_allows(request.user, "edit"):
            return err("FORBIDDEN", "Changing the letterhead needs the Employees 'edit' right.", http.HTTP_403_FORBIDDEN)
        company, d, actor = self.company(), request.data, self.actor()
        lh = CompanyLetterhead.objects.filter(company=company).first() or CompanyLetterhead(company=company, created_by=actor)
        try:
            for f, mx in TEXT_FIELDS.items():
                if f in d:
                    v = one_line(d[f])
                    if len(v) > mx:
                        raise ValueError(f"{f} is too long (max {mx} characters).")
                    if f == "website" and v and (" " in v or v.lower().startswith(("javascript:", "data:"))):
                        raise ValueError("website must be a plain address such as www.example.com.")
                    setattr(lh, f, v)
            for f, mx in MULTILINE.items():
                if f in d:
                    v = re.sub(r"[ \t]+", " ", str(d[f] or "").replace("\r", "")).strip()
                    if len(v) > mx:
                        raise ValueError(f"{f} is too long (max {mx} characters).")
                    setattr(lh, f, v)
            if "cin" in d:
                v = one_line(d["cin"]).upper()
                if v and not CIN_RE.match(v):
                    raise ValueError("CIN must look like U26939PN2013PTC146665 (21 characters).")
                lh.cin = v
            if "header_style" in d:
                v = str(d["header_style"] or "").upper()
                if v not in dict(CompanyLetterhead.HEADER):
                    raise ValueError("header_style must be FULL, LOGO_ONLY or NONE.")
                lh.header_style = v
            if "page_size" in d:
                v = str(d["page_size"] or "").upper()
                if v not in dict(CompanyLetterhead.PAGE):
                    raise ValueError("page_size must be A4 or LETTER.")
                lh.page_size = v
            if "body_font_size" in d:
                try:
                    n = int(d["body_font_size"])
                except (TypeError, ValueError):
                    raise ValueError("body_font_size must be a whole number (8 - 14).")
                if n < 8 or n > 14:
                    raise ValueError("body_font_size must be between 8 and 14.")
                lh.body_font_size = n
            for f in ("footer_enabled", "show_ref_no"):
                if f in d:
                    setattr(lh, f, to_bool(d[f]))
            if "policy_defaults" in d:
                pd = d["policy_defaults"]
                if isinstance(pd, str):
                    import json
                    try:
                        pd = json.loads(pd)
                    except ValueError:
                        raise ValueError("policy_defaults must be a JSON object.")
                if not isinstance(pd, dict):
                    raise ValueError("policy_defaults must be an object.")
                bad = [k for k in pd if k not in POLICY_INT and k not in POLICY_TXT]
                if bad:
                    raise ValueError("Unknown policy field(s): " + ", ".join(bad) + ". Allowed: " + ", ".join(list(POLICY_INT) + list(POLICY_TXT)))
                merged = {**ctx_policy(lh)}
                for k, v in pd.items():
                    if k in POLICY_INT:
                        lo, hi = POLICY_INT[k]
                        try:
                            n = int(v)
                        except (TypeError, ValueError):
                            raise ValueError(f"{k} must be a whole number.")
                        if n < lo or n > hi:
                            raise ValueError(f"{k} must be between {lo} and {hi}.")
                        merged[k] = n
                    else:
                        t = one_line(v)
                        if not t or len(t) > POLICY_TXT[k]:
                            raise ValueError(f"{k} is required (max {POLICY_TXT[k]} characters).")
                        merged[k] = t
                lh.policy_defaults = merged
            for kind in ("logo", "stamp", "signature"):
                up = request.FILES.get(kind)
                if up is not None:
                    check_image(up)
                if up is None and to_bool(d.get("remove_" + kind)):
                    getattr(lh, kind).delete(save=False)
                    setattr(lh, kind, None)
            if lh.cin and CompanyLetterhead.objects.filter(cin__iexact=lh.cin).exclude(company=company).exists():
                return err("DUPLICATE", "This CIN is already registered by another company account.", http.HTTP_409_CONFLICT,
                           errors={"cin": "already registered"})
        except ValueError as e:
            return err("VALIDATION", str(e))
        lh.updated_by = actor
        lh.save()
        for kind in ("logo", "stamp", "signature"):
            up = request.FILES.get(kind)
            if up is not None:
                old = getattr(lh, kind)
                if old and getattr(old, "name", None):
                    old.delete(save=False)
                getattr(lh, kind).save(up.name, up, save=False)
        lh.save()
        return ok("LETTERHEAD_SAVED", "Letterhead saved.", letterhead_payload(request, company))


def ctx_policy(lh):
    from .letter_models import default_policy
    return {**default_policy(), **(lh.policy_defaults or {} if lh.pk else {})}


def pdf_response(data, name="letter.pdf", download=False):
    r = HttpResponse(data, content_type="application/pdf")
    r["Content-Disposition"] = f'{"attachment" if download else "inline"}; filename="{name}"'
    return r


class LetterheadPreviewView(PeopleAuthMixin, APIView):
    permission_action = "view"

    def get(self, request):
        company = self.company()
        ctx = lf.letterhead_context(company)
        today = timezone.localdate()
        body = ("[[ordinal_dates]]\n# SAMPLE LETTER\n\n>> **Date:** " + today.strftime("%d %B %Y") + "\n\n.. **To,**\n**Employee Name**\nEmployee address\n\n"
                "Dear Employee,\nThis page shows how every letter issued by " + (ctx["short_name"] or "your company") + " will look: logo, company block, "
                "title, body, signature and the footer with CIN and website.\n\nWarm regards,\n[[stampsign]]\n**" + ctx["signatory_title"] + "**\n"
                + (ctx["short_name"] or "") + "\nDate: " + today.strftime("%d/%m/%Y"))
        return pdf_response(lf.render_letter_pdf(ctx, "Letterhead preview", body, {}, ""), "letterhead-preview.pdf")


# ------------------------------------------------------------------ recipient + payload helpers
def resolve_recipient(company, d, lt):
    ref = d.get("recipient_code") or d.get("employee_code") or d.get("candidate_id")
    if not ref:
        raise ValueError("recipient_code (employee code, or candidate code / id for an Offer letter) is required.")
    try:
        emp = emp_by_code(company, ref)
    except ValueError:
        emp = candidate_by_ref(company, ref) if lt == "OFFER" else None
        if emp is None:
            raise
    defaults = offer_defaults(emp) if lt == "OFFER" else {}
    extra = dict(d["variables"]) if isinstance(d.get("variables"), dict) else {}
    return emp, defaults, extra


def letter_type_of(v):
    lt = str(v or "").upper()
    if lt not in TEMPLATES:
        raise ValueError("Invalid letter_type. Allowed: " + ", ".join(CARD_MAP))
    return lt


class LetterVariablesView(PeopleAuthMixin, APIView):
    permission_action = "view"

    def get(self, request):
        company, p = self.company(), request.query_params
        try:
            lt = letter_type_of(p.get("letter_type"))
            emp, defaults, extra = resolve_recipient(company, {"recipient_code": p.get("recipient_code") or p.get("candidate_id") or p.get("employee_code")}, lt)
        except ValueError as e:
            code = "NOT_FOUND" if "not found" in str(e).lower() else "VALIDATION"
            return err(code, str(e), http.HTTP_404_NOT_FOUND if code == "NOT_FOUND" else http.HTTP_400_BAD_REQUEST)
        rows, values, _ = ld.form_for(emp, lt, extra, company, defaults)
        subject, body = resolve_template(company, lt)
        return ok("LETTER_FORM", "Letter form with values read from the models.", {
            "letter_type": lt, "recipient": {**emp_brief(emp, request)}, "fields": rows,
            "subject": ld.format_body(subject, values), "has_custom_template": LetterTemplate.objects.filter(company=company, code=lt, is_active=True).exists(),
            "values": {k: v for k, v in values.items() if not k.endswith("_block")},
            "missing": [r["key"] for r in rows if r["required"] and not r["value"]]})


class LetterPreviewView(PeopleAuthMixin, APIView):
    permission_action = "create"

    def post(self, request):
        company, d = self.company(), request.data
        try:
            lt = letter_type_of(d.get("letter_type"))
            emp, defaults, extra = resolve_recipient(company, d, lt)
        except ValueError as e:
            return err("VALIDATION", str(e))
        v, src = ld.build_variables_v2(emp, extra, company, defaults)
        s, b = resolve_template(company, lt)
        body = ld.format_body(d.get("body") or b, v)
        return ok("LETTER_PREVIEW", "Letter preview (not saved).", {
            "subject": ld.format_body(d.get("subject") or s, v).replace("\n", " "), "body": body, "body_plain": lf.plain_text(body),
            "variables": {k: x for k, x in v.items() if not k.endswith("_block")}, "sources": src})


class LetterPreviewPdfView(PeopleAuthMixin, APIView):
    permission_action = "create"

    def post(self, request):
        company, d = self.company(), request.data
        try:
            lt = letter_type_of(d.get("letter_type"))
            emp, defaults, extra = resolve_recipient(company, d, lt)
        except ValueError as e:
            return err("VALIDATION", str(e))
        v, _ = ld.build_variables_v2(emp, extra, company, defaults)
        s, b = resolve_template(company, lt)
        body = ld.format_body(d.get("body") or b, v)
        return pdf_response(render_pdf(v["company_name"], v["company_address"], s, body, "PREVIEW", company=company, variables=v),
                            f"{lt.lower()}-preview.pdf")


class LetterRegenerateView(PeopleAuthMixin, APIView):
    permission_action = "edit"

    def post(self, request, pk):
        company = self.company()
        l = EmployeeLetter.objects.filter(company=company, pk=pk, is_active=True).select_related("employee").first()
        if l is None:
            return err("NOT_FOUND", "Letter not found.", http.HTTP_404_NOT_FOUND)
        v = l.variables or {}
        pdf = render_pdf(v.get("company_name") or "", v.get("company_address") or "", l.subject or "", l.body, l.letter_no,
                         company=company, variables=v)
        if l.pdf_file:
            l.pdf_file.delete(save=False)
        l.pdf_file.save(f"{l.letter_no}.pdf", ContentFile(pdf), save=False)
        l.updated_by = self.actor()
        l.save()
        return ok("LETTER_REGENERATED", "The PDF was re-created in the current letterhead.",
                  {"id": l.id, "letter_no": l.letter_no, "view_url": f"/api/people/generated-letters/{l.id}/pdf/",
                   "download_url": f"/api/people/generated-letters/{l.id}/download/"})


class LetterMarkupView(PeopleAuthMixin, APIView):
    permission_action = "view"

    def get(self, request):
        return ok("LETTER_MARKUP", "How to write a letter body.", {
            **lf.MARKUP_HELP, "base_placeholders": list(BASE_PLACEHOLDERS),
            "example": "# OFFER LETTER\n\n>> **Date:** {date}\n\nDear {first_name},\nWe are pleased to offer you **{designation}**.\n\n"
                       "[[stampsign]]\n**{signatory_title}**\n{company_short_name}"})


class LetterDefaultsView(PeopleAuthMixin, APIView):
    permission_action = "view"

    def get(self, request):
        company = self.company()
        custom = set(LetterTemplate.objects.filter(company=company, is_active=True).values_list("code", flat=True))
        return ok("LETTER_DEFAULTS", "Standard letter bodies (in the company letter format).", [
            {"code": c, "title": t, "description": d, "subject": TEMPLATES[c][0], "body": TEMPLATES[c][1], "customised": c in custom}
            for c, t, d in CARDS])
