"""Render the Cortex Bank knowledge base into realistic PDF documents.

Usage: python -m generator.render_pdfs   (run from cortex/)
Outputs: pdfs/*.pdf, pdfs/manifest.json
"""
import json
from pathlib import Path

from reportlab.lib import colors
from reportlab.lib.enums import TA_RIGHT
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
from reportlab.lib.units import mm
from reportlab.platypus import Image, Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle

from content import bank as B

ROOT = Path(__file__).resolve().parent.parent
OUT = ROOT / "pdfs"
LOGO = ROOT / "docs" / "brand" / "cortex-logo.png"

NAVY = colors.HexColor("#0B1B3A")
ORANGE = colors.HexColor("#F97316")
GREY = colors.HexColor("#64748B")
LEVEL_LABEL = {0: "L0 PUBLIC / CONTRACTOR", 1: "L1 INTERNAL", 2: "L2 CONFIDENTIAL", 3: "L3 RESTRICTED", 4: "L4 HIGHLY RESTRICTED"}

ss = getSampleStyleSheet()
S = {
    "title": ParagraphStyle("t", parent=ss["Title"], textColor=NAVY, fontSize=18, leading=22, alignment=0, spaceAfter=4),
    "h": ParagraphStyle("h", parent=ss["Heading2"], textColor=NAVY, fontSize=12, spaceBefore=10, spaceAfter=4),
    "p": ParagraphStyle("p", parent=ss["BodyText"], fontSize=9.5, leading=13),
    "small": ParagraphStyle("s", parent=ss["BodyText"], fontSize=8, textColor=GREY),
    "cls": ParagraphStyle("c", parent=ss["BodyText"], fontSize=8, textColor=ORANGE, alignment=TA_RIGHT),
}

DEPT = {d[0]: d for d in B.DEPARTMENTS}
REG = {r[0]: r for r in B.REGULATIONS}
CTL = {c[0]: c for c in B.CONTROLS}
RISK = {r[0]: r for r in B.RISKS}
SYS = {s[0]: s for s in B.SYSTEMS}
POL = {p[0]: p for p in B.POLICIES}


def reg(rid):
    return f"{REG[rid][1]} ({rid})"


def ctl(cid):
    return f"{CTL[cid][1]} ({cid})"


def sysn(sid):
    return f"{SYS[sid][1]} ({sid})"


def dept(code):
    return f"{DEPT[code][1]} ({code})"


def table(rows, widths, header=True):
    t = Table(rows, colWidths=widths, repeatRows=1 if header else 0)
    style = [("FONTSIZE", (0, 0), (-1, -1), 8), ("GRID", (0, 0), (-1, -1), 0.3, colors.HexColor("#CBD5E1")),
             ("VALIGN", (0, 0), (-1, -1), "TOP")]
    if header:
        style += [("BACKGROUND", (0, 0), (-1, 0), NAVY), ("TEXTCOLOR", (0, 0), (-1, 0), colors.white)]
    t.setStyle(TableStyle(style))
    return t


def P(text, style="p"):
    return Paragraph(text, S[style])


def bullets(items):
    return [P(f"• {i}") for i in items]


class Doc:
    def __init__(self, doc_id, title, doc_type, dept_code, level, version, effective, owner=None):
        self.id, self.title, self.type, self.dept, self.level = doc_id, title, doc_type, dept_code, level
        self.version, self.effective = version, effective
        self.owner = owner or DEPT[dept_code][2]
        self.body = []

    def meta(self):
        return {"id": self.id, "title": self.title, "type": self.type, "dept": self.dept, "level": self.level,
                "version": self.version, "effective": self.effective, "file": f"{self.id}.pdf"}

    def render(self):
        path = OUT / f"{self.id}.pdf"
        cls = LEVEL_LABEL[self.level]

        def frame(canvas, doc):
            canvas.saveState()
            if LOGO.exists():
                canvas.drawImage(str(LOGO), 18 * mm, 277 * mm, 12 * mm, 12 * mm, mask="auto")
            canvas.setFont("Helvetica-Bold", 11)
            canvas.setFillColor(NAVY)
            canvas.drawString(32 * mm, 284 * mm, "CORTEX BANK")
            canvas.setFont("Helvetica", 7)
            canvas.setFillColor(GREY)
            canvas.drawString(32 * mm, 280 * mm, f"{B.BANK['tagline']}  |  {B.BANK['hq']}")
            canvas.setFillColor(ORANGE)
            canvas.setFont("Helvetica-Bold", 8)
            canvas.drawRightString(192 * mm, 284 * mm, cls)
            canvas.setFillColor(GREY)
            canvas.setFont("Helvetica", 7)
            canvas.drawRightString(192 * mm, 280 * mm, f"{self.id}  v{self.version}")
            canvas.line(18 * mm, 276 * mm, 192 * mm, 276 * mm)
            canvas.drawString(18 * mm, 10 * mm, f"{cls}  -  Synthetic document for demonstration. Not a real bank.")
            canvas.drawRightString(192 * mm, 10 * mm, f"Page {doc.page}")
            canvas.restoreState()

        head = [P(self.title, "title"),
                table([["Document ID", self.id, "Type", self.type],
                       ["Owner", f"{self.owner}, {DEPT[self.dept][1]}", "Classification", cls],
                       ["Version", self.version, "Effective", self.effective]],
                      [28 * mm, 62 * mm, 28 * mm, 56 * mm], header=False),
                Spacer(1, 6)]
        SimpleDocTemplate(str(path), pagesize=A4, topMargin=26 * mm, bottomMargin=18 * mm,
                          leftMargin=18 * mm, rightMargin=18 * mm, title=self.title,
                          author="Cortex Bank (synthetic)").build(head + self.body, onFirstPage=frame, onLaterPages=frame)


def approval(d, approver):
    return [P("Approval", "h"), table([["Approved by", "Date"], [approver, d.effective]], [120 * mm, 54 * mm])]


def related(ids):
    return [P("Related Documents", "h"), P(", ".join(ids))] if ids else []


def build_policy(p):
    pid, title, dcode, regs, ctls, stmts, ver, eff, lvl = p
    d = Doc(pid, title, "Policy", dcode, lvl, ver, eff)
    sops = [s[0] for s in B.SOPS if pid in s[3]]
    grds = [g[0] for g in B.GUARDRAILS if pid in g[3]]
    risks = sorted({r for c in ctls for r in CTL[c][5]})
    d.body += [P("1. Purpose", "h"),
               P(f"This policy sets out Cortex Bank's requirements for {title.replace(' Policy', '')}. "
                 f"It is owned by the {d.owner} in {dept(dcode)} and applies to all staff, contractors and subsidiaries.")]
    if regs:
        d.body += [P("2. Regulatory Basis", "h"),
                   P("This policy implements the bank's obligations under " + "; ".join(reg(r) for r in regs) + "."),
                   *bullets(f"{REG[r][1]}: {REG[r][3]}" for r in regs)]
    d.body += [P("3. Policy Statements", "h"), *bullets(stmts)]
    if ctls:
        d.body += [P("4. Key Controls", "h"),
                   P("Compliance with this policy is achieved through the following controls:"),
                   table([["Control", "Name", "Type", "Frequency", "Owner", "Mitigates"]] +
                         [[c, Paragraph(CTL[c][1], S["p"]), CTL[c][2], CTL[c][3], CTL[c][4], ", ".join(CTL[c][5])] for c in ctls],
                         [22 * mm, 62 * mm, 20 * mm, 22 * mm, 14 * mm, 34 * mm])]
    if risks:
        d.body += [P("5. Risks Addressed", "h"), P(", ".join(f"{RISK[r][1]} ({r})" for r in risks) + ".")]
    if sops:
        d.body += [P("6. Implementing Procedures", "h"), P("This policy is implemented by: " + ", ".join(sops) + ".")]
    if grds:
        d.body += [P("7. Applicable Standards", "h"), P("The following guardrail standards apply: " + ", ".join(grds) + ".")]
    d.body += related(sops + grds + regs) + approval(d, "Board Risk Committee" if lvl >= 2 else DEPT[dcode][2])
    return d


def build_sop(s):
    sid, title, dcode, pols, systems, steps, ver, eff, lvl = s
    d = Doc(sid, title, "Standard Operating Procedure", dcode, lvl, ver, eff)
    legacy = [l for l in B.LEGACY_SOPS if l[6] == sid]
    grds = [g[0] for g in B.GUARDRAILS if sid in g[3]]
    d.body += [P("1. Purpose and Scope", "h"),
               P(f"This procedure describes how {DEPT[dcode][1]} performs '{title}'. "
                 f"It implements " + ", ".join(f"{POL[p][1]} ({p})" for p in pols) + ".")]
    if systems:
        d.body += [P("2. Systems Used", "h"), *bullets(f"{sysn(x)}: {SYS[x][2]}" for x in systems)]
    rows = [["Step", "Activity", "Controls"]]
    for i, (text, cs) in enumerate(steps, 1):
        rows.append([str(i), Paragraph(text, S["p"]), Paragraph("<br/>".join(ctl(c) for c in cs) or "-", S["p"])])
    d.body += [P("3. Procedure", "h"), table(rows, [12 * mm, 100 * mm, 62 * mm])]
    if grds:
        d.body += [P("4. Guardrails", "h"), P("This procedure is subject to: " + ", ".join(grds) + ".")]
    vh = [["Version", "Effective", "Change"]]
    for l in legacy:
        vh.append([l[3], l[4], f"Original procedure ({l[0]}), retired {l[5]}."])
    vh.append([ver, eff, "Current version." + (f" Supersedes {legacy[0][0]}." if legacy else "")])
    d.body += [P("5. Version History", "h"), table(vh, [18 * mm, 24 * mm, 132 * mm])]
    d.body += related(pols + grds + [l[0] for l in legacy]) + approval(d, DEPT[dcode][2])
    return d


def build_legacy(l):
    lid, title, dcode, ver, eff, retired, sup, summary, lvl = l
    d = Doc(lid, title, "Standard Operating Procedure (Retired)", dcode, lvl, ver, eff)
    d.body += [P("STATUS: RETIRED", "h"),
               P(f"This procedure was in force from {eff} until {retired}. It is superseded by {sup}. Retained for record-keeping only."),
               P("1. Procedure Summary", "h"), P(summary)] + related([sup])
    return d


def build_guardrail(g):
    gid, title, dcode, applies, rules, lvl = g
    d = Doc(gid, title, "Guardrail Standard", dcode, lvl, "1.0", "2025-01-01")
    d.body += [P("1. Purpose", "h"), P(f"This standard defines mandatory guardrails. Owner: {dept(dcode)}."),
               P("2. Mandatory Rules", "h"), *bullets(rules),
               P("3. Applies To", "h"), P(", ".join(applies) + ".")]
    if gid == "GRD-004":
        rows = [["Role", "Clearance", "Department scope"]] + [[r[1], f"L{r[2]}", ", ".join(r[3])] for r in B.ROLES]
        d.body += [P("4. Role Access Matrix", "h"), table(rows, [70 * mm, 30 * mm, 74 * mm])]
    return d


def build_kri(k):
    kid, title, dcode, lvl, inds = k
    d = Doc(kid, title, "KRI / KPI Framework", dcode, lvl, "2026.Q2", "2026-06-30")
    rows = [["Indicator", "Name", "Measures", "Target", "Current", "Status"]]
    rows += [[i[0], Paragraph(i[1], S["p"]), ", ".join(i[2]), i[3], i[4], i[5]] for i in inds]
    breaches = [i for i in inds if i[5] == "Breach"]
    d.body += [P("1. Purpose", "h"), P(f"Key indicators monitored by {dept(dcode)} and reported quarterly to the Board Risk Committee."),
               P("2. Indicators (as at 30 June 2026)", "h"),
               table(rows, [20 * mm, 62 * mm, 26 * mm, 20 * mm, 20 * mm, 26 * mm])]
    if breaches:
        d.body += [P("3. Breaches Requiring Action", "h"),
                   *bullets(f"{i[0]} ({i[1]}) is in breach: {i[4]} against a target of {i[3]}. Linked control: {', '.join(ctl(c) for c in i[2])}." for i in breaches)]
    return d


def build_audit(a):
    aid, title, date, lvl, scope, findings = a
    d = Doc(aid, title, "Internal Audit Report", "IAU", lvl, "Final", date)
    rating = "Unsatisfactory" if any(f[2] == "High" for f in findings) else "Needs Improvement"
    d.body += [P("1. Executive Summary", "h"),
               P(f"Internal Audit reviewed {', '.join(dept(s) for s in scope)}. Overall rating: <b>{rating}</b>. "
                 f"{len(findings)} finding(s) raised, reported to the Board Audit Committee."),
               P("2. Findings", "h")]
    for f in findings:
        d.body += [P(f"<b>{f[0]}: {f[1]}</b>"),
                   P(f"Severity: {f[2]}. Control: {ctl(f[3])}. Owner: {dept(f[4])}. Remediation due: {f[5]}. Status: {f[6]}."),
                   Spacer(1, 4)]
    return d


def build_regsum(r):
    rid, short, full, summary = r
    pols = [p for p in B.POLICIES if rid in p[3]]
    d = Doc(f"RS-{rid[4:]}", f"Regulatory Obligation Summary: {short}", "Regulatory Summary", "LGL", 1, "2026.1", "2026-01-10")
    d.body += [P("1. Regulation", "h"), P(f"{full} ({rid}). {summary}"),
               P("2. How Cortex Bank Complies", "h"),
               table([["Policy", "Title", "Owner"]] + [[p[0], Paragraph(p[1], S["p"]), p[2]] for p in pols],
                     [28 * mm, 110 * mm, 36 * mm])]
    return d


def build_rcn(c):
    cid, title, date, rid, summary, pols, actions = c
    d = Doc(cid, title, "Regulatory Change Notice", "LGL", 1, "1.0", date)
    d.body += [P("1. Change", "h"), P(f"{summary} Regulation: {reg(rid)}."),
               P("2. Impacted Policies", "h"), *bullets(f"{POL[p][1]} ({p})" for p in pols),
               P("3. Required Actions", "h"), *bullets(actions)]
    return d


def build_history():
    d = Doc("HIS-001", "Cortex Bank: A Century of Banking (1926-2026)", "Corporate History", "LGL", 1, "1.0", "2026-01-01")
    d.body += [P("Milestones", "h"), table([["Year", "Event"]] + [[str(y), Paragraph(e, S["p"])] for y, e in B.HISTORY], [20 * mm, 154 * mm]),
               P("Legacy Systems Still in Use", "h"), *bullets(f"{sysn(s[0])}: {s[2]}" for s in B.SYSTEMS if s[0] in ("SYS-CORE", "SYS-TRD"))]
    return d


def build_org():
    d = Doc("ORG-001", "Organisation & Department Mandates", "Organisation Chart", "HRS", 1, "2026.1", "2026-01-01")
    d.body += [P("Departments", "h"),
               table([["Code", "Department", "Head", "Mandate"]] + [[x[0], x[1], x[2], Paragraph(x[3], S["p"])] for x in B.DEPARTMENTS],
                     [14 * mm, 44 * mm, 40 * mm, 76 * mm])]
    return d


def all_docs():
    docs = [build_policy(p) for p in B.POLICIES] + [build_sop(s) for s in B.SOPS]
    docs += [build_legacy(l) for l in B.LEGACY_SOPS] + [build_guardrail(g) for g in B.GUARDRAILS]
    docs += [build_kri(k) for k in B.KRI_FRAMEWORKS] + [build_audit(a) for a in B.AUDIT_REPORTS]
    docs += [build_regsum(r) for r in B.REGULATIONS] + [build_rcn(c) for c in B.CHANGE_NOTICES]
    docs += [build_history(), build_org()]
    return docs


def main():
    OUT.mkdir(exist_ok=True)
    docs = all_docs()
    for d in docs:
        d.render()
    (OUT / "manifest.json").write_text(json.dumps([d.meta() for d in docs], indent=1))
    print(f"Rendered {len(docs)} PDFs to {OUT}")


if __name__ == "__main__":
    main()