# ============================================================
# Payroll Hub - shared helpers (reuses People.common: envelope, paging, parsing, CrudBase)
# Everything is computed from the database - no sample / hard-coded data.
# ============================================================
import os
from decimal import ROUND_HALF_UP, Decimal

from rest_framework.permissions import BasePermission

from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated  # noqa: F401
from Employee.employee_crud_permissions import (_role_is_usable, actor_label, resolve_actor_role,  # noqa: F401
                                                role_allows)
from Employee.models import EmployeeDT
from People.common import (CrudBase, PeopleAuthMixin, dept_name, emp_brief, emp_by_code, employees_qs, err, iso,  # noqa: F401
                           ok, paginate, to_bool, to_date, to_decimal, to_int)

from .models import PayrollSetting

MODULE = "payroll"
MONTHS = ["", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October",
          "November", "December"]
ALLOWED_EXT = {".pdf", ".doc", ".docx", ".xls", ".xlsx", ".png", ".jpg", ".jpeg", ".txt", ".csv"}
TWO = Decimal("0.01")


def q2(v):
    return Decimal(v or 0).quantize(TWO, rounding=ROUND_HALF_UP)


def f(v):
    return float(q2(v))


def month_label(m, y):
    return f"{MONTHS[m]} {y}" if m and y else None


def lakhs(v):
    return f"₹{float(v) / 100000:,.1f} Lakhs"


# ---------------- permissions (Payroll module) ----------------
def payroll_allows(user, act):
    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 bool(role_allows(role, MODULE, "edit" if act == "approve" else act))


class IsPayrollUser(BasePermission):
    message = "You do not have permission to use the Payroll 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)
            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 payroll_allows(request.user, act)


class PayAuthMixin(PeopleAuthMixin):
    permission_classes = [IsPayrollUser]


class PayCrud(PayAuthMixin, CrudBase):
    pass


class EmployeeBase:
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    def company(self):
        return self.request.user.company

    def actor(self):
        return actor_label(self.request.user)


def person(request):
    u = request.user
    return (u, u.name) if isinstance(u, EmployeeDT) else (None, "Company Admin")


def get_setting(company):
    s, _ = PayrollSetting.objects.get_or_create(company=company)
    return s


def check_file(fobj, mb=10):
    if os.path.splitext(fobj.name)[1].lower() not in ALLOWED_EXT:
        raise ValueError("Unsupported file type. Allowed: " + ", ".join(sorted(ALLOWED_EXT)))
    if fobj.size > mb * 1024 * 1024:
        raise ValueError(f"File too large (max {mb} MB).")


def file_url(request, fl):
    if not fl:
        return None
    try:
        return request.build_absolute_uri(fl.url) if request else fl.url
    except Exception:
        return None


def pick(value, allowed, label):
    v = str(value or "").strip().upper()
    if v not in allowed:
        raise ValueError(f"Invalid {label}. Allowed: {', '.join(allowed)}")
    return v


def month_year(d, o=None, required=True):
    m = to_int(d.get("month"), getattr(o, "month", None))
    y = to_int(d.get("year"), getattr(o, "year", None))
    if required and (not m or not y):
        raise ValueError("month and year are required.")
    if m is not None and not 1 <= m <= 12:
        raise ValueError("month must be 1-12.")
    if y is not None and not 2000 <= y <= 2100:
        raise ValueError("year is invalid.")
    return m, y


def money(d, key, default=None, allow_zero=True):
    v = to_decimal(d.get(key), default)
    if v is not None:
        if v < 0:
            raise ValueError(f"{key} cannot be negative.")
        if not allow_zero and v == 0:
            raise ValueError(f"{key} must be greater than zero.")
    return v
