# ============================================================
# ADDITIVE: Organization Hierarchy API  (landing page, org chart, employee card, department view, edit manager)
# Mounted at /api/people/org/...   (People/org_chart_urls.py)
# Auth: Company Admin or HR employee (Employees module role).  GET = view, POST manager = edit, settings POST = manage.
# EVERYTHING is company scoped (B2B) - another company's ids / codes are simply "not found".
#
#   GET  hierarchy/                                  landing: stats cards, chart card, departments list (?q= search)
#   GET  chart/                                      org chart tree (?q ?department ?root ?depth ?expand ?group)
#   GET  chart/export/?fmt=csv|xlsx                  export the chart (same filters)
#   GET  chart/health/                               data-quality: loops, inactive managers, multiple roots, duplicates
#   GET  chart/settings/   POST chart/settings/      dynamic org-chart settings
#   GET  employees/<code>/card/                      employee card (reporting manager, direct reports, actions)
#   GET  employees/<code>/team/                      "View Team" (?all=true for everyone below)
#   GET  employees/<code>/reporting-manager/options/ who can be chosen as the manager (no self, no own team)
#   POST employees/<code>/reporting-manager/         "Edit Reporting Manager"  {manager: code|null, reason?}
#   GET  departments/<id>/team-view/                 Department View (leaders with team size)
# ============================================================
import csv
import io
import re

from django.db import transaction
from django.db.models import Q
from django.http import HttpResponse
from django.utils import timezone
from rest_framework import status as http
from rest_framework.views import APIView

from Employee.models import Department

from . import org_chart_engine as oc
from .common import (PeopleAuthMixin, emp_brief, employees_qs, ensure_extra, err, iso, log_history, ok,
                     paginate, people_allows, to_bool)
from .models import EmployeeExtra, OrgChartSettings
from .org_models import DepartmentOwnership
from .views_org import member_row, members_of, owner_of


def get_emp(company, code):
    return employees_qs(company).filter(employee_code=str(code).strip()).select_related("department").first()


def find_department(company, ref):
    qs = Department.objects.filter(company=company, is_active=True)
    ref = str(ref).strip()
    return qs.filter(pk=int(ref)).first() if ref.isdigit() else qs.filter(name__iexact=ref).first()


def actions_for(code, user):
    return {
        "view_profile": {"label": "View Profile", "api": f"/api/people/profile360/{code}/",
                         "path": f"/employees/{code}/360"},
        "view_team": {"label": "View Team", "api": f"/api/people/org/employees/{code}/team/"},
        "edit_reporting_manager": {"label": "Edit Reporting Manager", "method": "POST",
                                   "api": f"/api/people/org/employees/{code}/reporting-manager/",
                                   "options_api": f"/api/people/org/employees/{code}/reporting-manager/options/",
                                   "allowed": people_allows(user, "edit")},
        "add_employee": {"label": "Add Employee", "method": "POST", "api": "/company/employees/add/",
                         "allowed": people_allows(user, "create")},
    }


def person(graph, n, request=None, **extra):
    e = graph.emps[n]
    return {**emp_brief(e, request), "department": oc.dept_label(e),
            "direct_reports": len(graph.kids(n)), "team_size": graph.size.get(n, 0),
            "role_type": graph.role_type(n), **extra}


def card_payload(graph, e, request, user):
    n = e.id
    active = n in graph.emps
    mgr = graph.emps.get(graph.manager.get(n)) if active else None
    x = getattr(e, "people_profile", None)
    return {
        **emp_brief(e, request), "department": oc.dept_label(e), "department_id": e.department_id,
        "status": "Active" if e.is_active else "Inactive",
        "lifecycle_status": x.lifecycle_status if x else None, "joining_date": iso(e.Date_of_Joining),
        "reporting_manager": ({"employee_code": mgr.employee_code, "name": mgr.name, "designation": mgr.Designation}
                              if mgr else None),
        "direct_reports": len(graph.kids(n)) if active else 0, "team_size": graph.size.get(n, 0) if active else 0,
        "role_type": graph.role_type(n) if active else "member",
        "management_chain": [{"employee_code": a.employee_code, "name": a.name, "designation": a.Designation}
                             for a in graph.chain(n)] if active else [],
        "actions": actions_for(e.employee_code, user),
    }


class OrgBase(PeopleAuthMixin):
    permission_action = "view"

    def graph(self):
        return oc.OrgGraph(self.company())


# ================================================================ landing page
class OrgHierarchyView(OrgBase, APIView):
    def get(self, request):
        company, user = self.company(), request.user
        g = self.graph()
        stats = g.stats()
        q = (request.query_params.get("q") or "").strip()
        deps = Department.objects.filter(company=company, is_active=True).order_by("name")
        if q:
            deps = deps.filter(Q(name__icontains=q) | Q(code__icontains=q))
        styles = g.settings.department_styles or {}
        rows = []
        for i, d in enumerate(deps):
            members = members_of(company, d)
            o = owner_of(d)
            st = styles.get(str(d.id), {})
            rows.append({"id": d.id, "name": d.name, "code": d.code, "employees": members.count(),
                         "icon": st.get("icon"), "color": st.get("color") or oc.PALETTE[d.id % len(oc.PALETTE)],
                         "head": member_row(o.head) if o and o.head_id else None,
                         "team_view_api": f"/api/people/org/departments/{d.id}/team-view/"})
        found = []
        if q:
            qs = employees_qs(company).filter(is_active=True).filter(
                Q(name__icontains=q) | Q(employee_code__icontains=q) | Q(email__icontains=q)
                | Q(Designation__icontains=q)).select_related("department").order_by("name")[:10]
            found = [{**emp_brief(e, request), "card_api": f"/api/people/org/employees/{e.employee_code}/card/"}
                     for e in qs]
        data = {
            "company": getattr(company, "Registered_Company_Name", None) or str(company),
            "stats": {**stats, "departments": Department.objects.filter(company=company, is_active=True).count()},
            "chart_card": {"title": "Organization Chart", "button": "Open Organization Chart",
                           "chart_api": "/api/people/org/chart/", "export_api": "/api/people/org/chart/export/"},
            "departments": rows, "search": {"q": q, "employees": found} if q else None,
            "key_actions": [
                {"key": "open_chart", "label": "Open Organization Chart", "api": "/api/people/org/chart/", "allowed": True},
                {"key": "export", "label": "Export", "api": "/api/people/org/chart/export/", "allowed": True},
                {"key": "add_employee", "label": "Add Employee", "api": "/company/employees/add/",
                 "allowed": people_allows(user, "create")},
                {"key": "edit_reporting_manager", "label": "Edit Reporting Manager", "allowed": people_allows(user, "edit")},
                {"key": "settings", "label": "Org chart settings", "api": "/api/people/org/chart/settings/",
                 "allowed": people_allows(user, "manage")}],
        }
        return ok("ORG_HIERARCHY", "Organization hierarchy overview.", data)


# ================================================================ chart tree
class OrgChartView(OrgBase, APIView):
    def get(self, request):
        company, p = self.company(), request.query_params
        g = self.graph()
        dept = None
        if (p.get("department") or "").strip():
            dept = find_department(company, p["department"])
            if dept is None:
                return err("VALIDATION", "Department not found in your company.", http.HTTP_404_NOT_FOUND)
        depth = None
        if p.get("depth") not in (None, ""):
            if not str(p["depth"]).isdigit():
                return err("VALIDATION", "depth must be a whole number (levels below the root).")
            depth = int(p["depth"])
        expand = (p.get("expand") or "2").strip().lower()
        if not (expand in ("all", "none") or expand.isdigit()):
            return err("VALIDATION", "expand must be all, none or a number of levels.")
        tb = oc.TreeBuilder(g, request, q=p.get("q"), dept=dept, expand=expand, depth=depth,
                            group=to_bool(p.get("group"), True))
        primary = g.primary_root()
        breadcrumb, other = [], []
        if (p.get("root") or "").strip():
            e = g.by_code.get(p["root"].strip())
            if e is None:
                return err("NOT_FOUND", "Root employee not found (or not active) in your company.", http.HTTP_404_NOT_FOUND)
            root = tb.tree(e.id, False)
            if root:
                root["is_subtree_root"] = True
            breadcrumb = [{"employee_code": a.employee_code, "name": a.name, "designation": a.Designation}
                          for a in g.chain(e.id)]
        else:
            root = tb.tree(primary, True) if primary else None
            if to_bool(p.get("include_other_roots"), True):
                for r in g.roots:
                    if r != primary:
                        t = tb.tree(r, False)
                        if t:
                            t["orphan_root"] = True
                            other.append(t)
        total = g.stats()["total_employees"]
        meta = {"total_employees": total, "nodes_returned": tb.nodes, "max_level": tb.max_level,
                "primary_root": g.emps[primary].employee_code if primary else None,
                "filters": {"q": (p.get("q") or "").strip() or None, "department": dept.name if dept else None,
                            "root": (p.get("root") or "").strip() or None, "depth": depth, "expand": expand},
                "matches": len(tb.matches) if tb.included is not None else None,
                "has_issues": bool(g.cycle_roots or g.broken_manager or len(g.roots) - len(g.cycle_roots) > 1)}
        msg = "Organization chart." if (root or other) else "No employee matches the filters."
        return ok("ORG_CHART", msg, {"root": root, "other_roots": other, "breadcrumb": breadcrumb}, meta=meta)


# ================================================================ export
def _safe_cell(v):
    s = "" if v is None else str(v)
    return "'" + s if s[:1] in ("=", "+", "-", "@", "\t", "\r") else s       # spreadsheet formula-injection guard


EXPORT_COLUMNS = [("Level", "level"), ("Employee Code", "employee_code"), ("Name", "name"),
                  ("Designation", "designation"), ("Department", "department"),
                  ("Reporting Manager Code", "reporting_manager_code"), ("Reporting Manager", "reporting_manager"),
                  ("Direct Reports", "direct_reports"), ("Team Size", "team_size"), ("Role Type", "role_type"),
                  ("Email", "email"), ("Joining Date", "joining_date"), ("Status", "status")]


class OrgChartExportView(OrgBase, APIView):
    def get(self, request):
        company, p = self.company(), request.query_params
        fmt = (p.get("fmt") or "csv").strip().lower()        # NOT "format": DRF reserves ?format= for renderers
        if fmt not in ("csv", "xlsx"):
            return err("VALIDATION", "fmt must be csv or xlsx.")
        g = self.graph()
        dept = None
        if (p.get("department") or "").strip():
            dept = find_department(company, p["department"])
            if dept is None:
                return err("VALIDATION", "Department not found in your company.", http.HTTP_404_NOT_FOUND)
        include = None
        if dept is not None or (p.get("q") or "").strip():
            include = oc.TreeBuilder(g, request, q=p.get("q"), dept=dept).included
        rows = oc.flat_rows(g, include)
        slug = re.sub(r"[^a-z0-9]+", "-", (getattr(company, "Registered_Company_Name", "") or "company").lower()).strip("-")
        name = f"org-chart-{slug}-{timezone.localdate().isoformat()}.{fmt}"
        if fmt == "csv":
            buf = io.StringIO()
            w = csv.writer(buf)
            w.writerow([c for c, _ in EXPORT_COLUMNS])
            for r in rows:
                w.writerow([_safe_cell(r[k]) for _, k in EXPORT_COLUMNS])
            resp = HttpResponse("\ufeff" + buf.getvalue(), content_type="text/csv; charset=utf-8")
        else:
            from openpyxl import Workbook
            wb = Workbook()
            ws = wb.active
            ws.title = "Org Chart"
            ws.append([c for c, _ in EXPORT_COLUMNS])
            for r in rows:
                ws.append([_safe_cell(r[k]) if isinstance(r[k], str) else r[k] for _, k in EXPORT_COLUMNS])
            out = io.BytesIO()
            wb.save(out)
            resp = HttpResponse(out.getvalue(), content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
        resp["Content-Disposition"] = f'attachment; filename="{name}"'
        resp["X-Row-Count"] = str(len(rows))
        return resp


# ================================================================ health
class OrgChartHealthView(OrgBase, APIView):
    def get(self, request):
        g = self.graph()
        issues = g.issues()
        return ok("ORG_HEALTH", "Organization data check.",
                  {"healthy": not any(i["severity"] == "error" for i in issues), "issues": issues,
                   "stats": g.stats()})


# ================================================================ employee card / team / manager
class EmployeeCardView(OrgBase, APIView):
    def get(self, request, code):
        e = get_emp(self.company(), code)
        if e is None:
            return err("NOT_FOUND", "Employee not found.", http.HTTP_404_NOT_FOUND)
        return ok("ORG_EMPLOYEE_CARD", "Employee card.", card_payload(self.graph(), e, request, request.user))


class EmployeeTeamView(OrgBase, APIView):
    def get(self, request, code):
        company, p = self.company(), request.query_params
        e = get_emp(company, code)
        if e is None:
            return err("NOT_FOUND", "Employee not found.", http.HTTP_404_NOT_FOUND)
        g = self.graph()
        everyone = to_bool(p.get("all"))
        ids = []
        if e.id in g.emps:
            ids = sorted(g.descendants(e.id)) if everyone else g.kids(e.id)
        q = (p.get("q") or "").strip().lower()
        if q:
            ids = [i for i in ids if q in (g.emps[i].name or "").lower() or q in (g.emps[i].employee_code or "").lower()
                   or q in (g.emps[i].Designation or "").lower()]
        ids = sorted(ids, key=lambda i: (-g.size.get(i, 0), g.emps[i].name or ""))
        rows, pg = paginate(request, ids, lambda i: {
            **person(g, i, request, card_api=f"/api/people/org/employees/{g.emps[i].employee_code}/card/",
                     reporting_manager=g.emps[g.manager[i]].name if i in g.manager else None,
                     view_team_api=f"/api/people/org/employees/{g.emps[i].employee_code}/team/")})
        head = {**emp_brief(e, request), "direct_reports": len(g.kids(e.id)), "team_size": g.size.get(e.id, 0)}
        return ok("ORG_TEAM", "Team members.", rows, meta=pg, manager=head, scope="all" if everyone else "direct")


class ManagerOptionsView(OrgBase, APIView):
    def get(self, request, code):
        company, p = self.company(), request.query_params
        e = get_emp(company, code)
        if e is None:
            return err("NOT_FOUND", "Employee not found.", http.HTTP_404_NOT_FOUND)
        g = self.graph()
        blocked = {e.id} | (g.descendants(e.id) if e.id in g.emps else set())
        q = (p.get("q") or "").strip().lower()
        cur = g.manager.get(e.id)
        rows = []
        for n, m in g.emps.items():
            if n in blocked:
                continue
            if q and q not in (m.name or "").lower() and q not in (m.employee_code or "").lower() \
                    and q not in (m.Designation or "").lower():
                continue
            rows.append({**emp_brief(m, request), "direct_reports": len(g.kids(n)), "is_current": n == cur})
        rows.sort(key=lambda r: (not r["is_current"], r["name"] or ""))
        return ok("ORG_MANAGER_OPTIONS", "Employees that can be chosen as reporting manager.", rows[:50],
                  total=len(rows), excluded="the employee themselves and everyone in their own team (prevents loops)")


class ReportingManagerView(OrgBase, APIView):
    permission_action = "edit"

    @transaction.atomic
    def post(self, request, code):
        company, d = self.company(), request.data
        e = get_emp(company, code)
        if e is None:
            return err("NOT_FOUND", "Employee not found.", http.HTTP_404_NOT_FOUND)
        if not e.is_active:
            return err("VALIDATION", "Inactive employees cannot be moved in the hierarchy.")
        key = "manager" if "manager" in d else "reporting_manager" if "reporting_manager" in d else None
        if key is None:
            return err("VALIDATION", "manager is required: an employee_code, or null to remove the reporting manager.")
        raw = d.get(key)
        if raw is not None and not str(raw).strip():
            return err("VALIDATION", "manager cannot be blank. Send an employee_code, or null to remove it.")
        reason = str(d.get("reason") or "").strip()
        if len(reason) > 250:
            return err("VALIDATION", "reason can be at most 250 characters.")
        g = oc.OrgGraph(company)
        if e.id not in g.emps:
            return err("VALIDATION", "Employee is not part of the active hierarchy.")
        mgr = None
        if raw is not None:
            mgr = g.by_code.get(str(raw).strip())
            if mgr is None:                      # other company's / inactive / unknown codes all look the same
                return err("VALIDATION", f"'{str(raw).strip()}' is not an active employee of your company.")
        x = ensure_extra(e)
        # DUPLICATE guard: the same reporting line is never written (or logged) twice
        if mgr is not None and x.reporting_manager_id == mgr.id:
            return err("DUPLICATE", f"{e.name} already reports to {mgr.name}. Nothing changed.", http.HTTP_409_CONFLICT)
        if mgr is None and x.reporting_manager_id is None:
            return err("DUPLICATE", f"{e.name} already has no reporting manager. Nothing changed.", http.HTTP_409_CONFLICT)
        try:
            oc.check_reporting_line(g, e, mgr)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        before = x.reporting_manager
        actor = self.actor()
        x.reporting_manager, x.updated_by = mgr, actor
        x.save()
        log_history(company, e, "MANAGER_CHANGE",
                    f"Reporting manager changed to {mgr.name if mgr else 'none'}", reason or None, actor=actor,
                    meta={"kind": "org_chart", "from": before.employee_code if before else None,
                          "to": mgr.employee_code if mgr else None})
        g2 = oc.OrgGraph(company)
        e = get_emp(company, code)
        return ok("ORG_MANAGER_UPDATED", "Reporting manager updated.", {
            "changed": {"from": ({"employee_code": before.employee_code, "name": before.name} if before else None),
                        "to": ({"employee_code": mgr.employee_code, "name": mgr.name} if mgr else None)},
            "card": card_payload(g2, e, request, request.user)})


# ================================================================ department view
class DepartmentTeamView(OrgBase, APIView):
    def get(self, request, pk):
        company, p = self.company(), request.query_params
        dep = Department.objects.filter(company=company, is_active=True, pk=pk).first()
        if dep is None:
            return err("NOT_FOUND", "Department not found.", http.HTTP_404_NOT_FOUND)
        g = self.graph()
        mem = [n for n, e in g.emps.items() if oc._in_department(e, dep)]
        total = len(mem)
        show_all = to_bool(p.get("all"))
        if not show_all:
            mem = [n for n in mem if g.kids(n)]
        q = (p.get("q") or "").strip().lower()
        if q:
            mem = [n for n in mem if q in (g.emps[n].name or "").lower() or q in (g.emps[n].Designation or "").lower()
                   or q in (g.emps[n].employee_code or "").lower()]
        mem.sort(key=lambda n: (-g.size.get(n, 0), g.emps[n].name or ""))
        o = owner_of(dep)
        rows, pg = paginate(request, mem, lambda n: {
            **person(g, n, request, view_team_api=f"/api/people/org/employees/{g.emps[n].employee_code}/team/",
                     card_api=f"/api/people/org/employees/{g.emps[n].employee_code}/card/",
                     profile_api=f"/api/people/profile360/{g.emps[n].employee_code}/")})
        return ok("ORG_DEPARTMENT_VIEW", "Department view.", rows, meta=pg,
                  department={"id": dep.id, "name": dep.name, "code": dep.code, "employees": total,
                              "head": member_row(o.head) if o and o.head_id else None},
                  scope="all" if show_all else "leaders")


# ================================================================ settings (dynamic)
class OrgChartSettingsView(OrgBase, APIView):
    def _payload(self, s):
        return {"lead_keywords": s.lead_keywords, "group_min_size": s.group_min_size,
                "group_leaders": s.group_leaders, "leadership_label": s.leadership_label,
                "root_employee": ({"employee_code": s.root_employee.employee_code, "name": s.root_employee.name}
                                  if s.root_employee_id else None),
                "max_depth": s.max_depth, "department_styles": s.department_styles or {}}

    def get(self, request):
        return ok("ORG_CHART_SETTINGS", "Org chart settings.", self._payload(oc.get_settings(self.company())))

    @transaction.atomic
    def post(self, request):
        if not people_allows(request.user, "manage"):
            return err("FORBIDDEN", "Changing org chart settings needs the Employees 'manage' right.", http.HTTP_403_FORBIDDEN)
        company, d = self.company(), request.data
        s = oc.get_settings(company)
        try:
            if "lead_keywords" in d:
                v = d["lead_keywords"]
                if isinstance(v, str):
                    v = [x for x in re.split(r"[,\n]", v)]
                if not isinstance(v, (list, tuple)):
                    raise ValueError("lead_keywords must be a list of words.")
                seen, out = set(), []
                for x in v:
                    w = str(x).strip()
                    if not w:
                        continue
                    if len(w) > 30:
                        raise ValueError("Each lead keyword can be at most 30 characters.")
                    if w.lower() not in seen:                    # duplicate keywords are dropped
                        seen.add(w.lower())
                        out.append(w)
                if len(out) > 10:
                    raise ValueError("At most 10 lead keywords.")
                s.lead_keywords = out
            if "group_min_size" in d:
                n = _int(d["group_min_size"], "group_min_size", 2, 50)
                s.group_min_size = n
            if "max_depth" in d:
                s.max_depth = _int(d["max_depth"], "max_depth", 3, 25)
            if "group_leaders" in d:
                s.group_leaders = to_bool(d["group_leaders"])
            if "leadership_label" in d:
                lab = str(d["leadership_label"] or "").strip()
                if not lab or len(lab) > 60:
                    raise ValueError("leadership_label is required (max 60 characters).")
                s.leadership_label = lab
            if "root_employee" in d:
                ref = d["root_employee"]
                if ref in (None, ""):
                    s.root_employee = None
                else:
                    e = employees_qs(company).filter(employee_code=str(ref).strip(), is_active=True).first()
                    if e is None:
                        raise ValueError(f"'{ref}' is not an active employee of your company.")
                    g = oc.OrgGraph(company, s)
                    if e.id in g.manager:
                        raise ValueError("The root employee must not report to anyone. Remove their reporting manager first.")
                    s.root_employee = e
            if "department_styles" in d:
                st = d["department_styles"]
                if not isinstance(st, dict):
                    raise ValueError("department_styles must be an object {department_id: {icon, color}}.")
                valid = set(Department.objects.filter(company=company).values_list("id", flat=True))
                clean = {}
                for k, v in st.items():
                    if not str(k).isdigit() or int(k) not in valid:
                        raise ValueError(f"Department '{k}' not found in your company.")
                    if not isinstance(v, dict):
                        raise ValueError(f"department_styles[{k}] must be an object.")
                    icon, color = str(v.get("icon") or "").strip(), str(v.get("color") or "").strip()
                    if len(icon) > 30 or len(color) > 20:
                        raise ValueError(f"department_styles[{k}]: icon max 30, color max 20 characters.")
                    clean[str(int(k))] = {"icon": icon or None, "color": color or None}
                s.department_styles = {**(s.department_styles or {}), **clean}
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        s.updated_by = self.actor()
        s.save()
        return ok("ORG_CHART_SETTINGS_SAVED", "Org chart settings saved.", self._payload(s))


def _int(v, label, lo, hi):
    try:
        n = int(v)
    except (TypeError, ValueError):
        raise ValueError(f"{label} must be a whole number.")
    if n < lo or n > hi:
        raise ValueError(f"{label} must be between {lo} and {hi}.")
    return n
