# ============================================================
# ADDITIVE tests - Employee self-service Assets (/employee/assets/) + asset read-leak fix
#   python manage.py test People.tests_employee_assets
# ============================================================
from datetime import date, timedelta
from decimal import Decimal

from django.test import override_settings
from django.utils import timezone
from rest_framework.test import APIClient, APITestCase

from Company.models import company_details
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People.models import AssetAllocation, AssetMaster, ExitClearance

A = "/api/people"
ME = "/employee/assets"
MEDIA = override_settings(MEDIA_ROOT="/tmp/emp_assets_test_media")


@MEDIA
class EmployeeAssetTests(APITestCase):
    def mk_company(self, n):
        return company_details.objects.create(email=f"ea{n}@x.com", password="pw", contact_no=f"93000000{n:02d}",
                                             status=True, is_verified=True, Registered_Company_Name="Zenith Corp",
                                             Company_address="Pune")

    def mk_emp(self, company, code, name, role=None):
        e = EmployeeDT.objects.create(company=company, employee_code=code, name=name, email=f"{code}@x.com",
                                      Designation="Engineer", Date_of_Joining=date(2023, 1, 10),
                                      Basic_Salary=Decimal("60000"))
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def mk_asset(self, company, tag, emp=None, **kw):
        a = AssetMaster.objects.create(company=company, asset_tag=tag, device_name=f"Dev {tag}", category="Laptop",
                                       serial_number=f"SN-{tag}", purchase_cost=Decimal("99999"), vendor="SecretVendor",
                                       notes="internal-note", status="Available")
        if emp is None:
            return a, None
        a.status = "Allocated"
        a.save()
        al = AssetAllocation.objects.create(company=company, asset=a, employee=emp, **kw)
        return a, al

    def setUp(self):
        self.co, self.other = self.mk_company(1), self.mk_company(2)
        # role defaults reproduce the production leak: can_view_employees defaults to True
        self.basic_role = EmployeeRole.objects.create(company=self.co, role_name="employee", role_code="employee")
        self.hr_role = EmployeeRole.objects.create(
            company=self.co, role_name="HR", role_code="hr", can_view_employees=True, can_create_employees=True,
            can_edit_employees=True, can_delete_employees=True)
        self.view_only = EmployeeRole.objects.create(company=self.co, role_name="V", role_code="v",
                                                     can_view_employees=True, can_create_employees=False,
                                                     can_edit_employees=False, can_delete_employees=False)
        self.me = self.mk_emp(self.co, "EMP1001", "Me Employee", role=self.basic_role)
        self.colleague = self.mk_emp(self.co, "EMP1002", "Colleague", role=self.basic_role)
        self.norole = self.mk_emp(self.co, "EMP1003", "No Role")
        self.hr = self.mk_emp(self.co, "EMP1004", "HR Person", role=self.hr_role)
        self.viewer = self.mk_emp(self.co, "EMP1005", "Viewer", role=self.view_only)
        self.outsider = self.mk_emp(self.other, "EMP2001", "Outsider")

        self.admin = client_for(company_token(self.co))
        self.me_c = client_for(employee_token(self.me))
        self.col_c = client_for(employee_token(self.colleague))
        self.norole_c = client_for(employee_token(self.norole))
        self.hr_c = client_for(employee_token(self.hr))
        self.view_c = client_for(employee_token(self.viewer))
        self.out_c = client_for(employee_token(self.outsider))
        self.other_admin = client_for(company_token(self.other))

        self.a1, self.al1 = self.mk_asset(self.co, "LT-001", self.me, allocated_on=date(2026, 1, 5),
                                          condition_out="Good")
        self.a2, self.al2 = self.mk_asset(self.co, "LT-002", self.colleague, allocated_on=date(2026, 2, 1))
        self.a3, self.al3 = self.mk_asset(self.other, "LT-001", self.outsider)

    # ------------- Fix A: admin asset APIs closed to ordinary employees -------------
    def test_ES01_to_05_basic_employee_cannot_read_company_inventory(self):
        for u in ("assets/", "asset-allocations/", "asset-returns/", "asset-history/", "assets/summary/",
                  "assets/options/", "assets/export/"):
            self.assertEqual(self.me_c.get(f"{A}/{u}").status_code, 403, u)
            self.assertEqual(self.view_c.get(f"{A}/{u}").status_code, 403, u)       # view-only role also blocked
            self.assertEqual(self.norole_c.get(f"{A}/{u}").status_code, 403, u)
            self.assertEqual(APIClient().get(f"{A}/{u}").status_code, 401, u)

    def test_ES06_basic_employee_cannot_write(self):
        r = self.me_c.post(f"{A}/assets/", {"asset_tag": "X1", "device_name": "x"}, format="json")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(self.me_c.post(f"{A}/assets/{self.a2.id}/assign/", {"employee_code": "EMP1001"},
                                        format="json").status_code, 403)
        self.assertEqual(self.me_c.post(f"{A}/asset-returns/receive-all/", {"employee_code": "EMP1002"},
                                        format="json").status_code, 403)
        self.assertEqual(self.me_c.delete(f"{A}/assets/{self.a1.id}/").status_code, 403)

    def test_admin_and_hr_still_work(self):
        for c in (self.admin, self.hr_c):
            for u in ("assets/", "asset-allocations/", "asset-returns/", "asset-history/", "assets/summary/",
                      "assets/options/", "assets/export/"):
                self.assertEqual(c.get(f"{A}/{u}").status_code, 200, u)
        r = self.hr_c.post(f"{A}/assets/", {"asset_tag": "HR-1", "device_name": "HR laptop"}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual(self.admin.get(f"{A}/assets/").json()["meta"]["total"], 3)   # 2 seeded + HR-1

    # ------------- Fix B: employee side -------------
    def test_auth_required(self):
        for u in ("/", "/summary/", "/pending-returns/", "/history/", f"/{self.al1.id}/"):
            self.assertEqual(APIClient().get(ME + u).status_code, 401, u)
            self.assertEqual(APIClient().get(ME + u.replace("/", "/", 1)).status_code, 401)
        self.assertEqual(APIClient().post(f"{ME}/{self.al1.id}/acknowledge/").status_code, 401)
        # a Company-admin token is not an employee token
        self.assertIn(self.admin.get(ME + "/").status_code, (401, 403))

    def test_ES21_list_only_my_rows_and_no_sensitive_fields(self):
        r = self.me_c.get(ME + "/")
        self.assertEqual(r.status_code, 200, r.content)
        body = r.json()
        self.assertEqual(body["meta"]["total"], 1)
        row = body["data"][0]
        self.assertEqual(row["asset_tag"], "LT-001")
        self.assertEqual(row["display_status"], "Awaiting Acknowledgement")
        self.assertTrue(row["can_acknowledge"])
        # ES-27: nothing sensitive
        flat = str(body)
        for secret in ("purchase_cost", "99999", "SecretVendor", "internal-note", "Colleague", "EMP1002", "vendor"):
            self.assertNotIn(secret, flat)

    def test_ES22_no_idor_query_params(self):
        r = self.me_c.get(ME + "/?employee=EMP1002&employee_code=EMP1002&company=2")
        self.assertEqual(r.json()["meta"]["total"], 1)
        self.assertEqual(r.json()["data"][0]["asset_tag"], "LT-001")

    def test_ES23_colleague_allocation_is_404(self):
        self.assertEqual(self.me_c.get(f"{ME}/{self.al2.id}/").status_code, 404)
        self.assertEqual(self.me_c.post(f"{ME}/{self.al2.id}/acknowledge/").status_code, 404)
        self.assertEqual(self.me_c.get(f"{ME}/{self.al1.id}/").status_code, 200)

    def test_ES24_hr_sees_only_own_assets_here(self):
        self.mk_asset(self.co, "HR-LT", self.hr)
        r = self.hr_c.get(ME + "/")
        self.assertEqual([x["asset_tag"] for x in r.json()["data"]], ["HR-LT"])

    def test_ES25_acknowledge_and_conflict(self):
        r = self.me_c.post(f"{ME}/{self.al1.id}/acknowledge/", {"note": "Received with charger"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        d = r.json()["data"]
        self.assertTrue(d["acknowledged"])
        self.assertIsNotNone(d["acknowledged_on"])
        self.assertEqual(d["display_status"], "Assigned")
        self.assertFalse(d["can_acknowledge"])
        self.al1.refresh_from_db()
        self.assertEqual(self.al1.acknowledged_note, "Received with charger")
        self.assertEqual(self.me_c.post(f"{ME}/{self.al1.id}/acknowledge/").status_code, 409)

    def test_acknowledge_bad_bodies_and_returned(self):
        self.assertEqual(self.me_c.post(f"{ME}/{self.al1.id}/acknowledge/", ["x"], format="json").status_code, 200)
        r = self.me_c.post(f"{ME}/{self.al1.id}/acknowledge/", {"note": "x" * 300}, format="json")
        self.assertIn(r.status_code, (400, 409))
        _, ret = self.mk_asset(self.co, "LT-009", self.me)
        ret.status, ret.returned_on = "Returned", timezone.localdate()
        ret.save()
        self.assertEqual(self.me_c.post(f"{ME}/{ret.id}/acknowledge/").status_code, 409)

    def test_ES26_hr_return_request_visible_to_employee(self):
        due = (timezone.localdate() + timedelta(days=5)).isoformat()
        r = self.hr_c.post(f"{A}/asset-returns/request/", {"employee_code": "EMP1001", "due_date": due,
                                                          "reason": "Upgrade cycle"}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        row = self.me_c.get(ME + "/").json()["data"][0]
        self.assertTrue(row["return_pending"])
        self.assertEqual(row["return_due_date"], due)
        self.assertEqual(row["return_reason"], "Upgrade cycle")
        self.assertEqual(row["display_status"], "Return Pending")
        self.assertEqual(self.me_c.get(ME + "/pending-returns/").json()["meta"]["total"], 1)
        self.assertEqual(self.me_c.get(ME + "/summary/").json()["data"]["pending_return"], 1)
        self.assertEqual(self.me_c.get(ME + "/?status=pending_return").json()["meta"]["total"], 1)
        self.assertEqual(self.col_c.get(ME + "/pending-returns/").json()["meta"]["total"], 0)

    def test_ES28_received_asset_moves_to_returned(self):
        self.hr_c.post(f"{A}/asset-returns/request/", {"employee_code": "EMP1001", "reason": "x"}, format="json")
        r = self.hr_c.post(f"{A}/asset-returns/receive-all/", {"employee_code": "EMP1001"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(self.me_c.get(ME + "/?status=assigned").json()["meta"]["total"], 0)
        hist = self.me_c.get(ME + "/history/").json()
        self.assertEqual(hist["meta"]["total"], 1)
        self.assertEqual(hist["data"][0]["display_status"], "Returned")
        s = self.me_c.get(ME + "/summary/").json()["data"]
        self.assertEqual((s["assigned"], s["returned"], s["pending_return"]), (0, 1, 0))

    def test_ES29_exit_lists_pending_assets_with_last_working_day(self):
        lwd = timezone.localdate() + timedelta(days=20)
        ExitClearance.objects.create(company=self.co, employee=self.me, status="In Progress", last_working_day=lwd)
        row = self.me_c.get(ME + "/").json()["data"][0]
        self.assertTrue(row["return_pending"])
        self.assertEqual(row["return_due_date"], lwd.isoformat())
        s = self.me_c.get(ME + "/summary/").json()["data"]
        self.assertTrue(s["in_exit_process"])
        self.assertEqual(s["pending_return"], 1)
        self.assertEqual(self.me_c.get(ME + "/pending-returns/").json()["meta"]["total"], 1)
        # the colleague is not in exit
        self.assertFalse(self.col_c.get(ME + "/summary/").json()["data"]["in_exit_process"])

    def test_ES30_cross_company_isolation(self):
        self.assertEqual(self.out_c.get(ME + "/").json()["meta"]["total"], 1)
        self.assertEqual(self.out_c.get(ME + "/").json()["data"][0]["asset_id"], self.a3.id)
        for al in (self.al1, self.al2):
            self.assertEqual(self.out_c.get(f"{ME}/{al.id}/").status_code, 404)
            self.assertEqual(self.out_c.post(f"{ME}/{al.id}/acknowledge/").status_code, 404)

    def test_filters_search_and_bad_status(self):
        self.assertEqual(self.me_c.get(ME + "/?status=bogus").status_code, 400)
        self.assertEqual(self.me_c.get(ME + "/?search=LT-001").json()["meta"]["total"], 1)
        self.assertEqual(self.me_c.get(ME + "/?search=nothing").json()["meta"]["total"], 0)
        self.assertEqual(self.me_c.get(ME + "/?status=unacknowledged").json()["meta"]["total"], 1)
        for q in ("?page_size=abc", "?page=0", "?page=999"):
            self.assertEqual(self.me_c.get(ME + "/" + q).status_code, 200, q)
        self.assertEqual(self.me_c.get(ME + "/999999/").status_code, 404)

    def test_soft_deleted_asset_hidden(self):
        self.a1.is_active = False
        self.a1.save()
        self.assertEqual(self.me_c.get(ME + "/").json()["meta"]["total"], 0)

    def test_summary_counts(self):
        s = self.me_c.get(ME + "/summary/").json()["data"]
        self.assertEqual((s["assigned"], s["returned"], s["pending_return"], s["awaiting_acknowledgement"]),
                         (1, 0, 0, 1))
