# ============================================================
# Payroll Hub - Employee app            /employee/payroll-hub/...
# Auth: Employee JWT only. An employee sees ONLY their own data; payslips appear only after HR releases the cycle.
#
#   home/                          latest payslip, outstanding loans, pending claims, YTD
#   payslips/ , <id>/ , <id>/pdf/  my released payslips (?financial_year=)
#   inputs/ ?month= &year=         my payroll inputs / claims;  POST raise a reimbursement claim; PATCH|DELETE while pending
#   variable-pay/                  my variable pay register
#   deductions/                    my non-statutory deductions
#   loans/ , <id>/ , <id>/schedule/ , POST apply , POST <id>/cancel/
#   salary-structure/              company salary architecture + my breakup
#   ytd/?financial_year=2026-27    year-to-date totals from released payslips
# ============================================================
from decimal import Decimal

from django.db.models import Sum
from django.http import Http404, HttpResponse
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.routers import SimpleRouter
from rest_framework.viewsets import ViewSet

from Employee.models import Payroll

from . import engine as en
from .common import (EmployeeBase, check_file, err, f, file_url, get_setting, iso, money, month_label, month_year, ok,
                     paginate, q2, to_bool, to_decimal, to_int)
from .models import Loan, PayrollDeduction, PayrollInput, Payslip, VariablePay
from .views_admin import (cur_period, deduction_row, ensure_open, input_row, loan_row, loan_terms_check, variable_row)

PARSERS = [JSONParser, MultiPartParser, FormParser]


def fy_pairs(fy):
    try:
        a, b = str(fy).split("-")
        s = int(a)
        if (s + 1) % 100 != int(b):
            raise ValueError
    except (ValueError, AttributeError):
        raise ValueError("financial_year must look like 2026-27.")
    return s, [(s, m) for m in range(4, 13)] + [(s + 1, m) for m in range(1, 4)]


def fy_of(d):
    s = d.year if d.month >= 4 else d.year - 1
    return f"{s}-{str(s + 1)[2:]}"


class Base(EmployeeBase, ViewSet):
    parser_classes = PARSERS

    def released(self):
        return Payslip.objects.filter(company=self.company(), employee=self.me, status="RELEASED", is_active=True)


def slip_dict(s):
    return {"id": s.id, "payslip_no": s.payslip_no, "month": s.month, "year": s.year, "period": month_label(s.month, s.year),
            "gross_salary": f(s.gross_salary), "total_deductions": f(s.total_deductions), "net_payable": f(s.net_payable),
            "released_at": iso(s.released_at), "pdf_url": f"/employee/payroll-hub/payslips/{s.id}/pdf/"}


class MyPayslips(Base):
    def list(self, request):
        qs = self.released()
        fy = request.query_params.get("financial_year")
        try:
            if fy:
                _, pairs = fy_pairs(fy)
                from django.db.models import Q
                cond = Q()
                for y, m in pairs:
                    cond |= Q(year=y, month=m)
                qs = qs.filter(cond)
        except ValueError as e:
            return err("VALIDATION", str(e))
        rows, meta = paginate(request, qs, slip_dict)
        return ok("MY_PAYSLIPS", "My payslips.", rows, meta=meta)

    def retrieve(self, request, pk=None):
        s = self.released().filter(pk=pk).first() if str(pk).isdigit() else None
        if s is None:
            return err("NOT_FOUND", "Payslip not found.", 404)
        return ok("MY_PAYSLIP", "Payslip.", slip_dict(s) | {"earnings": s.breakup.get("earnings", []),
                                                           "deductions": s.breakup.get("deductions", [])})

    @action(detail=True, methods=["get"])
    def pdf(self, request, pk=None):
        s = self.released().filter(pk=pk).first() if str(pk).isdigit() else None
        if s is None:
            raise Http404("Payslip not found.")
        slip = {"period": month_label(s.month, s.year), "earnings": s.breakup.get("earnings", []),
                "deductions": s.breakup.get("deductions", []), "gross_salary": f(s.gross_salary),
                "total_deductions": f(s.total_deductions), "net_payable": f(s.net_payable)}
        resp = HttpResponse(en.payslip_pdf(self.company(), self.me, slip), content_type="application/pdf")
        resp["Content-Disposition"] = f'inline; filename="{s.payslip_no}.pdf"'
        return resp


class MyInputs(Base):
    """GET ?month= ?year= ?status= | POST {month?, year?, amount, label, remarks?, attachment?} reimbursement claim"""

    def _mine(self):
        return PayrollInput.objects.filter(company=self.company(), employee=self.me, is_active=True)

    def list(self, request):
        p = request.query_params
        qs = self._mine()
        for k in ("month", "year"):
            if p.get(k):
                qs = qs.filter(**{k: p[k]})
        if p.get("status"):
            qs = qs.filter(status=p["status"].upper())
        rows, meta = paginate(request, qs.exclude(input_type="LOP").select_related("employee"),
                              lambda i: input_row(i, request))
        return ok("MY_PAYROLL_INPUTS", "My payroll inputs.", rows, meta=meta)

    def create(self, request):
        c = self.company()
        if not get_setting(c).allow_employee_claims:
            return err("FORBIDDEN", "Reimbursement claims are not enabled for your company.", 403)
        d, t = request.data, timezone.localdate()
        try:
            m, y = month_year({"month": d.get("month") or t.month, "year": d.get("year") or t.year})
            ensure_open(c, m, y)
            amount = money(d, "amount", None, allow_zero=False)
            if amount is None:
                raise ValueError("amount is required.")
            label = str(d.get("label") or "").strip()
            if not label:
                raise ValueError("label is required (e.g. Travel Reimbursement).")
            i = PayrollInput(company=c, employee=self.me, month=m, year=y, input_type="REIMBURSEMENT",
                             label=label[:100], amount=amount, remarks=d.get("remarks") or None,
                             status="PENDING_REVIEW", source="EMPLOYEE", created_by=self.actor(),
                             updated_by=self.actor())
            fl = request.FILES.get("attachment")
            if fl is not None:
                check_file(fl)
                i.attachment = fl
            if self._mine().filter(month=m, year=y, input_type="REIMBURSEMENT", amount=amount,
                                   label__iexact=label).exists():
                raise ValueError("You have already submitted this claim.")
        except ValueError as e:
            return err("VALIDATION", str(e))
        i.save()
        return ok("MY_CLAIM_CREATED", "Claim submitted for review.", input_row(i, request), 201)

    def _one(self, pk):
        return self._mine().filter(pk=pk).first() if str(pk).isdigit() else None

    def retrieve(self, request, pk=None):
        i = self._one(pk)
        return ok("MY_PAYROLL_INPUT", "Input.", input_row(i, request)) if i else err("NOT_FOUND", "Not found.", 404)

    def partial_update(self, request, pk=None):
        i = self._one(pk)
        if i is None:
            return err("NOT_FOUND", "Not found.", 404)
        if i.source != "EMPLOYEE" or i.status != "PENDING_REVIEW":
            return err("LOCKED", "Only your own pending claims can be changed.", 403)
        d = request.data
        try:
            ensure_open(i.company, i.month, i.year)
            if "amount" in d:
                i.amount = money(d, "amount", None, allow_zero=False)
            for k in ("label", "remarks"):
                if k in d:
                    setattr(i, k, d[k] or None)
            fl = request.FILES.get("attachment")
            if fl is not None:
                check_file(fl)
                i.attachment = fl
        except ValueError as e:
            return err("VALIDATION", str(e))
        i.updated_by = self.actor()
        i.save()
        return ok("MY_CLAIM_UPDATED", "Claim updated.", input_row(i, request))

    update = partial_update

    def destroy(self, request, pk=None):
        i = self._one(pk)
        if i is None:
            return err("NOT_FOUND", "Not found.", 404)
        if i.source != "EMPLOYEE" or i.status != "PENDING_REVIEW":
            return err("LOCKED", "Only your own pending claims can be withdrawn.", 403)
        i.is_active = False
        i.save()
        return ok("MY_CLAIM_DELETED", "Claim withdrawn.", {"id": i.id})

    @action(detail=True, methods=["post"], url_path="update")
    def update_post(self, request, pk=None):
        return self.partial_update(request, pk)

    @action(detail=True, methods=["post"], url_path="delete")
    def delete_post(self, request, pk=None):
        return self.destroy(request, pk)


class MyVariablePay(Base):
    def list(self, request):
        qs = VariablePay.objects.filter(company=self.company(), employee=self.me, is_active=True).exclude(status="DRAFT")
        return ok("MY_VARIABLE_PAY", "My variable pay.", [variable_row(v, request) for v in qs.select_related("employee")])


class MyDeductions(Base):
    def list(self, request):
        qs = PayrollDeduction.objects.filter(company=self.company(), employee=self.me, is_active=True).exclude(
            status="PENDING_APPROVAL")
        return ok("MY_DEDUCTIONS", "My deductions.", [deduction_row(d, request) for d in qs.select_related("employee")])


class MyLoans(Base):
    parser_classes = [JSONParser, FormParser, MultiPartParser]

    def _mine(self):
        return Loan.objects.filter(company=self.company(), employee=self.me, is_active=True)

    def list(self, request):
        rows = [loan_row(l, request) for l in self._mine().select_related("employee")]
        act = [r for r in rows if r["status"] == "ACTIVE"]
        return ok("MY_LOANS", "My loans & advances.", rows, summary={
            "outstanding": round(sum(r["balance_remaining"] for r in act), 2),
            "monthly_emi": round(sum(r["monthly_emi"] for r in act), 2), "active": len(act)})

    def retrieve(self, request, pk=None):
        l = self._mine().filter(pk=pk).first() if str(pk).isdigit() else None
        return ok("MY_LOAN", "Loan.", loan_row(l, request, True)) if l else err("NOT_FOUND", "Not found.", 404)

    @action(detail=True, methods=["get"])
    def schedule(self, request, pk=None):
        return self.retrieve(request, pk)

    def create(self, request):
        c, d = self.company(), request.data
        st = get_setting(c)
        if not st.allow_employee_loan_requests:
            return err("FORBIDDEN", "Loan requests are not enabled for your company.", 403)
        try:
            l = Loan(company=c, employee=self.me, requested_by_employee=True, status="PENDING", created_by=self.actor(),
                     updated_by=self.actor())
            lt = str(d.get("loan_type") or "LOAN").upper()
            if lt not in dict(Loan.TYPES):
                raise ValueError("loan_type must be LOAN or SALARY_ADVANCE.")
            l.loan_type = lt
            l.principal = money(d, "principal", None, allow_zero=False)
            if l.principal is None:
                raise ValueError("principal is required.")
            l.tenure_months = to_int(d.get("tenure_months"), 0)
            l.interest_rate = Decimal("0")
            l.purpose = d.get("purpose") or None
            if d.get("start_month") or d.get("start_year"):
                l.start_month, l.start_year = month_year({"month": d.get("start_month"), "year": d.get("start_year")})
            loan_terms_check(l)
            if self._mine().filter(status="PENDING", loan_type=lt).exists():
                raise ValueError("You already have a pending request of this type.")
            l.loan_no = en.next_loan_no(c, timezone.localdate().year)
        except ValueError as e:
            return err("VALIDATION", str(e))
        l.save()
        return ok("MY_LOAN_REQUESTED", "Loan request submitted for approval.", loan_row(l, request), 201)

    @action(detail=True, methods=["post"])
    def cancel(self, request, pk=None):
        l = self._mine().filter(pk=pk).first() if str(pk).isdigit() else None
        if l is None:
            return err("NOT_FOUND", "Not found.", 404)
        if l.status != "PENDING":
            return err("LOCKED", "Only a pending request can be cancelled.", 403)
        l.status, l.updated_by = "CANCELLED", self.actor()
        l.save()
        return ok("MY_LOAN_CANCELLED", "Request cancelled.", loan_row(l, request))


class MySalaryStructure(Base):
    def list(self, request):
        c = self.company()
        last = Payroll.objects.filter(company=c, Employee_ID=self.me.employee_code).order_by("-year", "-month").first()
        mine = en.breakup(c, last.gross_salary) if last and last.gross_salary else None
        from .models import SalaryComponent
        return ok("MY_SALARY_STRUCTURE", "Salary structure.", {
            "components": [en.component_row(x) for x in SalaryComponent.objects.filter(company=c, is_active=True)],
            "my_breakup": mine, "based_on": month_label(last.month, last.year) if last else None})


class MyYtd(Base):
    def list(self, request):
        try:
            fy = request.query_params.get("financial_year") or fy_of(timezone.localdate())
            _, pairs = fy_pairs(fy)
        except ValueError as e:
            return err("VALIDATION", str(e))
        from django.db.models import Q
        cond = Q()
        for y, m in pairs:
            cond |= Q(year=y, month=m)
        qs = self.released().filter(cond)
        agg = qs.aggregate(g=Sum("gross_salary"), d=Sum("total_deductions"), n=Sum("net_payable"))
        ded = {}
        for s in qs:
            for d in s.breakup.get("deductions", []):
                ded[d["code"]] = round(ded.get(d["code"], 0) + d["amount"], 2)
        return ok("MY_YTD", "Year to date.", {"financial_year": fy, "payslips": qs.count(),
                                              "gross_salary": f(agg["g"]), "total_deductions": f(agg["d"]),
                                              "net_pay": f(agg["n"]), "deductions_by_code": ded})


class MyHome(Base):
    def list(self, request):
        last = self.released().first()
        loans = [loan_row(l, request) for l in Loan.objects.filter(company=self.company(), employee=self.me,
                                                                    is_active=True, status="ACTIVE")]
        return ok("MY_PAYROLL_HOME", "Payroll summary.", {
            "latest_payslip": slip_dict(last) if last else None,
            "loan_outstanding": round(sum(r["balance_remaining"] for r in loans), 2),
            "pending_claims": PayrollInput.objects.filter(company=self.company(), employee=self.me, is_active=True,
                                                          status="PENDING_REVIEW").count(),
            "pending_loan_requests": Loan.objects.filter(company=self.company(), employee=self.me, is_active=True,
                                                         status="PENDING").count()})


router = SimpleRouter()
router.register(r"home", MyHome, basename="emp-ph-home")
router.register(r"payslips", MyPayslips, basename="emp-ph-payslips")
router.register(r"inputs", MyInputs, basename="emp-ph-inputs")
router.register(r"variable-pay", MyVariablePay, basename="emp-ph-variable")
router.register(r"deductions", MyDeductions, basename="emp-ph-deductions")
router.register(r"loans", MyLoans, basename="emp-ph-loans")
router.register(r"salary-structure", MySalaryStructure, basename="emp-ph-structure")
router.register(r"ytd", MyYtd, basename="emp-ph-ytd")
urlpatterns = router.urls
