# ============================================================
# Shared helpers for the People (Employees workspace) API
# ============================================================
from datetime import date, datetime
from decimal import Decimal, InvalidOperation

from django.db.models import Q
from django.utils import timezone
from django.utils.dateparse import parse_date, parse_datetime
from rest_framework import status as http
from rest_framework.decorators import action
from rest_framework.permissions import BasePermission
from rest_framework.response import Response
from rest_framework.viewsets import ViewSet

from Employee.employee_crud_permissions import (
    AdminOrEmployeeJWTAuthentication, _role_is_usable, actor_label,
    resolve_actor_role, resolve_company_for_user, role_allows,
)
from Employee.models import EmployeeDT

from .models import EmployeeExtra, HistoryEvent

MODULE = "employees"          # EmployeeRole checkboxes: can_<view|create|edit|delete|manage>_employees


# ---------------------------------------------------------------
# response envelope (same as Company/hr_api_views.py + Recruitment)
# ---------------------------------------------------------------
def ok(code, message, data=None, status=http.HTTP_200_OK, **extra):
    body = {"status": "success", "code": code, "message": message, "data": data}
    body.update(extra)
    return Response(body, status=status)


def err(code, message, status=http.HTTP_400_BAD_REQUEST, errors=None):
    body = {"status": "error", "code": code, "message": message, "data": None}
    if errors is not None:
        body["errors"] = errors
    return Response(body, status=status)


# ---------------------------------------------------------------
# permissions: Company Admin always; employee (HR) via role checkboxes
# ---------------------------------------------------------------
def people_allows(user, action_name):
    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
    return role_allows(role, MODULE, "edit" if action_name == "approve" else action_name)


class IsPeopleUser(BasePermission):
    message = "You do not have permission to use the Employees module."
    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)
            if va == "update_post":
                act = "edit"
            elif va == "delete_post":
                act = "delete"
            else:
                act = (getattr(view, "permission_action_map", None) or {}).get(va)
        if act is None:
            act = self.METHOD_ACTION.get(request.method)
        return bool(act) and people_allows(request.user, act)


class PeopleAuthMixin:
    authentication_classes = [AdminOrEmployeeJWTAuthentication]
    permission_classes = [IsPeopleUser]

    # POST-only clients (project convention): <id>/update/ and <id>/delete/
    @action(detail=True, methods=["post"], url_path="update")
    def update_post(self, request, pk=None):
        fn = getattr(self, "partial_update", None)
        if fn is None:
            return err("NOT_ALLOWED", "Update is not supported here.", http.HTTP_405_METHOD_NOT_ALLOWED)
        return fn(request, pk)

    @action(detail=True, methods=["post"], url_path="delete")
    def delete_post(self, request, pk=None):
        fn = getattr(self, "destroy", None)
        if fn is None:
            return err("NOT_ALLOWED", "Delete is not supported here.", http.HTTP_405_METHOD_NOT_ALLOWED)
        return fn(request, pk)

    def company(self):
        return resolve_company_for_user(self.request.user)

    def actor(self):
        return actor_label(self.request.user)


# ---------------------------------------------------------------
# parsing
# ---------------------------------------------------------------
def to_decimal(value, default=None):
    if value in (None, ""):
        return default
    try:
        return Decimal(str(value))
    except (InvalidOperation, ValueError):
        raise ValueError(f"Invalid number: {value}")


def to_date(value):
    if value in (None, ""):
        return None
    if isinstance(value, datetime):
        return value.date()
    if isinstance(value, date):
        return value
    d = parse_date(str(value)[:10])
    if d is None:
        raise ValueError(f"Invalid date (use YYYY-MM-DD): {value}")
    return d


def to_bool(value, default=False):
    if value is None:
        return default
    return str(value).strip().lower() in ("1", "true", "yes", "y", "on")


def to_int(value, default=None):
    if value in (None, ""):
        return default
    try:
        return int(value)
    except (TypeError, ValueError):
        raise ValueError(f"Invalid integer: {value}")


def iso(v):
    return v.isoformat() if v else None


def paginate(request, items, builder, default_size=25, max_size=200):
    """items = queryset or list. Returns (rows, meta)."""
    try:
        size = max(1, min(int(request.query_params.get("page_size", default_size)), max_size))
        page = max(1, int(request.query_params.get("page", 1)))
    except ValueError:
        size, page = default_size, 1
    total = items.count() if hasattr(items, "count") and not isinstance(items, list) else len(items)
    start = (page - 1) * size
    chunk = items[start:start + size]
    meta = {"page": page, "page_size": size, "total": total, "pages": (total + size - 1) // size or 1}
    return [builder(o) for o in chunk], meta


# ---------------------------------------------------------------
# employees
# ---------------------------------------------------------------
def employees_qs(company):
    """Real employees only = EmployeeDT rows that are NOT still candidates.
    (Candidates: Employee_Status 'Candidate', or hiring fields present and
    not yet JOINED. Converted candidates have candidate_status JOINED.)"""
    hiring = (Q(recruitment_profile__isnull=False)
              | (Q(applied_position__isnull=False) & ~Q(applied_position="")))
    return (EmployeeDT.objects.filter(company=company)
            .exclude(Employee_Status__iexact="Candidate")
            .exclude(hiring & ~Q(candidate_status="JOINED")))


def emp_by_code(company, code, required=True):
    if code in (None, ""):
        if required:
            raise ValueError("employee_code is required.")
        return None
    emp = employees_qs(company).filter(employee_code=str(code).strip()).first()
    if emp is None:
        raise ValueError(f"Employee '{code}' not found in your company.")
    return emp


def infer_lifecycle(emp):
    """Lifecycle for an employee that has no EmployeeExtra yet (old data):
    resigned -> Notice; joined within 6 months -> Probation; otherwise Confirmed."""
    if getattr(emp, "Resignation_Status", None):
        return "Notice"
    doj = getattr(emp, "Date_of_Joining", None)
    if doj and (timezone.localdate() - doj).days <= 180:
        return "Probation"          # recent joiner
    return "Confirmed"              # established (or unknown joining date) - avoids flooding the probation queue


def ensure_extra(emp):
    extra, _ = EmployeeExtra.objects.get_or_create(
        employee=emp, defaults={"company": emp.company, "lifecycle_status": infer_lifecycle(emp)})
    return extra


def sync_extras(company):
    """Idempotent: give every pre-existing employee an EmployeeExtra row (lifecycle inferred), so directory
    filters / counts also work for data created before this module existed."""
    missing = employees_qs(company).filter(people_profile__isnull=True)
    rows = [EmployeeExtra(company=company, employee=e, lifecycle_status=infer_lifecycle(e),
                          probation_due_date=None) for e in missing]
    if rows:
        EmployeeExtra.objects.bulk_create(rows, ignore_conflicts=True)
    return len(rows)


def lifecycle_label(extra):
    return dict(EmployeeExtra.LIFECYCLE).get(extra.lifecycle_status, extra.lifecycle_status)


def dept_name(emp):
    return emp.department.name if getattr(emp, "department_id", None) else emp.Department


def emp_brief(emp, request=None):
    if emp is None:
        return None
    img = None
    f = getattr(emp, "profile_image", None) or getattr(emp, "image", None)
    if f:
        try:
            img = request.build_absolute_uri(f.url) if request else f.url
        except Exception:
            img = None
    return {"id": emp.id, "employee_code": emp.employee_code, "name": emp.name, "email": emp.email,
            "designation": emp.Designation, "department": dept_name(emp), "profile_image": img}


def get_extra(emp):
    try:
        return emp.people_profile
    except EmployeeExtra.DoesNotExist:
        return None


def log_history(company, emp, event_type, title, description=None, when=None, meta=None, actor=None):
    return HistoryEvent.objects.create(
        company=company, employee=emp, event_type=event_type, title=title, description=description,
        event_date=when or timezone.localdate(), meta=meta or {}, created_by=actor, updated_by=actor)


def next_seq(model, company, field, prefix, width=4):
    """PREFIX-<n> sequence per company, e.g. APT-2026-0001."""
    last = (model.objects.filter(company=company, **{f"{field}__startswith": prefix})
            .order_by("-id").values_list(field, flat=True).first())
    n = 1
    if last:
        try:
            n = int(last.rsplit("-", 1)[1]) + 1
        except (IndexError, ValueError):
            n = model.objects.filter(company=company).count() + 1
    return f"{prefix}{str(n).zfill(width)}"


# ---------------------------------------------------------------
# generic company-isolated CRUD base (POST-style + REST style)
# subclasses define: model, scope(), build(), apply()
# ---------------------------------------------------------------
class CrudBase(PeopleAuthMixin, ViewSet):
    model = None
    code = "RECORD"
    search_fields = ()
    status_field = "status"
    select = ()
    soft_delete = True

    def scope(self):
        qs = self.model.objects.filter(company=self.company())
        if self.select:
            qs = qs.select_related(*self.select)
        return qs

    def build(self, obj):                    # -> dict
        raise NotImplementedError

    def apply(self, obj, data, creating):    # mutate obj, raise ValueError
        raise NotImplementedError

    def after_save(self, obj, creating):
        pass

    def filter(self, qs, p):
        if p.get(self.status_field) and self.status_field:
            qs = qs.filter(**{self.status_field: p[self.status_field]})
        if p.get("employee"):
            qs = qs.filter(employee__employee_code=p["employee"])
        q = (p.get("search") or "").strip()
        if q and self.search_fields:
            cond = Q()
            for f in self.search_fields:
                cond |= Q(**{f"{f}__icontains": q})
            qs = qs.filter(cond)
        return qs

    def list(self, request):
        qs = self.filter(self.scope().filter(is_active=True), request.query_params)
        rows, meta = paginate(request, qs, self.build)
        return ok(f"{self.code}_LIST", "List fetched.", rows, meta=meta)

    def retrieve(self, request, pk=None):
        obj = self.scope().filter(pk=pk, is_active=True).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        return ok(f"{self.code}_DETAIL", "Detail fetched.", self.build(obj))

    def create(self, request):
        obj = self.model(company=self.company(), created_by=self.actor(), updated_by=self.actor())
        try:
            self.apply(obj, request.data, True)
            obj.save()
            self.after_save(obj, True)
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok(f"{self.code}_CREATED", "Created.", self.build(obj), http.HTTP_201_CREATED)

    def partial_update(self, request, pk=None):
        obj = self.scope().filter(pk=pk, is_active=True).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            self.apply(obj, request.data, False)
            obj.updated_by = self.actor()
            obj.save()
            self.after_save(obj, False)
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok(f"{self.code}_UPDATED", "Updated.", self.build(obj))

    update = partial_update

    def destroy(self, request, pk=None):
        obj = self.scope().filter(pk=pk, is_active=True).first()
        if obj is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if self.soft_delete:
            obj.is_active, obj.updated_by = False, self.actor()
            obj.save()
        else:
            obj.delete()
        return ok(f"{self.code}_DELETED", "Deleted.", {"id": int(pk)})
