# ============================================================
# Workflow Engine / Scheduled Jobs / Integrations & Connectors
#   /api/admin-center/workflows/   /jobs/   /integrations/
# ============================================================
from datetime import datetime

from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.views import APIView

from Employee.leave_models import ApprovalWorkflowStep
from Employee.models import EmployeeRole

from . import services
from .common import (AuditedCrud, CenterAuthMixin, compute_next_run, emp_by_code, encrypt_secret, err, iso, log_event, ok, schedule_label, secret_hint,
                     to_int)
from .models import IntegrationConnector, ScheduledJob, WorkflowDefinition, WorkflowStep


# ---------------- workflows ----------------
def step_label(s):
    if s.approver_role_id:
        return s.approver_role.role_name
    if s.approver_employee_id:
        return s.approver_employee.name
    return s.approver_type


def workflow_row(w):
    steps = list(w.steps.filter(is_active=True).select_related("approver_role", "approver_employee").order_by("step_order"))
    return {"id": w.id, "workflow_name": w.name, "name": w.name, "module": w.module, "trigger_event": w.trigger_event,
            "levels": len(steps), "levels_label": f"{len(steps)} Tier", "sla_hours": w.sla_hours, "sla_label": f"{w.sla_hours} Hrs",
            "approver_chain": " → ".join(step_label(s) for s in steps), "description": w.description, "status": w.status,
            "steps": [{"order": s.step_order, "approver_type": s.approver_type, "approver": step_label(s),
                       "role_id": s.approver_role_id, "employee_code": s.approver_employee.employee_code if s.approver_employee_id else None,
                       "sla_hours": s.sla_hours} for s in steps],
            "created_at": w.created_at.isoformat()}


class WorkflowViewSet(AuditedCrud):
    """
    CRUD   /api/admin-center/workflows/        ?module= ?status= ?search=
    POST   {name, module, trigger_event, sla_hours?, status?, description?,
            steps:[{approver_type?, role_code?|role_id?, employee_code?, sla_hours?}, ...]}      (steps are replaced on update when sent)
    GET    /api/admin-center/workflows/legacy/   existing Leave / WFH approval chains (read-only, owned by the Leave Hub)
    """
    model, code, module_label = WorkflowDefinition, "WORKFLOW", "Workflow Engine"
    search_fields = ("name", "module", "trigger_event")
    unique_fields = ("name",)
    permission_action_map = {"legacy": "view"}
    sensitive = False

    def build(self, w):
        return workflow_row(w)

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

    def _steps(self, raw):
        if not isinstance(raw, list) or not raw:
            raise ValueError("steps must be a non-empty list.")
        co, out = self.company(), []
        for i, s in enumerate(raw, 1):
            if isinstance(s, str):
                s = {"approver_type": s}
            role = emp = None
            if s.get("role_id") or s.get("role_code"):
                q = EmployeeRole.objects.filter(company=co, is_active=True)
                role = q.filter(pk=to_int(s["role_id"])).first() if s.get("role_id") else q.filter(role_code__iexact=s["role_code"]).first()
                if role is None:
                    raise ValueError(f"Step {i}: role not found.")
            if s.get("employee_code"):
                emp = emp_by_code(co, s["employee_code"])
            at = s.get("approver_type") or ("Role" if role else "Employee" if emp else None)
            if not at:
                raise ValueError(f"Step {i}: approver_type (or role / employee) is required.")
            if at not in WorkflowStep.APPROVERS:
                raise ValueError(f"Step {i}: approver_type must be one of: {', '.join(WorkflowStep.APPROVERS)}.")
            if at == "Role" and role is None or at == "Employee" and emp is None:
                raise ValueError(f"Step {i}: {at.lower()} approver needs a {'role_code' if at == 'Role' else 'employee_code'}.")
            out.append((i, at, role, emp, to_int(s.get("sla_hours"))))
        return out

    def apply(self, w, d, creating):
        name = (d.get("name") or w.name or "").strip()
        mod = next((m for m in WorkflowDefinition.MODULES if m.lower() == (d.get("module") or w.module or "").lower()), None)
        trig = (d.get("trigger_event") or w.trigger_event or "").strip()
        if not name or not trig:
            raise ValueError("name and trigger_event are required.")
        if mod is None:
            raise ValueError(f"module must be one of: {', '.join(WorkflowDefinition.MODULES)}.")
        w.name, w.module, w.trigger_event = name, mod, trig
        self.dup(w, name=name)
        if "sla_hours" in d:
            h = to_int(d["sla_hours"])
            if h is None or h <= 0:
                raise ValueError("sla_hours must be greater than 0.")
            w.sla_hours = h
        if "description" in d:
            w.description = d["description"]
        if "status" in d:
            if d["status"] not in ("Active", "Draft", "Inactive"):
                raise ValueError("status must be Active, Draft or Inactive.")
            w.status = d["status"]
        w._new_steps = self._steps(d["steps"]) if ("steps" in d or creating) else None
        if creating and "steps" not in d:
            raise ValueError("steps must be a non-empty list.")

    def after_save(self, w, creating):
        if getattr(w, "_new_steps", None) is not None:
            w.steps.all().delete()
            for i, at, role, emp, sla in w._new_steps:
                WorkflowStep.objects.create(company=w.company, workflow=w, step_order=i, approver_type=at, approver_role=role, approver_employee=emp,
                                            sla_hours=sla, created_by=w.updated_by, updated_by=w.updated_by)

    @action(detail=False, methods=["get"], url_path="legacy")
    def legacy(self, request):
        rows = {}
        for s in ApprovalWorkflowStep.objects.filter(company=self.company(), is_active=True).order_by("request_type", "step_order"):
            r = rows.setdefault(s.request_type, {"request_type": s.request_type, "source": "leave_hub", "steps": []})
            r["steps"].append({"order": s.step_order, "name": s.name, "approver_type": s.approver_type, "sla_hours": s.sla_hours})
        for r in rows.values():
            r["levels"] = len(r["steps"])
            r["approver_chain"] = " → ".join(s["name"] for s in r["steps"])
        return ok("WORKFLOW_LEGACY", "Existing Leave Hub approval chains (read-only).", list(rows.values()))


# ---------------- scheduled jobs ----------------
def job_row(j):
    return {"id": j.id, "job_name": j.name, "name": j.name, "job_type": j.job_type, "handler": j.handler, "schedule_type": j.schedule_type,
            "schedule": schedule_label(j), "time_of_day": str(j.time_of_day)[:5], "day_of_week": j.day_of_week, "day_of_month": j.day_of_month,
            "last_execution": iso(j.last_run_at), "last_run_status": j.last_run_status, "last_run_message": j.last_run_message,
            "next_scheduled_run": iso(j.next_run_at), "status": j.status, "created_at": j.created_at.isoformat()}


class JobViewSet(AuditedCrud):
    """
    CRUD   /api/admin-center/jobs/             ?status= ?job_type= ?search=
    POST   {name, job_type, schedule_type: Daily|Weekdays|Weekly|Monthly, time_of_day:"02:00", day_of_week?(0=Mon), day_of_month?(1-28), handler?: backup|lockout|log, status?: Active|Paused}
    POST   /api/admin-center/jobs/<id>/run/      [Run Now]     POST /<id>/pause/   POST /<id>/resume/
    POST   /api/admin-center/jobs/run-due/        run every Active job whose next run time has passed (call from cron / `manage.py run_admin_jobs`)
    """
    model, code, module_label = ScheduledJob, "JOB", "Scheduled Jobs"
    search_fields = ("name", "job_type")
    unique_fields = ("name",)
    permission_action_map = {"run": "edit", "pause": "edit", "resume": "edit", "run_due": "edit"}

    def build(self, j):
        return job_row(j)

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

    def apply(self, j, d, creating):
        name = (d.get("name") or j.name or "").strip()
        jt = next((t for t in ScheduledJob.TYPES if t.lower() == (d.get("job_type") or j.job_type or "").lower()), None)
        if not name:
            raise ValueError("name is required.")
        if jt is None:
            raise ValueError(f"job_type must be one of: {', '.join(ScheduledJob.TYPES)}.")
        j.name, j.job_type = name, jt
        self.dup(j, name=name)
        if "handler" in d or creating:
            h = d.get("handler") or ("backup" if jt == "Backup" else "log")
            if h not in services.HANDLERS:
                raise ValueError(f"handler must be one of: {', '.join(services.HANDLERS)}.")
            j.handler = h
        if "schedule_type" in d or creating:
            st = d.get("schedule_type") or "Daily"
            if st not in ScheduledJob.SCHEDULES:
                raise ValueError(f"schedule_type must be one of: {', '.join(ScheduledJob.SCHEDULES)}.")
            j.schedule_type = st
        if "time_of_day" in d:
            try:
                j.time_of_day = datetime.strptime(str(d["time_of_day"])[:5], "%H:%M").time()
            except ValueError:
                raise ValueError("time_of_day must be HH:MM (24h).")
        elif creating:
            j.time_of_day = datetime.strptime("02:00", "%H:%M").time()
        if j.schedule_type == "Weekly":
            w = to_int(d.get("day_of_week", j.day_of_week), 0)
            if not 0 <= w <= 6:
                raise ValueError("day_of_week must be 0 (Mon) - 6 (Sun).")
            j.day_of_week, j.day_of_month = w, None
        elif j.schedule_type == "Monthly":
            m = to_int(d.get("day_of_month", j.day_of_month), 1)
            if not 1 <= m <= 28:
                raise ValueError("day_of_month must be between 1 and 28.")
            j.day_of_month, j.day_of_week = m, None
        else:
            j.day_of_week = j.day_of_month = None
        if "status" in d:
            if d["status"] not in ("Active", "Paused"):
                raise ValueError("status must be Active or Paused.")
            j.status = d["status"]
        j.next_run_at = compute_next_run(j) if j.status == "Active" else None

    def _job(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["post"], url_path="run")
    def run(self, request, pk=None):
        j = self._job(pk)
        if j is None:
            return err("NOT_FOUND", "Record not found.", 404)
        status, msg = services.run_job(j, self.actor())
        log_event(request, self.company(), "RUN", "Scheduled Jobs", j.name, None, f"{status}: {msg}")
        j.refresh_from_db()
        return ok("JOB_RUN", f"Job executed: {status}.", job_row(j), 200 if status == "Completed" else 500)

    def _toggle(self, request, pk, st):
        j = self._job(pk)
        if j is None:
            return err("NOT_FOUND", "Record not found.", 404)
        old, j.status, j.updated_by = j.status, st, self.actor()
        j.next_run_at = compute_next_run(j) if st == "Active" else None
        j.save()
        log_event(request, self.company(), "UPDATED", "Scheduled Jobs", j.name, {"status": old}, {"status": st})
        return ok("JOB_" + st.upper(), f"Job {st.lower()}.", job_row(j))

    @action(detail=True, methods=["post"], url_path="pause")
    def pause(self, request, pk=None):
        return self._toggle(request, pk, "Paused")

    @action(detail=True, methods=["post"], url_path="resume")
    def resume(self, request, pk=None):
        return self._toggle(request, pk, "Active")

    @action(detail=False, methods=["post"], url_path="run-due")
    def run_due(self, request):
        ran = []
        for j in self.scope().filter(is_active=True, status="Active", next_run_at__lte=timezone.now()):
            ran.append({"id": j.id, "name": j.name, "result": services.run_job(j, self.actor())[0]})
        return ok("JOBS_RUN_DUE", f"{len(ran)} job(s) executed.", ran)


# ---------------- integrations ----------------
def integ_row(i):
    return {"id": i.id, "integration_connector": i.name, "name": i.name, "protocol_type": i.connector_type, "connector_type": i.connector_type,
            "endpoint": i.endpoint, "version": i.version, "status": i.status, "has_secret": bool(i.secret_enc), "secret_hint": i.secret_hint,
            "last_ping_at": iso(i.last_ping_at), "last_ping_ms": i.last_ping_ms, "last_ping_message": i.last_ping_message,
            "created_at": i.created_at.isoformat()}


class IntegrationViewSet(AuditedCrud):
    """
    CRUD   /api/admin-center/integrations/       ?status= ?connector_type= ?search=
    POST   {name, connector_type: Email|Biometric|REST API|Accounting|SMS|Other, endpoint?, version?, secret?(write-only), status?: Disabled}
           `secret` is encrypted at rest and NEVER returned (only has_secret + masked hint). Send "clear_secret": true to remove it.
    POST   /api/admin-center/integrations/<id>/ping/      [Test Ping]
    """
    model, code, module_label = IntegrationConnector, "INTEGRATION", "Integrations"
    search_fields = ("name", "connector_type", "endpoint")
    unique_fields = ("name",)
    permission_action_map = {"ping": "edit"}

    def build(self, i):
        return integ_row(i)

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

    def apply(self, i, d, creating):
        name = (d.get("name") or i.name or "").strip()
        ct = next((t for t in IntegrationConnector.TYPES if t.lower() == (d.get("connector_type") or i.connector_type or "").lower()), None)
        if not name:
            raise ValueError("name is required.")
        if ct is None:
            raise ValueError(f"connector_type must be one of: {', '.join(IntegrationConnector.TYPES)}.")
        i.name, i.connector_type = name, ct
        self.dup(i, name=name)
        for k in ("endpoint", "version"):
            if k in d:
                setattr(i, k, d[k])
        if d.get("secret"):
            i.secret_enc, i.secret_hint = encrypt_secret(str(d["secret"])), secret_hint(str(d["secret"]))
        elif d.get("clear_secret"):
            i.secret_enc = i.secret_hint = None
        if "status" in d:
            if d["status"] not in ("Disabled", "Not Tested"):
                raise ValueError("status can only be set to Disabled or Not Tested; Connected / Error come from Test Ping.")
            i.status = d["status"]

    @action(detail=True, methods=["post"], url_path="ping")
    def ping(self, request, pk=None):
        i = self.scope().filter(pk=pk, is_active=True).first()
        if i is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if i.status == "Disabled":
            return err("INVALID_STATE", "Connector is disabled.", 409)
        okk, ms, msg = services.ping_endpoint(i.endpoint)
        i.status, i.last_ping_at, i.last_ping_ms, i.last_ping_message, i.updated_by = ("Connected" if okk else "Error"), timezone.now(), ms, msg, self.actor()
        i.save()
        log_event(request, self.company(), "PING", "Integrations", i.name, None, f"{i.status}: {msg}")
        return ok("INTEGRATION_PING", msg, integ_row(i), 200 if okk else 502)
