# ============================================================
# ADDITIVE tests - Leave Management & WFH engine
#   python manage.py test Employee.tests_leave_hub
# ============================================================

from datetime import timedelta
from decimal import Decimal

from django.utils import timezone
from rest_framework.test import APIClient, APITestCase
from rest_framework_simplejwt.tokens import RefreshToken

from Company.models import company_details
from Employee.leave_models import (
    ApprovalAction, ApprovalWorkflowStep, LeaveBalance, ReportingHierarchy, WFHRequest,
)
from Employee.models import (
    AttendanceEmp, EmployeeAccount, EmployeeDT, EmployeeRole, LeaveRequest,
)

HUB = "/api/leave-hub"
ME = "/employee/leave"


def company_token(company):
    t = RefreshToken()
    t["type"] = "company"
    t["user_id"] = company.company_id
    return str(t.access_token)


def employee_token(emp):
    t = RefreshToken()
    t["type"] = "employee"
    t["user_id"] = emp.employee_code
    t["employee_id"] = emp.employee_code
    t["company_id"] = emp.company.company_id
    return str(t.access_token)


def client_for(token):
    c = APIClient()
    c.credentials(HTTP_AUTHORIZATION=f"Bearer {token}")
    return c


def next_workday(offset):
    d = timezone.localdate() + timedelta(days=offset)
    while d.weekday() == 6:
        d += timedelta(days=1)
    return d


def next_monday(min_days_ahead=4):
    d = timezone.localdate() + timedelta(days=min_days_ahead)
    while d.weekday() != 0:
        d += timedelta(days=1)
    return d


class LeaveHubBase(APITestCase):

    def mk_company(self, n):
        return company_details.objects.create(
            email=f"c{n}@x.com", password="pw", contact_no=f"90000000{n:02d}",
            status=True, is_verified=True)

    def mk_emp(self, company, name, role=None, n=0):
        e = EmployeeDT.objects.create(
            company=company, name=name, email=f"{name.lower()}{n}@x.com")
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        self.company = self.mk_company(1)
        self.other = self.mk_company(2)

        self.hr_role = EmployeeRole.objects.create(
            company=self.company, role_name="HR", role_code="hr",
            can_view_leave=True, can_create_leave=True, can_approve_leave=True)
        self.view_role = EmployeeRole.objects.create(
            company=self.company, role_name="Viewer", role_code="viewer",
            can_view_leave=True)

        self.emp = self.mk_emp(self.company, "Rahul", n=1)
        self.mgr = self.mk_emp(self.company, "Manager", n=2)
        self.hod = self.mk_emp(self.company, "Hod", n=3)
        self.hr = self.mk_emp(self.company, "Hrperson", role=self.hr_role, n=4)
        self.viewer = self.mk_emp(self.company, "Viewer", role=self.view_role, n=5)
        self.stranger = self.mk_emp(self.company, "Stranger", n=6)
        self.alien = self.mk_emp(self.other, "Alien", n=7)

        ReportingHierarchy.objects.create(
            company=self.company, Employee_ID=self.emp.employee_code,
            manager_code=self.mgr.employee_code, hod_code=self.hod.employee_code)

        self.admin = client_for(company_token(self.company))
        self.c_emp = client_for(employee_token(self.emp))
        self.c_mgr = client_for(employee_token(self.mgr))
        self.c_hod = client_for(employee_token(self.hod))
        self.c_hr = client_for(employee_token(self.hr))
        self.c_view = client_for(employee_token(self.viewer))
        self.c_stranger = client_for(employee_token(self.stranger))
        self.c_alien = client_for(employee_token(self.alien))

    # helper
    def apply_leave(self, leave_type="Casual Leave", offset=10, days=1, client=None):
        start = next_workday(offset)
        r = (client or self.c_emp).post(f"{ME}/leaves/", {
            "leave_type": leave_type, "from_date": str(start),
            "to_date": str(start + timedelta(days=days - 1)), "reason": "test"},
            format="json")
        return r


class LeaveWorkflowTests(LeaveHubBase):

    def test_apply_and_full_three_tier_approval(self):
        r = self.apply_leave()
        self.assertEqual(r.status_code, 201, r.data)
        data = r.data["data"]
        self.assertEqual(data["status"], "Pending")
        self.assertEqual([p["approver_type"] for p in data["pipeline"]],
                         ["reporting_manager", "hod", "hr"])
        self.assertEqual(data["current_tier"], "Manager Review")
        lid = data["id"]

        # a stranger / the requester cannot approve
        ap_id = data["pipeline"][0]["id"]
        self.assertEqual(self.c_stranger.post(
            f"{ME}/approvals/{ap_id}/approve/").status_code, 404)
        self.assertEqual(self.c_emp.post(
            f"{ME}/approvals/{ap_id}/approve/").status_code, 404)

        # HOD cannot jump the queue
        hod_tier = data["pipeline"][1]["id"]
        self.assertEqual(self.c_hod.post(
            f"{ME}/approvals/{hod_tier}/approve/").status_code, 409)

        # manager queue shows it
        q = self.c_mgr.get(f"{ME}/approvals/pending/")
        self.assertEqual(len(q.data["data"]), 1)

        r = self.c_mgr.post(f"{ME}/approvals/{ap_id}/approve/", {"review_comment": "ok"},
                            format="json")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertIsNone(r.data["data"]["final"])
        self.assertEqual(r.data["data"]["current_tier"], "HOD Review")

        r = self.c_hod.post(f"{ME}/approvals/{hod_tier}/approve/")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(r.data["data"]["current_tier"], "HR Ops Review")

        # last tier: HR role employee through the hub
        r = self.c_hr.post(f"{HUB}/leave-requests/{lid}/approve/")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(r.data["data"]["final"], "Approved")
        self.assertEqual(LeaveRequest.objects.get(pk=lid).status, "Approved")
        self.assertTrue(AttendanceEmp.objects.filter(
            Employee_ID=self.emp.employee_code, status="Casual Leave").exists())

        # balance now shows 1 used
        b = self.c_emp.get(f"{ME}/balances/").data["data"]["balances"]
        cl = next(x for x in b if x["leave_type"] == "Casual Leave")
        self.assertEqual(cl["used"], Decimal("1.0"))
        self.assertEqual(cl["remaining"], Decimal("11.0"))

    def test_reject_at_first_tier(self):
        lid = self.apply_leave().data["data"]["id"]
        ap = ApprovalAction.objects.filter(request_id=lid, request_type="leave").first()
        r = self.c_mgr.post(f"{ME}/approvals/{ap.pk}/reject/", {"review_comment": "no"},
                            format="json")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(LeaveRequest.objects.get(pk=lid).status, "Rejected")
        self.assertFalse(ApprovalAction.objects.filter(
            request_id=lid, request_type="leave", status="Pending").exists())

    def test_insufficient_balance_overlap_and_edit_cancel_delete(self):
        r = self.apply_leave(days=15)               # ~13 working days > 12 CL
        self.assertEqual(r.status_code, 409, r.data)
        self.assertEqual(r.data["code"], "insufficient_balance")

        r = self.apply_leave(offset=12)
        self.assertEqual(r.status_code, 201)
        lid = r.data["data"]["id"]
        self.assertEqual(self.apply_leave(offset=12).status_code, 409)   # overlap

        d = next_workday(20)
        r = self.c_emp.patch(f"{ME}/leaves/{lid}/", {
            "from_date": str(d), "to_date": str(d)}, format="json")
        self.assertEqual(r.status_code, 200, r.data)

        r = self.c_emp.post(f"{ME}/leaves/{lid}/cancel/")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(r.data["data"]["status"], "Cancelled")

        lid2 = self.apply_leave(offset=30).data["data"]["id"]
        self.assertEqual(self.c_emp.delete(f"{ME}/leaves/{lid2}/").status_code, 200)
        self.assertFalse(LeaveRequest.objects.filter(pk=lid2).exists())

        # others cannot see my leave
        self.assertEqual(self.c_stranger.get(f"{ME}/leaves/{lid}/").status_code, 404)

    def test_custom_workflow_and_reset(self):
        r = self.admin.post(f"{HUB}/workflow-steps/", {
            "request_type": "leave", "step_order": 1, "name": "Manager",
            "approver_type": "reporting_manager", "sla_hours": 6}, format="json")
        self.assertEqual(r.status_code, 201, r.data)
        self.assertEqual(self.admin.post(f"{HUB}/workflow-steps/", {
            "request_type": "leave", "step_order": 1, "name": "X",
            "approver_type": "hod"}, format="json").status_code, 409)

        chain = self.admin.get(f"{HUB}/workflow/?request_type=leave").data["data"]["chains"]["leave"]
        self.assertEqual(len(chain), 2)          # submission + 1 custom step

        d = self.apply_leave().data["data"]
        self.assertEqual(len(d["pipeline"]), 1)

        r = self.admin.post(f"{HUB}/workflow/reset/", {"request_type": "leave"}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(len(r.data["data"]["chain"]), 4)
        self.assertEqual(ApprovalWorkflowStep.objects.count(), 0)

    def test_legacy_admin_approve_still_works_and_pipeline_resolves(self):
        lid = self.apply_leave().data["data"]["id"]
        r = self.admin.post(f"/api/leaves/{lid}/approve/")           # pre-existing endpoint
        self.assertEqual(r.status_code, 200, r.data)
        row = self.admin.get(f"{HUB}/leave-requests/{lid}/").data["data"]
        self.assertEqual(row["status"], "Approved")
        self.assertTrue(all(p["status"] == "Approved" for p in row["pipeline"]))
        # existing list endpoint untouched
        self.assertEqual(self.admin.get("/api/leaves/").status_code, 200)
        self.assertEqual(self.admin.get("/api/leaves/summary/").status_code, 200)


class WFHTests(LeaveHubBase):

    def test_notice_quota_and_approval(self):
        # same-day is below the 24h notice
        r = self.c_emp.post(f"{ME}/wfh/", {"wfh_date": str(timezone.localdate())}, format="json")
        self.assertEqual(r.status_code, 400, r.data)

        mon = next_monday()
        ids = []
        for i in range(2):
            r = self.c_emp.post(f"{ME}/wfh/", {
                "wfh_date": str(mon + timedelta(days=i)), "reason": "focus"}, format="json")
            self.assertEqual(r.status_code, 201, r.data)
            ids.append(r.data["data"]["id"])
        self.assertEqual(r.data["data"]["weekly_quota_status"]["label"],
                         "2/2 Days Used (0 Left)")

        r = self.c_emp.post(f"{ME}/wfh/", {"wfh_date": str(mon + timedelta(days=2))},
                            format="json")
        self.assertEqual(r.status_code, 409)
        self.assertEqual(r.data["code"], "wfh_quota_exceeded")
        # duplicate date
        r = self.c_emp.post(f"{ME}/wfh/", {"wfh_date": str(mon)}, format="json")
        self.assertEqual(r.status_code, 409)

        # approvals through manager -> hod -> admin
        wid = ids[0]
        acts = list(ApprovalAction.objects.filter(
            request_type="wfh", request_id=wid).order_by("step_order"))
        self.assertEqual(self.c_mgr.post(f"{ME}/approvals/{acts[0].pk}/approve/").status_code, 200)
        self.assertEqual(self.c_hod.post(f"{ME}/approvals/{acts[1].pk}/approve/").status_code, 200)
        r = self.admin.post(f"{HUB}/wfh-requests/{wid}/approve/")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(WFHRequest.objects.get(pk=wid).status, "Approved")

        # admin list shows the table fields
        rows = self.admin.get(f"{HUB}/wfh-requests/").data["data"]
        self.assertEqual(rows["pipeline_count"], 1)
        first = rows["requests"][-1] if rows["requests"][0]["id"] != wid else rows["requests"][0]
        self.assertIn("notice_validation", first)

    def test_admin_crud_and_policy(self):
        mon = next_monday()
        r = self.admin.post(f"{HUB}/wfh-requests/", {
            "Employee_ID": self.emp.employee_code, "wfh_date": str(mon),
            "reason": "x", "auto_approve": True}, format="json")
        self.assertEqual(r.status_code, 201, r.data)
        wid = r.data["data"]["id"]
        self.assertEqual(r.data["data"]["status"], "Approved")

        # not editable once approved
        self.assertEqual(self.admin.patch(f"{HUB}/wfh-requests/{wid}/", {
            "reason": "y"}, format="json").status_code, 409)

        r = self.admin.patch(f"{HUB}/wfh-policy/", {"weekly_quota_days": 1}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(r.data["data"]["cards"]["weekly_wfh_allowance"], "1 Days")
        r = self.c_emp.post(f"{ME}/wfh/", {"wfh_date": str(mon + timedelta(days=1))},
                            format="json")
        self.assertEqual(r.status_code, 409)

        r = self.admin.delete(f"{HUB}/wfh-policy/")
        self.assertEqual(r.data["data"]["weekly_quota_days"], 2)

        self.assertEqual(self.admin.delete(f"{HUB}/wfh-requests/{wid}/").status_code, 200)
        # unknown / other-company employee
        r = self.admin.post(f"{HUB}/wfh-requests/", {
            "Employee_ID": self.alien.employee_code, "wfh_date": str(mon)}, format="json")
        self.assertEqual(r.status_code, 404)


class ConfigTests(LeaveHubBase):

    def test_policies_crud_and_framework(self):
        r = self.admin.get(f"{HUB}/policies/")
        self.assertEqual(len(r.data["data"]), 4)
        pl = next(p for p in r.data["data"] if p["code"] == "PL")
        r = self.admin.patch(f"{HUB}/policies/{pl['id']}/", {"annual_quota": "20"}, format="json")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(self.admin.post(f"{HUB}/policies/", {
            "leave_type": "Paid Leave"}, format="json").status_code, 409)
        fw = self.admin.get(f"{HUB}/policies/framework/").data["data"]["policies"]
        self.assertEqual([p["no"] for p in fw], [1, 2, 3, 4])
        self.assertEqual(self.admin.delete(f"{HUB}/policies/{pl['id']}/").status_code, 200)
        # employee reads it
        self.assertEqual(self.c_emp.get(f"{ME}/policies/").status_code, 200)

    def test_balances_allocations_and_initialize(self):
        code = self.emp.employee_code
        r = self.admin.get(f"{HUB}/balances/?employee_id={code}")
        self.assertEqual(r.status_code, 200, r.data)
        by = {b["code"]: b for b in r.data["data"]["balances"]}
        self.assertEqual((by["PL"]["total"], by["CL"]["total"], by["SL"]["total"]),
                         (Decimal("18.0"), Decimal("12.0"), Decimal("10.0")))
        fy = r.data["data"]["financial_year"]

        r = self.admin.post(f"{HUB}/balance-allocations/", {
            "Employee_ID": code, "leave_type": "Casual Leave", "financial_year": fy,
            "allocated": "12", "carried_forward": "0", "adjustment": "3"}, format="json")
        self.assertEqual(r.status_code, 201, r.data)
        rid = r.data["data"]["id"]
        self.assertEqual(self.admin.post(f"{HUB}/balance-allocations/", {
            "Employee_ID": code, "leave_type": "Casual Leave", "financial_year": fy,
            "allocated": "1"}, format="json").status_code, 409)
        by = {b["code"]: b for b in self.admin.get(
            f"{HUB}/balances/?employee_id={code}").data["data"]["balances"]}
        self.assertEqual(by["CL"]["total"], Decimal("15.0"))

        self.assertEqual(self.admin.patch(f"{HUB}/balance-allocations/{rid}/", {
            "adjustment": "-2"}, format="json").status_code, 200)
        self.assertEqual(self.admin.patch(f"{HUB}/balance-allocations/{rid}/", {
            "Employee_ID": self.mgr.employee_code}, format="json").status_code, 400)
        self.assertEqual(self.admin.delete(f"{HUB}/balance-allocations/{rid}/").status_code, 200)

        r = self.admin.post(f"{HUB}/balances/initialize/", {"financial_year": fy}, format="json")
        self.assertEqual(r.status_code, 200, r.data)
        self.assertEqual(r.data["data"]["created"], 6 * 3)       # 6 active employees x PL/CL/SL
        self.assertEqual(LeaveBalance.objects.filter(company=self.company).count(), 18)

        r = self.admin.get(f"{HUB}/balances/?financial_year={fy}")
        self.assertEqual(r.data["data"]["total_employees"], 6)

    def test_hierarchy_crud(self):
        code = self.stranger.employee_code
        r = self.admin.post(f"{HUB}/hierarchy/", {
            "Employee_ID": code, "manager_code": self.mgr.employee_code,
            "hod_code": self.hod.employee_code}, format="json")
        self.assertEqual(r.status_code, 201, r.data)
        hid = r.data["data"]["id"]
        self.assertEqual(r.data["data"]["manager"]["name"], "Manager")
        self.assertEqual(self.admin.post(f"{HUB}/hierarchy/", {
            "Employee_ID": code}, format="json").status_code, 409)
        self.assertEqual(self.admin.patch(f"{HUB}/hierarchy/{hid}/", {
            "manager_code": code}, format="json").status_code, 400)       # self as manager
        self.assertEqual(self.admin.patch(f"{HUB}/hierarchy/{hid}/", {
            "hod_code": self.alien.employee_code}, format="json").status_code, 404)  # other company
        self.assertEqual(self.admin.delete(f"{HUB}/hierarchy/{hid}/").status_code, 200)

    def test_calendar_dashboard_and_pending_queue(self):
        lid = self.apply_leave(offset=2).data["data"]["id"]
        self.admin.post(f"{HUB}/leave-requests/{lid}/approve/")          # tier 1 as admin
        d = self.admin.get(f"{HUB}/dashboard/").data["data"]
        self.assertEqual(d["cards"]["total_requests"]["value"], 1)
        self.assertEqual(d["cards"]["pending_approvals"]["value"], 1)
        self.assertEqual(len(d["requests"]), 1)
        self.assertEqual(d["requests"][0]["request_ref"], f"LEV-{lid}")

        q = self.admin.get(f"{HUB}/approvals/pending/").data["data"]
        self.assertEqual(len(q), 1)

        self.admin.post(f"{HUB}/leave-requests/{lid}/approve/")
        self.admin.post(f"{HUB}/leave-requests/{lid}/approve/")          # final
        start = timezone.localdate()
        cal = self.admin.get(f"{HUB}/calendar/?start_date={start}&end_date={start + timedelta(days=10)}")
        self.assertEqual(cal.status_code, 200, cal.data)
        days = cal.data["data"]["days"]
        self.assertTrue(any(x["on_leave_count"] for x in days))
        self.assertTrue(days[0]["is_today"])

        mine = self.c_stranger.get(f"{ME}/calendar/?start_date={start}&end_date={start + timedelta(days=10)}")
        self.assertEqual(mine.status_code, 200, mine.data)
        self.assertTrue(any(x["on_leave_count"] for x in mine.data["data"]["days"]))
        self.assertIsNone(next(x for x in mine.data["data"]["days"]
                               if x["on_leave"])["on_leave"][0]["reason"])   # reasons hidden

        self.assertEqual(self.c_emp.get(f"{ME}/dashboard/").status_code, 200)
        self.assertEqual(self.c_emp.get(f"{ME}/workflow/").status_code, 200)


class PermissionTests(LeaveHubBase):

    def test_roles_and_isolation(self):
        # no token
        self.assertEqual(APIClient().get(f"{HUB}/dashboard/").status_code, 401)
        # employee without role -> 403 on the hub
        self.assertEqual(self.c_stranger.get(f"{HUB}/dashboard/").status_code, 403)
        # view-only role can read but not write config
        self.assertEqual(self.c_view.get(f"{HUB}/policies/").status_code, 200)
        r = self.c_view.post(f"{HUB}/policies/", {"leave_type": "Paid Leave"}, format="json")
        self.assertEqual(r.status_code, 403)
        # HR role (approve flag) can edit config
        self.assertEqual(self.c_hr.patch(f"{HUB}/wfh-policy/", {
            "advance_notice_hours": 12}, format="json").status_code, 200)
        # admin token on employee endpoints is rejected
        self.assertIn(self.admin.get(f"{ME}/dashboard/").status_code, (401, 403))
        # cross-company: alien cannot touch my company's leave
        lid = self.apply_leave().data["data"]["id"]
        self.assertEqual(self.c_alien.get(f"{ME}/leaves/{lid}/").status_code, 404)
        self.assertEqual(self.c_alien.get(f"{ME}/approvals/pending/").data["data"], [])
