# ============================================================
# Skill Matrix   /api/training/skills/  +  /api/training/employee-skills/
# ============================================================
from django.db import transaction
from django.db.models import F, Q
from django.utils import timezone
from rest_framework.decorators import action

from Employee.models import Department

from .common import (TrainingCrud, dept_name, emp_brief, emp_by_code, employees_qs, err, level_label, ok, program_row,
                     skill_row, skill_stats, to_bool, to_date, to_int)
from .models import EmployeeSkill, SKILL_LEVELS, TrainingProgram, TrainingSkill


def _level(v, field="level"):
    n = to_int(v)
    if n is None or not 0 <= n <= 4:
        raise ValueError(f"{field} must be an integer between 0 and 4.")
    return n


class SkillViewSet(TrainingCrud):
    """
    CRUD  /api/training/skills/                 the Engineering Skill Competency Matrix rows
    GET   /api/training/skills/matrix/          full table (no paging) + summary   ?department=
    GET   /api/training/skills/<id>/employees/  every in-scope employee with level   ?below_target=true
    POST  /api/training/skills/<id>/assess/     {ratings:[{employee_code, level, remarks?}]}
    body  {domain, category?, description?, target_level(1-4), department?, gap_level_override?}
    """
    model = TrainingSkill
    code = "SKILL"
    status_field = None
    select = ("department",)
    search_fields = ("domain", "category", "description")

    def build(self, s):
        return skill_row(s)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("department"):
            qs = qs.filter(department_id=int(p["department"])) if str(p["department"]).isdigit() else qs.filter(department__name__iexact=p["department"])
        return qs

    def _summary(self, rows):
        gaps = {}
        for r in rows:
            gaps[r["gap_level"]] = gaps.get(r["gap_level"], 0) + 1
        return {"skills": len(rows), "average_bench_strength_percent": round(sum(r["bench_strength_percent"] for r in rows) / len(rows)) if rows else 0,
                "by_gap_level": gaps}

    def list(self, request):
        resp = super().list(request)
        resp.data["summary"] = self._summary(resp.data["data"])
        return resp

    @action(detail=False, methods=["get"])
    def matrix(self, request):
        qs = self.filter(self.scope().filter(is_active=True), request.query_params)
        rows = [skill_row(s) for s in qs]
        return ok("SKILL_MATRIX", "Skill competency matrix.", {"columns": ["Domain", "Proficiency Target", "Current Bench Strength", "Gap Level"],
                  "rows": [{"id": r["id"], "domain": r["domain"], "proficiency_target": r["proficiency_target"],
                            "current_bench_strength": r["current_bench_strength"], "gap_level": r["gap_level"]} for r in rows],
                  "summary": self._summary(rows)})

    def retrieve(self, request, pk=None):
        s = self.scope().filter(pk=pk, is_active=True).first()
        if s is None:
            return err("NOT_FOUND", "Skill not found.", 404)
        row = skill_row(s)
        row["linked_programs"] = [program_row(p, request, brief=True) for p in s.programs.filter(is_active=True)]
        return ok("SKILL_DETAIL", "Skill detail.", row)

    def apply(self, s, d, creating):
        co = self.company()
        dom = (d.get("domain") or s.domain or "").strip()
        if not dom:
            raise ValueError("domain is required.")
        if TrainingSkill.objects.filter(company=co, domain__iexact=dom, is_active=True).exclude(pk=s.pk).exists():
            raise ValueError("A skill with this domain already exists.")
        s.domain = dom
        for k in ("category", "description"):
            if k in d:
                setattr(s, k, d[k])
        if "target_level" in d or creating:
            n = to_int(d.get("target_level"), 3)
            if not 1 <= n <= 4:
                raise ValueError("target_level must be between 1 and 4.")
            s.target_level = n
        if "department" in d:
            ref = d["department"]
            s.department = None if ref in (None, "") else (Department.objects.filter(company=co).filter(Q(pk=int(ref)) if str(ref).isdigit() else Q(name__iexact=str(ref))).first() or (_ for _ in ()).throw(ValueError(f"Department '{ref}' not found.")))
        if "gap_level_override" in d:
            v = d["gap_level_override"] or None
            if v and v not in dict(TrainingSkill.GAP):
                raise ValueError(f"Invalid gap_level_override. Allowed: {', '.join(dict(TrainingSkill.GAP))}")
            s.gap_level_override = v

    @action(detail=True, methods=["get"])
    def employees(self, request, pk=None):
        s = self.scope().filter(pk=pk, is_active=True).first()
        if s is None:
            return err("NOT_FOUND", "Skill not found.", 404)
        emps = employees_qs(s.company).filter(is_active=True).select_related("department")
        if s.department_id:
            emps = emps.filter(department_id=s.department_id)
        lv = {r.employee_id: r for r in EmployeeSkill.objects.filter(skill=s, is_active=True)}
        rows = []
        for e in emps:
            cur = lv[e.id].current_level if e.id in lv else 0
            rows.append({"employee": emp_brief(e, request), "department": dept_name(e), "current_level": cur,
                         "level_label": level_label(cur), "target_level": s.target_level, "gap": max(s.target_level - cur, 0),
                         "meets_target": cur >= s.target_level, "assessed_on": lv[e.id].assessed_on.isoformat() if e.id in lv else None})
        if to_bool(request.query_params.get("below_target")):
            rows = [r for r in rows if not r["meets_target"]]
        return ok("SKILL_EMPLOYEES", "Employees vs target.", {"skill": skill_row(s), "employees": rows})

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def assess(self, request, pk=None):
        s = self.scope().filter(pk=pk, is_active=True).first()
        if s is None:
            return err("NOT_FOUND", "Skill not found.", 404)
        saved, errors = 0, []
        for r in request.data.get("ratings") or []:
            try:
                e = emp_by_code(self.company(), r.get("employee_code"))
                lvl = _level(r.get("level"))
            except ValueError as ex:
                errors.append({"record": r, "reason": str(ex)})
                continue
            es, _ = EmployeeSkill.objects.get_or_create(employee=e, skill=s, defaults={"company": s.company, "created_by": self.actor()})
            es.current_level, es.assessed_on, es.assessed_by, es.source = lvl, timezone.localdate(), self.actor(), "Manual"
            es.remarks, es.is_active, es.updated_by = r.get("remarks"), True, self.actor()
            es.save()
            saved += 1
        return ok("SKILL_ASSESSED", f"{saved} rating(s) saved.", {"saved": saved, "errors": errors, "skill": skill_row(s)})


class EmployeeSkillViewSet(TrainingCrud):
    """
    CRUD  /api/training/employee-skills/   ?employee=<code> ?skill=<id> ?below_target=true ?department=
    POST  {employee_code, skill(id|domain), current_level(0-4), remarks?}   (upsert: re-posting updates the level)
    """
    employee_field = "employee__employee_code"
    model = EmployeeSkill
    code = "EMPLOYEE_SKILL"
    status_field = None
    select = ("employee", "employee__department", "skill")
    search_fields = ("employee__name", "employee__employee_code", "skill__domain")

    def build(self, es):
        return {"id": es.id, "employee": emp_brief(es.employee, self.request), "department": dept_name(es.employee),
                "skill": {"id": es.skill_id, "domain": es.skill.domain, "target_level": es.skill.target_level},
                "current_level": es.current_level, "level_label": level_label(es.current_level),
                "target_label": level_label(es.skill.target_level), "gap": max(es.skill.target_level - es.current_level, 0),
                "meets_target": es.current_level >= es.skill.target_level, "assessed_on": es.assessed_on.isoformat(),
                "assessed_by": es.assessed_by, "source": es.source, "remarks": es.remarks}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("skill"):
            qs = qs.filter(skill_id=int(p["skill"])) if str(p["skill"]).isdigit() else qs.filter(skill__domain__iexact=p["skill"])
        if p.get("department"):
            qs = qs.filter(employee__department_id=int(p["department"])) if str(p["department"]).isdigit() else qs.filter(employee__Department__iexact=p["department"])
        if to_bool(p.get("below_target")):
            qs = qs.filter(current_level__lt=F("skill__target_level"))
        return qs

    def create(self, request):
        d, co = request.data, self.company()
        try:
            e = emp_by_code(co, d.get("employee_code"))
            q = TrainingSkill.objects.filter(company=co, is_active=True)
            ref = d.get("skill")
            sk = q.filter(pk=int(ref)).first() if str(ref).isdigit() else q.filter(domain__iexact=str(ref or "")).first()
            if sk is None:
                raise ValueError(f"Skill '{ref}' not found.")
            lvl = _level(d.get("current_level", d.get("level")), "current_level")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        es, created = EmployeeSkill.objects.get_or_create(employee=e, skill=sk, defaults={"company": co, "created_by": self.actor()})
        es.current_level, es.assessed_on, es.assessed_by, es.is_active = lvl, timezone.localdate(), self.actor(), True
        es.source, es.remarks, es.updated_by = "Manual", d.get("remarks"), self.actor()
        es.save()
        return ok("EMPLOYEE_SKILL_SAVED", "Skill level saved.", self.build(es), 201 if created else 200)

    def apply(self, es, d, creating):
        if "current_level" in d or "level" in d:
            es.current_level = _level(d.get("current_level", d.get("level")), "current_level")
            es.assessed_on, es.assessed_by, es.source = timezone.localdate(), self.actor(), "Manual"
        if "remarks" in d:
            es.remarks = d["remarks"]
