# ============================================================
# ADDITIVE: Organization Hierarchy - graph, tree builder, validation (pure helpers, no HTTP).
# One reporting manager per employee (EmployeeExtra.reporting_manager).  The builder:
#   * only uses ACTIVE employees of ONE company  (B2B isolation - the graph is loaded per company)
#   * lists every employee exactly once (no duplicate nodes), even if old data contains a reporting loop
#   * never raises on bad data; problems are returned as `issues`
# ============================================================
import re
from collections import Counter, defaultdict

from .common import dept_name, emp_brief, employees_qs
from .models import EmployeeExtra, OrgChartSettings

UNASSIGNED = "Unassigned"
PALETTE = ["#2563eb", "#16a34a", "#9333ea", "#ea580c", "#0891b2", "#db2777", "#0d9488", "#ca8a04"]
MAX_NODE_MEMBERS = 200


def get_settings(company):
    s, _ = OrgChartSettings.objects.get_or_create(company=company)
    return s


def dept_label(e):
    return dept_name(e) or e.Sub_Department or UNASSIGNED


def pluralize(word):
    w = (word or "").strip()
    if not w:
        return "Team Members"
    if w.lower().endswith("s"):
        return w
    if w.lower().endswith("y") and len(w) > 1 and w[-2].lower() not in "aeiou":
        return w[:-1] + "ies"
    return w + "s"


def is_lead(e, keywords):
    d = (e.Designation or "").lower()
    return any(k.lower() in d for k in (keywords or []) if k)


class OrgGraph:
    """Active employees of one company + their reporting lines, loaded in 2 queries."""

    def __init__(self, company, settings=None):
        self.company = company
        self.settings = settings or get_settings(company)
        emps = list(employees_qs(company).filter(is_active=True).select_related("department")
                    .order_by("name", "id"))
        self.emps = {e.id: e for e in emps}
        self.by_code = {e.employee_code: e for e in emps}
        raw = dict(EmployeeExtra.objects.filter(company=company, employee_id__in=list(self.emps))
                   .values_list("employee_id", "reporting_manager_id"))
        self.manager = {}                  # employee id -> manager id (only when the manager is active & in company)
        self.children = defaultdict(list)
        self.broken_manager = []           # reports to an inactive / exited / foreign manager
        for e in emps:
            m = raw.get(e.id)
            if m and m != e.id and m in self.emps:
                self.manager[e.id] = m
                self.children[m].append(e.id)
            elif m:
                self.broken_manager.append(e.id)
        for kids in self.children.values():
            kids.sort(key=lambda i: (self.emps[i].name or "", i))
        self._build_forest()

    # ---- forest: every employee ends up in exactly one tree
    def _build_forest(self):
        self.parent, self.order, self.cycle_roots, seen = {}, [], [], set()
        natural = [i for i in self.emps if i not in self.manager]

        def walk(root):
            stack = [root]
            while stack:
                n = stack.pop()
                if n in seen:
                    continue
                seen.add(n)
                self.order.append(n)
                for c in reversed(self.children.get(n, [])):
                    if c not in seen:
                        self.parent[c] = n
                        stack.append(c)

        self.size = {}
        natural.sort(key=lambda i: (self.emps[i].name or "", i))
        for r in natural:
            walk(r)
        for i in sorted(self.emps, key=lambda i: (self.emps[i].name or "", i)):
            if i not in seen:                       # member of a reporting loop - break it here
                self.cycle_roots.append(i)
                walk(i)
        self.roots = natural + self.cycle_roots
        for n in reversed(self.order):
            self.size[n] = sum(1 + self.size[c] for c in self.children.get(n, []) if self.parent.get(c) == n)

    # ---- helpers
    def kids(self, n):
        return [c for c in self.children.get(n, []) if self.parent.get(c) == n]

    def ancestors(self, n):
        out, seen = [], {n}
        while n in self.parent and self.parent[n] not in seen:
            n = self.parent[n]
            seen.add(n)
            out.append(n)
        return out

    def descendants(self, n):
        out, stack = set(), list(self.kids(n))
        while stack:
            x = stack.pop()
            if x not in out:
                out.add(x)
                stack.extend(self.kids(x))
        return out

    def height(self, n):
        """Number of levels below n."""
        best, stack = 0, [(n, 0)]
        while stack:
            x, d = stack.pop()
            best = max(best, d)
            stack.extend((c, d + 1) for c in self.kids(x))
        return best

    def depth_of(self, n):
        return len(self.ancestors(n))

    def primary_root(self):
        s = self.settings
        if s.root_employee_id and s.root_employee_id in self.emps and s.root_employee_id not in self.manager:
            return s.root_employee_id
        cands = [r for r in self.roots if r not in self.cycle_roots] or self.roots
        if not cands:
            return None
        return sorted(cands, key=lambda i: (-self.size.get(i, 0),
                                            self.emps[i].Date_of_Joining.toordinal() if self.emps[i].Date_of_Joining else 10 ** 7,
                                            i))[0]

    def is_leader(self, n):
        return bool(self.kids(n))

    def stats(self):
        kw = self.settings.lead_keywords
        leaders = [n for n in self.emps if self.kids(n)]
        leads = [n for n in leaders if is_lead(self.emps[n], kw)]
        return {"total_employees": len(self.emps), "leaders": len(leaders), "team_leads": len(leads),
                "managers": len(leaders) - len(leads),
                "individual_contributors": len(self.emps) - len(leaders), "top_level_roots": len(self.roots)}

    def role_type(self, n):
        if not self.kids(n):
            return "member"
        return "lead" if is_lead(self.emps[n], self.settings.lead_keywords) else "manager"

    def chain(self, n):
        """Management chain, top first, ending at n's manager."""
        return [self.emps[a] for a in reversed(self.ancestors(n))]

    def issues(self):
        out = []
        if self.cycle_roots:
            names = [self.emps[i].name for i in self.cycle_roots]
            out.append({"type": "CIRCULAR_REPORTING", "severity": "error", "count": len(self.cycle_roots),
                        "message": "Reporting loop found (A reports to B who reports back to A).",
                        "employees": [self._row(i) for i in self.cycle_roots], "names": names})
        if self.broken_manager:
            out.append({"type": "INACTIVE_MANAGER", "severity": "warning", "count": len(self.broken_manager),
                        "message": "Reports to an inactive / exited manager - re-assign the reporting manager.",
                        "employees": [self._row(i) for i in self.broken_manager]})
        natural = [r for r in self.roots if r not in self.cycle_roots]
        if len(natural) > 1:
            out.append({"type": "MULTIPLE_ROOTS", "severity": "warning", "count": len(natural),
                        "message": f"{len(natural)} employees have no reporting manager (a company normally has one top node).",
                        "employees": [self._row(i) for i in natural]})
        too_deep = [n for n in self.emps if self.depth_of(n) + 1 > self.settings.max_depth]
        if too_deep:
            out.append({"type": "TOO_DEEP", "severity": "warning", "count": len(too_deep),
                        "message": f"Reporting chain is deeper than the allowed {self.settings.max_depth} levels.",
                        "employees": [self._row(i) for i in too_deep[:50]]})
        codes = Counter((e.employee_code or "").strip().lower() for e in self.emps.values())
        dup_codes = sorted(c for c, n in codes.items() if c and n > 1)
        if dup_codes:
            out.append({"type": "DUPLICATE_EMPLOYEE_CODE", "severity": "error", "count": len(dup_codes),
                        "message": "The same employee code is used by more than one active employee.",
                        "values": dup_codes})
        mails = Counter((e.email or "").strip().lower() for e in self.emps.values())
        dup_mails = sorted(m for m, n in mails.items() if m and n > 1)
        if dup_mails:
            out.append({"type": "DUPLICATE_EMAIL", "severity": "warning", "count": len(dup_mails),
                        "message": "The same email id is used by more than one active employee.", "values": dup_mails})
        return out

    def _row(self, n):
        e = self.emps[n]
        return {"employee_code": e.employee_code, "name": e.name, "designation": e.Designation,
                "department": dept_label(e)}


# ---------------------------------------------------------------- validation of a new reporting line
def reporting_loop(graph, emp_id, mgr_id):
    """Chain [mgr ... emp] when making emp report to mgr would create a loop, else None."""
    path, n, seen = [mgr_id], mgr_id, {mgr_id}
    while n in graph.manager:
        n = graph.manager[n]
        path.append(n)
        if n == emp_id:
            return path
        if n in seen:
            return None                          # an existing loop elsewhere, not through emp
        seen.add(n)
    return None


def check_reporting_line(graph, emp, mgr):
    """Raise ValueError when `emp -> mgr` is not allowed.  mgr None = remove the manager."""
    if mgr is None:
        return
    if mgr.pk == emp.pk:
        raise ValueError("An employee cannot report to themselves.")
    if mgr.company_id != emp.company_id:
        raise ValueError("The manager belongs to a different company.")      # B2B guard
    if mgr.id not in graph.emps:
        raise ValueError(f"'{mgr.employee_code}' is not an active employee of your company.")
    loop = reporting_loop(graph, emp.id, mgr.id)
    if loop:
        names = " -> ".join(graph.emps[i].name for i in [emp.id] + loop[:-1] + [emp.id])
        raise ValueError(f"{mgr.name} already reports (directly or indirectly) to {emp.name}; this would create a "
                         f"circular reporting line ({names}).")
    new_levels = graph.depth_of(mgr.id) + 1 + 1 + graph.height(emp.id)
    if new_levels > graph.settings.max_depth:
        raise ValueError(f"This would make the reporting chain {new_levels} levels deep; the limit is "
                         f"{graph.settings.max_depth}.")


def assert_no_cycle(company, emp, mgr):
    """Hook used by the existing directory edit: block reporting loops there as well."""
    if mgr is None:
        return
    graph = OrgGraph(company)
    if reporting_loop(graph, emp.id, mgr.id):
        raise ValueError(f"{mgr.name} already reports (directly or indirectly) to {emp.name}; "
                         "this would create a circular reporting line.")


# ---------------------------------------------------------------- tree building
def _norm_key(s):
    return re.sub(r"[^a-z0-9]+", "-", (s or "").lower()).strip("-") or "team-members"


class TreeBuilder:
    def __init__(self, graph, request=None, q="", dept=None, expand="2", depth=None, group=True):
        self.g, self.request, self.q = graph, request, (q or "").strip().lower()
        self.dept = dept                      # Department row or None
        self.depth = depth
        self.group = group and not self.q     # searching shows people individually
        self.expand_all = str(expand).lower() == "all"
        self.expand_levels = 0 if str(expand).lower() == "none" else (999 if self.expand_all else (
            int(expand) if str(expand).isdigit() else 2))
        self.matches, self.included, self.nodes = set(), None, 0
        self.max_level = 0
        if self.q or self.dept is not None:
            self._filter()

    # ---- filter: matches + all their managers stay visible so the chart remains connected
    def _filter(self):
        g, q = self.g, self.q
        for n, e in g.emps.items():
            ok_q = (not q) or q in (e.name or "").lower() or q in (e.employee_code or "").lower() \
                or q in (e.email or "").lower() or q in (e.Designation or "").lower()
            ok_d = self.dept is None or _in_department(e, self.dept)
            if ok_q and ok_d:
                self.matches.add(n)
        inc = set(self.matches)
        for n in list(self.matches):
            inc.update(g.ancestors(n))
        self.included = inc

    def visible(self, n):
        return self.included is None or n in self.included

    # ---- nodes
    def _image(self, e):
        return emp_brief(e, self.request)["profile_image"]

    def emp_node(self, n, level, is_primary=False):
        g, e = self.g, self.g.emps[n]
        self.nodes += 1
        self.max_level = max(self.max_level, level)
        kids = [c for c in g.kids(n) if self.visible(c)]
        node = {
            "id": f"emp:{e.employee_code}", "type": "employee", "employee_code": e.employee_code, "name": e.name,
            "designation": e.Designation, "department": dept_label(e), "department_id": e.department_id,
            "profile_image": self._image(e), "level": level, "is_root": is_primary,
            "badge": "Root Node" if is_primary else None, "role_type": g.role_type(n),
            "direct_reports": len(g.kids(n)), "team_size": g.size.get(n, 0),
            "matched": n in self.matches if self.included is not None else False,
            "in_filter": (n in self.matches) if self.included is not None else True,
            "has_children": bool(kids),
            "expanded": (self.expand_all or level < self.expand_levels
                         or (self.included is not None and bool(kids))),
            "children_loaded": True, "children": [],
        }
        if self.depth is not None and level >= self.depth:
            node["children_loaded"] = False
            return node
        node["children"] = self._children(n, level + 1, is_primary)
        return node

    def _children(self, n, level, is_primary):
        g, s = self.g, self.g.settings
        kids = [c for c in g.kids(n) if self.visible(c)]
        leaders = [c for c in kids if g.kids(c)]
        ics = [c for c in kids if not g.kids(c)]
        out = []
        # leaders (people who manage people) are always individual nodes
        leader_nodes = [self.emp_node(c, level + (1 if (is_primary and s.group_leaders and leaders) else 0)) for c in leaders]
        if is_primary and s.group_leaders and leaders:
            self.max_level = max(self.max_level, level)
            out.append({"id": f"leadership:{g.emps[n].employee_code}", "type": "leadership", "label": s.leadership_label,
                        "count": len(leaders), "level": level, "expanded": True,
                        "children_loaded": True, "children": leader_nodes})
        else:
            out.extend(leader_nodes)
        # individual contributors: same-designation groups (>= group_min_size) or single nodes
        buckets = defaultdict(list)
        for c in ics:
            buckets[(g.emps[c].Designation or "").strip().lower()].append(c)
        for key, members in sorted(buckets.items(), key=lambda kv: (-len(kv[1]), kv[0])):
            if self.group and len(members) >= max(2, s.group_min_size):
                out.append(self._group_node(n, key, members, level))
            else:
                out.extend(self.emp_node(c, level) for c in members)
        return out

    def _group_node(self, n, key, members, level):
        g = self.g
        self.max_level = max(self.max_level, level)
        label = (g.emps[members[0]].Designation or "").strip() or "Team Members"
        rows = [{"employee_code": g.emps[m].employee_code, "name": g.emps[m].name,
                 "designation": g.emps[m].Designation, "profile_image": self._image(g.emps[m])}
                for m in members[:MAX_NODE_MEMBERS]]
        return {"id": f"group:{g.emps[n].employee_code}:{_norm_key(key)}", "type": "group", "label": label,
                "plural_label": pluralize(label), "display_label": f"{pluralize(label)} ({len(members)})",
                "count": len(members), "level": level, "expanded": False, "preview": rows[:5],
                "members": rows, "members_truncated": len(members) > MAX_NODE_MEMBERS,
                "children_loaded": True, "children": []}

    def tree(self, root_id, is_primary):
        if not self.visible(root_id):
            return None
        return self.emp_node(root_id, 0, is_primary)


def _in_department(e, dep):
    if e.department_id:
        return e.department_id == dep.id
    return (e.Department or "").strip().lower() == dep.name.strip().lower()


# ---------------------------------------------------------------- flat rows (export / team lists)
def flat_rows(graph, include=None):
    """Depth-first rows (manager before reports) - each employee exactly once."""
    out = []
    for n in graph.order:
        if include is not None and n not in include:
            continue
        e = graph.emps[n]
        m = graph.emps.get(graph.parent.get(n))
        out.append({"level": graph.depth_of(n), "employee_code": e.employee_code, "name": e.name,
                    "designation": e.Designation or "", "department": dept_label(e),
                    "reporting_manager_code": m.employee_code if m else "",
                    "reporting_manager": m.name if m else "", "direct_reports": len(graph.kids(n)),
                    "team_size": graph.size.get(n, 0), "role_type": graph.role_type(n),
                    "email": e.email or "", "joining_date": e.Date_of_Joining.isoformat() if e.Date_of_Joining else "",
                    "status": "Active"})
    return out
