# ============================================================
# ProjectHub - shared helpers (re-uses People.common + Timesheet.common, nothing re-implemented)
# ============================================================
from collections import defaultdict
from datetime import timedelta
from decimal import Decimal

from django.db.models import Q, Sum
from django.utils import timezone
from rest_framework.permissions import BasePermission

from Communication.models import Meeting, MeetingParticipant  # noqa: F401
from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated  # noqa: F401
from Employee.employee_crud_permissions import (_role_is_usable, actor_label, resolve_actor_role, role_allows)  # noqa: F401
from Employee.leave_models import ReportingHierarchy  # noqa: F401
from People.common import (CrudBase, PeopleAuthMixin, emp_brief, emp_by_code, employees_qs, err, iso, next_seq, ok,  # noqa: F401
                           paginate, to_bool, to_date, to_decimal, to_int)
from Timesheet.models import ProjectAllocation, TimesheetEntry, TimesheetProject  # noqa: F401
from Timesheet.common import find_project, project_row as ts_project_row  # noqa: F401

from .models import (ChangeRequest, DailyWorkReport, ProjectBug, ProjectMeetingMinute, ProjectPlan, ProjectTask,  # noqa: F401
                     TaskDependency)

MODULE = "projects"
DONE = ("Completed", "Cancelled")


# ---------------------------------------------------------------
# permissions: Company Admin always. Employee/HR: can_<action>_projects if that checkbox exists,
# else the same action on "timesheet", else on "attendance" (existing HR roles work with NO new migration).
# ---------------------------------------------------------------
def hub_allows(user, action):
    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 == "approve" else action
    return any(role_allows(role, m, a) for m in (MODULE, "timesheet", "attendance"))


class IsHubUser(BasePermission):
    message = "You do not have permission to manage Project & Milestone Tracking."
    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 hub_allows(request.user, act)


class HubAuthMixin(PeopleAuthMixin):
    permission_classes = [IsHubUser]


class HubCrud(HubAuthMixin, CrudBase):
    employee_field = None

    def filter(self, qs, p):
        qs = super().filter(qs, {k: v for k, v in p.items() if k not in ("employee", "project")})
        if p.get("project"):
            qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
        if p.get("employee") and self.employee_field:
            qs = qs.filter(**{self.employee_field: p["employee"]})
        return qs


# ---------------------------------------------------------------
# small lookups
# ---------------------------------------------------------------
def plan_for(project):
    """ProjectPlan is created lazily, so projects made in the Timesheet module also work here (no duplicate project)."""
    pl = getattr(project, "_plan_cache", None)
    if pl is None:
        pl, _ = ProjectPlan.objects.get_or_create(project=project, defaults={"company": project.company, "baseline_end_date": project.end_date,
                                                                              "approved_end_date": project.end_date})
        project._plan_cache = pl
    return pl


def find_task(company, ref, project=None):
    if ref in (None, ""):
        raise ValueError("task is required (id).")
    qs = ProjectTask.objects.filter(company=company, is_active=True)
    if project is not None:
        qs = qs.filter(project=project)
    t = qs.filter(pk=int(ref)).first() if str(ref).isdigit() else None
    if t is None:
        raise ValueError(f"Task '{ref}' not found.")
    return t


def choice(value, model_choices, label):
    allowed = dict(model_choices)
    if value not in allowed:
        raise ValueError(f"Invalid {label}. Allowed: {', '.join(allowed)}")
    return value


def actual_hours_by_task(company, project=None):
    qs = DailyWorkReport.objects.filter(company=company, is_active=True, status="Approved", task__isnull=False)
    if project is not None:
        qs = qs.filter(project=project)
    return {r["task_id"]: r["h"] for r in qs.values("task_id").annotate(h=Sum("hours"))}


def approved_hours(company, project=None, employee=None):
    qs = DailyWorkReport.objects.filter(company=company, is_active=True, status="Approved")
    if project is not None:
        qs = qs.filter(project=project)
    if employee is not None:
        qs = qs.filter(employee=employee)
    return qs.aggregate(h=Sum("hours"))["h"] or Decimal("0")


def is_overdue(t, today=None):
    today = today or timezone.localdate()
    return bool(t.due_date and t.due_date < today and t.status not in DONE)


def manager_projects(company, emp):
    return TimesheetProject.objects.filter(company=company, is_active=True, manager=emp)


def my_project_ids(company, emp):
    ids = set(ProjectAllocation.objects.filter(company=company, employee=emp, is_active=True).values_list("project_id", flat=True))
    ids |= set(manager_projects(company, emp).values_list("id", flat=True))
    return ids


# ---------------------------------------------------------------
# row builders (shared by Admin/HR and Employee side)
# ---------------------------------------------------------------
def task_row(t, request=None, actual=None):
    return {"id": t.id, "project": {"id": t.project_id, "code": t.project.code, "title": t.project.title},
            "parent_id": t.parent_id, "wbs_code": t.wbs_code, "title": t.title, "description": t.description,
            "type": "Milestone" if t.is_milestone else "Task", "is_milestone": t.is_milestone,
            "assignee": emp_brief(t.assignee, request) if t.assignee_id else None, "status": t.status, "priority": t.priority,
            "progress": t.progress, "start_date": iso(t.start_date), "due_date": iso(t.due_date), "completed_on": iso(t.completed_on),
            "planned_hours": float(t.planned_hours), "actual_hours": float(actual if actual is not None else 0),
            "is_overdue": is_overdue(t), "deliverable_verified": t.deliverable_verified, "blocked_reason": t.blocked_reason,
            "is_critical": t.is_critical, "early_start": iso(t.early_start), "early_finish": iso(t.early_finish), "slack_days": t.slack_days,
            "predecessors": [l.predecessor_id for l in t.predecessor_links.all() if l.is_active],
            "created_at": iso(t.created_at)}


def bug_row(b, request=None):
    return {"id": b.id, "bug_id": b.bug_code, "title": b.title, "description": b.description, "steps_to_reproduce": b.steps_to_reproduce,
            "project": {"id": b.project_id, "code": b.project.code, "title": b.project.title},
            "task_id": b.task_id, "severity": b.severity, "status": b.status, "qa_result": b.qa_result,
            "assignee": emp_brief(b.assignee, request) if b.assignee_id else None, "reported_by_code": b.reported_by_code,
            "rca": b.rca, "resolution": b.resolution, "resolved_at": iso(b.resolved_at), "created_at": iso(b.created_at)}


def cr_row(c):
    return {"id": c.id, "cr_id": c.cr_code, "project": {"id": c.project_id, "code": c.project.code, "title": c.project.title},
            "reason": c.reason, "scope_impact": c.scope_impact, "budget_impact": float(c.budget_impact), "hours_impact": float(c.hours_impact),
            "revised_target": iso(c.revised_target_date), "status": c.status, "requested_by_code": c.requested_by_code,
            "decided_by": c.decided_by, "decided_at": iso(c.decided_at), "decision_remarks": c.decision_remarks, "created_at": iso(c.created_at)}


def meeting_row(m, request=None):
    mt = m.meeting
    parts = [{"employee": emp_brief(p.employee, request), "role": p.role, "rsvp": p.rsvp}
             for p in mt.participants.filter(is_active=True).select_related("employee", "employee__department")]
    return {"id": m.id, "meeting_id": mt.id, "project": {"id": m.project_id, "code": m.project.code, "title": m.project.title},
            "title": mt.title, "agenda": mt.agenda, "meeting_type": m.project_meeting_type, "start_at": iso(mt.start_at), "end_at": iso(mt.end_at),
            "location": mt.location, "meeting_link": mt.meeting_link, "organizer": emp_brief(mt.organizer, request) if mt.organizer_id else None,
            "organizer_name": mt.organizer_name, "status": "Cancelled" if mt.status == "CANCELLED" else ("Completed" if mt.end_at < timezone.now() else "Scheduled"),
            "participants": parts, "minutes": m.minutes, "decisions": m.decisions, "rca": m.rca, "action_items": m.action_items, "created_at": iso(m.created_at)}


def dwr_row(r, request=None):
    ts = TimesheetEntry.objects.filter(company=r.company_id, employee=r.employee_id, project=r.project_id, work_date=r.report_date,
                                       is_active=True).exclude(status="Rejected").aggregate(h=Sum("hours"))["h"] or Decimal("0")
    return {"id": r.id, "employee": emp_brief(r.employee, request), "project": {"id": r.project_id, "code": r.project.code, "title": r.project.title},
            "task_id": r.task_id, "task_title": r.task.title if r.task_id else None, "report_date": iso(r.report_date), "summary": r.summary,
            "blockers": r.blockers, "hours": float(r.hours), "progress_percent": r.progress_percent, "status": r.status,
            "status_label": dict(DailyWorkReport.STATUS).get(r.status), "timesheet_hours_same_day": float(ts),
            "reviewed_by": r.reviewed_by, "reviewed_at": iso(r.reviewed_at), "review_remarks": r.review_remarks, "created_at": iso(r.created_at)}


def project_hub_row(p, request=None):
    """Timesheet's own project row + the planning extras + task/bug stats. Nothing duplicated."""
    pl = plan_for(p)
    base = ts_project_row(p, request)
    tasks = [t for t in ProjectTask.objects.filter(project=p, is_active=True).exclude(status="Cancelled")]
    work = [t for t in tasks if not t.is_milestone]
    ms = [t for t in tasks if t.is_milestone]
    prog = int(round(sum(t.progress for t in work) / len(work))) if work else 0
    base.update(priority=pl.priority, budget_amount=float(pl.budget_amount) if pl.budget_amount is not None else None,
                baseline_end_date=iso(pl.baseline_end_date), approved_end_date=iso(pl.approved_end_date), forecast_end_date=iso(pl.forecast_end_date),
                tasks_total=len(work), tasks_completed=sum(1 for t in work if t.status == "Completed"),
                milestones_total=len(ms), milestones_completed=sum(1 for t in ms if t.status == "Completed"),
                overdue_tasks=sum(1 for t in tasks if is_overdue(t)), progress_percent=prog,
                open_bugs=ProjectBug.objects.filter(project=p, is_active=True).exclude(status__in=("Closed", "Won't Fix")).count(),
                pending_change_requests=ChangeRequest.objects.filter(project=p, is_active=True, status="Pending").count())
    return base


def task_tree(project, request=None):
    tasks = list(ProjectTask.objects.filter(project=project, is_active=True).select_related("project", "assignee", "assignee__department")
                 .prefetch_related("predecessor_links").order_by("wbs_code", "id"))
    act = actual_hours_by_task(project.company, project)
    by_parent = defaultdict(list)
    for t in tasks:
        by_parent[t.parent_id].append(t)

    def build(t):
        r = task_row(t, request, act.get(t.id, 0))
        r["children"] = [build(c) for c in by_parent.get(t.id, [])]
        return r
    ids = {t.id for t in tasks}
    return [build(t) for t in tasks if t.parent_id is None or t.parent_id not in ids]


def next_wbs(project, parent):
    sib = ProjectTask.objects.filter(project=project, parent=parent, is_active=True).count() + 1
    return f"{parent.wbs_code}.{sib}" if parent and parent.wbs_code else str(sib)
