# ============================================================
# ADDITIVE: HR MIS & Workforce Analytics - Admin / HR API
# ------------------------------------------------------------
# Mounted at /api/reports/   (see People/reports_urls.py)
# Auth: Company Admin token, or an employee whose role has the
#       "reports" checkboxes (can_view_reports ...) if they exist, else the
#       existing "employees" checkboxes (same fall-back the Training module uses).
#       Payroll figures additionally need payroll VIEW (can_view_payroll /
#       can_manage_payroll): without it payroll fields are masked on HR MIS and
#       the Payroll tab answers 403.
#
# Screen tab            -> endpoint                (all GET, computed from live data)
# -----------------------------------------------------------------
# HR MIS                -> hr-mis/
# Recruitment Reports   -> recruitment/
# Attendance Reports    -> attendance/              ?muster=true&limit=&offset=
# Leave Reports         -> leave/
# Payroll Reports       -> payroll/
# Employee Reports      -> employees/
# Performance Reports   -> performance/             (re-uses the Performance module engine)
# Training Reports      -> training/
# Exit Reports          -> exit/
# common filters: ?financial_year=2026-27 | ?month=2026-09 | ?from=&to= ; narrow with
#                 ?employee_code=A,B | ?department=Name  (not on hr-mis / recruitment / exit)
#
# Stored configuration / history (full CRUD):
#   benchmarks/          targets used by the cards (industry attrition %, office start, payroll budget ...)
#   exit-reason-groups/  Exit Reports rows: reason grouping + Preventable % + Key Retention Recommendation
#   exports/             "Export Employee Master" / "Export Recruitment Data" history, download, regenerate
# ============================================================

import re

from django.core.files.base import ContentFile
from django.db import IntegrityError
from django.http import FileResponse
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.permissions import BasePermission
from rest_framework.views import APIView

from Employee.employee_crud_permissions import _role_is_usable, resolve_actor_role, role_allows

from . import reports_engine as en
from . import reports_exports as ex
from .common import CrudBase, PeopleAuthMixin, err, iso, ok, to_bool, to_decimal, to_int
from .exit_models import ExitInterview
from .reports_models import ExitReasonGroup, ReportBenchmark, ReportExport


# ------------------------------------------------------------
# permissions
# ------------------------------------------------------------

def reports_allows(user, action_name):
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    if actor is None:
        return False
    role = _role_is_usable(user)
    if role is None:
        return False
    a = "edit" if action_name == "approve" else action_name
    return role_allows(role, "reports", a) or role_allows(role, "employees", a)


def payroll_visible(user):
    """Payroll amounts need payroll VIEW (can_manage_payroll counts) - or Company Admin."""
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    role = _role_is_usable(user) if actor else None
    return bool(role is not None and role_allows(role, "payroll", "view"))


class IsReportsUser(BasePermission):
    message = "You do not have permission to use Reports & MIS."
    METHOD_ACTION = {"GET": "view", "HEAD": "view", "OPTIONS": "view", "POST": "create",
                     "PUT": "edit", "PATCH": "edit", "DELETE": "delete"}

    def has_permission(self, request, view):
        act = getattr(view, "permission_action", None)
        if act is None:
            va = getattr(view, "action", None)
            act = {"update_post": "edit", "delete_post": "delete"}.get(va) or \
                  (getattr(view, "permission_action_map", None) or {}).get(va)
        act = act or self.METHOD_ACTION.get(request.method)
        return bool(act) and reports_allows(request.user, act)


class ReportsAuthMixin(PeopleAuthMixin):
    permission_classes = [IsReportsUser]


# ------------------------------------------------------------
# META + the 9 report tabs
# ------------------------------------------------------------

TAB_TITLES = {"hr-mis": "HR MIS", "recruitment": "Recruitment Reports", "attendance": "Attendance Reports",
              "leave": "Leave Reports", "payroll": "Payroll Reports", "employees": "Employee Reports",
              "performance": "Performance Reports", "training": "Training Reports", "exit": "Exit Reports"}


class ReportsMetaView(ReportsAuthMixin, APIView):
    """GET /api/reports/meta/"""

    def get(self, request):
        return ok("REPORTS_META", "Reports metadata.", {
            "title": "HR MIS & Workforce Analytics",
            "subtitle": "Real-time headcount trends, recruitment throughput, and statutory reporting exports",
            "tabs": [{"key": k, "title": TAB_TITLES[k], "endpoint": f"/api/reports/{k}/",
                      "restricted": k == "payroll"} for k in en.TABS],
            "export_types": [{"key": k, "title": t} for k, t in ReportExport.TYPES],
            "export_formats": [k for k, _ in ReportExport.FORMATS],
            "benchmark_keys": [{"key": k, **{kk: (float(vv) if kk == "value" else vv) for kk, vv in v.items()}}
                               for k, v in en.DEFAULT_BENCHMARKS.items()] + [
                {"key": "annual_payroll_budget", "label": "Annual payroll budget (set per financial_year)", "unit": "INR", "value": None}],
            "exit_interview_reasons": [r for r, _ in ExitInterview.REASONS],
            "can_view_payroll": payroll_visible(request.user),
        })


def scope_codes(company, p):
    """Optional narrowing of the people a report covers."""
    codes = [c.strip() for c in str(p.get("employee_code") or "").split(",") if c.strip()]
    if codes:
        return codes
    if p.get("department"):
        rows = en.emp_rows(en.emps(company, None, active=False))
        return [r["employee_code"] for r in rows if r["dept"].lower() == p["department"].strip().lower()]
    return None


class ReportView(ReportsAuthMixin, APIView):
    """GET /api/reports/<tab>/ - one view class, the tab is set in reports_urls.py"""

    tab = None

    def get(self, request):
        company, p = self.company(), request.query_params
        tab = self.tab
        try:
            if tab == "performance":
                data = en.performance(company, p, scope_codes(company, p))
            else:
                start, end, fy = en.period_from(p)
                codes = scope_codes(company, p) if tab in ("attendance", "leave", "payroll", "employees", "training") else None
                if tab == "hr-mis":
                    data = en.hr_mis(company, start, end, fy, can_payroll=payroll_visible(request.user))
                elif tab == "recruitment":
                    data = en.recruitment(company, start, end, fy)
                elif tab == "attendance":
                    data = en.attendance(company, start, end, fy, codes, muster=to_bool(p.get("muster")),
                                         limit=max(1, min(to_int(p.get("limit"), 100), 500)),
                                         offset=max(0, to_int(p.get("offset"), 0)))
                elif tab == "leave":
                    data = en.leave(company, start, end, fy, codes)
                elif tab == "payroll":
                    if not payroll_visible(request.user):
                        return err("FORBIDDEN", "Payroll reports need payroll view permission.", 403)
                    data = en.payroll(company, start, end, fy, codes)
                elif tab == "employees":
                    data = en.employees_report(company, start, end, fy, codes)
                elif tab == "training":
                    data = en.training(company, start, end, fy, codes)
                else:
                    data = en.exit_report(company, start, end, fy)
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("REPORT_" + tab.upper().replace("-", "_"), f"{TAB_TITLES[tab]} fetched.", data)


# ------------------------------------------------------------
# helpers for the 3 CRUD resources
# ------------------------------------------------------------

class NoDup(CrudBase):
    """CrudBase + 409 on duplicates (subclasses implement dup())."""
    soft_delete = False

    def dup(self, d, exclude_pk=None, current=None):
        return None

    def filter(self, qs, p):
        return super().filter(qs, {k: v for k, v in p.items() if k != "employee"})

    def create(self, request):
        m = self.dup(request.data)
        if m:
            return err("EXISTS", m, 409)
        try:
            return super().create(request)
        except IntegrityError:
            return err("EXISTS", "A record with the same details already exists.", 409)

    def partial_update(self, request, pk=None):
        obj = self.scope().filter(pk=pk, is_active=True).first()
        if obj is not None:
            m = self.dup(request.data, exclude_pk=obj.pk, current=obj)
            if m:
                return err("EXISTS", m, 409)
        try:
            return super().partial_update(request, pk)
        except IntegrityError:
            return err("EXISTS", "A record with the same details already exists.", 409)

    update = partial_update


# ------------------------------------------------------------
# BENCHMARKS
# ------------------------------------------------------------

KEY_RE = re.compile(r"^[a-z][a-z0-9_]{1,59}$")


class BenchmarkViewSet(NoDup):
    """
    GET    /api/reports/benchmarks/               ?search= ?key= ?financial_year=
    POST   /api/reports/benchmarks/               {key, value, label?, unit?, financial_year?, notes?}
    GET    /api/reports/benchmarks/<id>/
    PATCH|PUT|POST(update/) /<id>/
    DELETE|POST(delete/)    /<id>/
    GET    /api/reports/benchmarks/effective/      every known key with the value the reports really use (saved | default)
    """

    model = ReportBenchmark
    code = "REPORT_BENCHMARK"
    status_field = None
    search_fields = ("key", "label", "notes")
    permission_action_map = {"effective": "view"}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("key"):
            qs = qs.filter(key=p["key"])
        if p.get("financial_year") not in (None, ""):
            qs = qs.filter(financial_year=p["financial_year"])
        return qs

    def build(self, b):
        return {"id": b.id, "key": b.key, "label": b.label, "value": float(b.value), "unit": b.unit,
                "financial_year": b.financial_year or None, "notes": b.notes,
                "created_at": iso(b.created_at), "updated_at": iso(b.updated_at)}

    def dup(self, d, exclude_pk=None, current=None):
        key = d.get("key", current.key if current else None)
        fy = d.get("financial_year", current.financial_year if current else "") or ""
        if not key:
            return None
        qs = ReportBenchmark.objects.filter(company=self.company(), key=key, financial_year=fy)
        if exclude_pk:
            qs = qs.exclude(pk=exclude_pk)
        return f"Benchmark '{key}' already exists" + (f" for {fy}." if fy else ".") if qs.exists() else None

    def apply(self, b, d, creating):
        if creating or "key" in d:
            key = str(d.get("key") or "").strip().lower()
            if not KEY_RE.match(key):
                raise ValueError("key must be lowercase letters, digits and underscores (e.g. industry_attrition_percent).")
            if not creating and key != b.key:
                raise ValueError("key cannot be changed. Delete and create a new benchmark instead.")
            b.key = key
        if creating or "value" in d:
            v = to_decimal(d.get("value"))
            if v is None:
                raise ValueError("value is required and must be a number.")
            b.value = v
        for f in ("label", "unit", "notes"):
            if f in d:
                setattr(b, f, d[f])
        if "financial_year" in d or creating:
            fy = d.get("financial_year") or ""
            if fy and not en.valid_fy(fy):
                raise ValueError("financial_year must look like 2026-27 (or empty for all years).")
            if not creating and fy != b.financial_year:
                raise ValueError("financial_year cannot be changed. Delete and create a new benchmark instead.")
            b.financial_year = fy

    @action(detail=False, methods=["get"])
    def effective(self, request):
        fy = request.query_params.get("financial_year") or en.financial_year()
        saved = {}
        for b in ReportBenchmark.objects.filter(company=self.company(), is_active=True):
            saved.setdefault(b.key, []).append(b)
        out = []
        for key, dflt in {**en.DEFAULT_BENCHMARKS, "annual_payroll_budget": {"label": "Annual payroll budget", "value": None, "unit": "INR"}}.items():
            v = en.get_benchmark(self.company(), key, fy)
            out.append({"key": key, "label": dflt["label"], "unit": dflt["unit"],
                        "effective_value": float(v) if v is not None else None,
                        "source": "saved" if key in saved and v is not None else ("default" if v is not None else "not set"),
                        "default_value": float(dflt["value"]) if dflt["value"] is not None else None})
        return ok("REPORT_BENCHMARK_EFFECTIVE", "Effective benchmarks.", {"financial_year": fy, "benchmarks": out})


# ------------------------------------------------------------
# EXIT REASON GROUPS
# ------------------------------------------------------------

class ExitReasonGroupViewSet(NoDup):
    """
    GET    /api/reports/exit-reason-groups/        ?search=
    POST   /api/reports/exit-reason-groups/        {name, reasons: [...], preventable_percent, recommendation, sort_order?}
    GET    /api/reports/exit-reason-groups/<id>/
    PATCH|PUT|POST(update/) /<id>/    DELETE|POST(delete/) /<id>/
    POST   /api/reports/exit-reason-groups/seed-defaults/   persist the 3 built-in groups (only when none exist)
    GET    /api/reports/exit-reason-groups/coverage/        which exit-interview reasons are not mapped yet
    A reason can belong to ONE group only (no double counting).
    """

    model = ExitReasonGroup
    code = "EXIT_REASON_GROUP"
    status_field = None
    search_fields = ("name", "recommendation")
    permission_action_map = {"coverage": "view", "seed_defaults": "create"}

    def build(self, g):
        return {"id": g.id, "name": g.name, "reasons": g.reasons, "preventable_percent": float(g.preventable_percent),
                "recommendation": g.recommendation, "sort_order": g.sort_order,
                "created_at": iso(g.created_at), "updated_at": iso(g.updated_at)}

    def dup(self, d, exclude_pk=None, current=None):
        company = self.company()
        name = d.get("name", current.name if current else None)
        others = ExitReasonGroup.objects.filter(company=company, is_active=True)
        if exclude_pk:
            others = others.exclude(pk=exclude_pk)
        if name and others.filter(name__iexact=str(name).strip()).exists():
            return f"A group named '{str(name).strip()}' already exists."
        reasons = d.get("reasons")
        if isinstance(reasons, list):
            for g in others:
                clash = sorted(set(map(str, reasons)) & set(g.reasons or []))
                if clash:
                    return f"Reason(s) {', '.join(clash)} already belong to the group '{g.name}'."
        return None

    def apply(self, g, d, creating):
        if creating or "name" in d:
            name = str(d.get("name") or "").strip()
            if not name:
                raise ValueError("name is required.")
            g.name = name
        if creating or "reasons" in d:
            r = d.get("reasons")
            if not isinstance(r, list) or not r:
                raise ValueError("reasons must be a non-empty list.")
            r = [str(i).strip() for i in r]
            if len(set(r)) != len(r) or not all(r):
                raise ValueError("reasons must be unique, non-empty values.")
            allowed = dict(ExitInterview.REASONS)
            bad = [i for i in r if i not in allowed]
            if bad:
                raise ValueError(f"Unknown reason(s): {', '.join(bad)}. Allowed: {', '.join(allowed)}")
            g.reasons = r
        if creating or "preventable_percent" in d:
            v = to_decimal(d.get("preventable_percent"), 0)
            if not (0 <= v <= 100):
                raise ValueError("preventable_percent must be between 0 and 100.")
            g.preventable_percent = v
        if "recommendation" in d:
            g.recommendation = d["recommendation"]
        if "sort_order" in d:
            g.sort_order = to_int(d["sort_order"], 0)

    @action(detail=False, methods=["post"], url_path="seed-defaults")
    def seed_defaults(self, request):
        if ExitReasonGroup.objects.filter(company=self.company(), is_active=True).exists():
            return err("EXISTS", "Exit reason groups already exist for this company.", 409)
        actor = self.actor()
        rows = [ExitReasonGroup.objects.create(
            company=self.company(), name=g["name"], reasons=g["reasons"], preventable_percent=g["preventable_percent"],
            recommendation=g["recommendation"], sort_order=i, created_by=actor, updated_by=actor)
            for i, g in enumerate(en.DEFAULT_EXIT_GROUPS, 1)]
        return ok("EXIT_REASON_GROUPS_SEEDED", "Default groups saved.", [self.build(g) for g in rows], 201)

    @action(detail=False, methods=["get"])
    def coverage(self, request):
        groups, configured = en.exit_groups(self.company())
        mapped = {r for g in groups for r in g["reasons"]}
        return ok("EXIT_REASON_COVERAGE", "Coverage.", {
            "configured": configured, "mapped": sorted(mapped),
            "unmapped": [r for r, _ in ExitInterview.REASONS if r not in mapped]})


# ------------------------------------------------------------
# EXPORTS
# ------------------------------------------------------------

class ExportViewSet(NoDup):
    """
    GET    /api/reports/exports/                 ?report_type= ?file_format= ?status= ?search=
    POST   /api/reports/exports/                 {report_type: employee_master|recruitment_data, file_format: csv|xlsx,
                                                  title?, notes?, filters?{...}}   -> generates the file now
        employee_master filters : status (active|exited|all), department, employee_type, joined_from, joined_to
        recruitment_data filters: stage, source, requisition_id, from, to
    GET    /api/reports/exports/<id>/
    PATCH|PUT|POST(update/) /<id>/                only title / notes
    DELETE|POST(delete/)    /<id>/                removes the record and the file
    GET    /api/reports/exports/<id>/download/    the file
    POST   /api/reports/exports/<id>/regenerate/  same filters, fresh data
    """

    model = ReportExport
    code = "REPORT_EXPORT"
    status_field = "status"
    search_fields = ("title", "file_name", "notes")
    permission_action_map = {"download": "view", "regenerate": "create"}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        for f in ("report_type", "file_format"):
            if p.get(f):
                qs = qs.filter(**{f: p[f]})
        return qs

    def build(self, x):
        url = f"/api/reports/exports/{x.id}/download/"
        return {"id": x.id, "report_type": x.report_type, "report_type_label": dict(ReportExport.TYPES)[x.report_type],
                "file_format": x.file_format, "title": x.title, "filters": x.filters, "row_count": x.row_count,
                "status": x.status, "error": x.error, "file_name": x.file_name, "file_size": x.file_size,
                "download_url": url if x.file else None, "download_count": x.download_count,
                "last_downloaded_at": iso(x.last_downloaded_at), "notes": x.notes, "requested_by": x.created_by,
                "created_at": iso(x.created_at), "updated_at": iso(x.updated_at)}

    def _generate(self, x):
        name, data, _ctype, rows = ex.render(x.report_type, x.file_format, x.company, x.filters)
        if x.file:
            x.file.delete(save=False)
        x.file.save(name, ContentFile(data), save=False)
        x.file_name, x.file_size, x.row_count, x.status, x.error = name, len(data), rows, "Completed", None

    def apply(self, x, d, creating):
        if not creating:
            blocked = [k for k in ("report_type", "file_format", "filters") if k in d]
            if blocked:
                raise ValueError("Only title and notes can be edited. Create a new export (or use regenerate).")
        else:
            x.report_type = d.get("report_type")
            x.file_format = d.get("file_format") or "csv"
            x.filters = d.get("filters") or {}
            if not isinstance(x.filters, dict):
                raise ValueError("filters must be an object.")
            x.title = d.get("title") or f"{dict(ReportExport.TYPES).get(x.report_type, 'Export')} - {timezone.localdate()}"
            self._generate(x)
        for f in ("title", "notes"):
            if f in d and not creating:
                setattr(x, f, d[f])
        if creating and "notes" in d:
            x.notes = d["notes"]

    def destroy(self, request, pk=None):
        x = self.scope().filter(pk=pk, is_active=True).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if x.file:
            x.file.delete(save=False)
        x.delete()
        return ok("REPORT_EXPORT_DELETED", "Deleted.", {"id": int(pk)})

    @action(detail=True, methods=["get"])
    def download(self, request, pk=None):
        x = self.scope().filter(pk=pk, is_active=True).first()
        if x is None or not x.file:
            return err("NOT_FOUND", "File not found.", 404)
        try:
            fh = x.file.open("rb")
        except (FileNotFoundError, ValueError):
            return err("NOT_FOUND", "The export file is no longer on the server. Use regenerate.", 404)
        x.download_count += 1
        x.last_downloaded_at = timezone.now()
        x.save(update_fields=["download_count", "last_downloaded_at"])
        ctype = "text/csv" if x.file_format == "csv" else "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
        return FileResponse(fh, as_attachment=True, filename=x.file_name, content_type=ctype)

    @action(detail=True, methods=["post"])
    def regenerate(self, request, pk=None):
        x = self.scope().filter(pk=pk, is_active=True).first()
        if x is None:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            self._generate(x)
        except ValueError as e:
            return err("VALIDATION", str(e))
        x.updated_by = self.actor()
        x.save()
        return ok("REPORT_EXPORT_REGENERATED", "Export regenerated.", self.build(x))
