# Flow tests for Corporate Asset Tracking & Inventory (Asset Master / Allocation / Return / History).
#   python manage.py test People.tests_assets
from datetime import timedelta

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

from Company.models import company_details
from Employee.models import Department

from .models import AssetAllocation, AssetMaintenance, AssetMaster

MEDIA = override_settings(MEDIA_ROOT="/tmp/people_test_media")
B = "/api/people/"


def mk_company(email):
    return company_details.objects.create(email=email, password="x", contact_no=str(abs(hash(email)))[:10],
                                          Registered_Company_Name="Zenith Corp", Company_address="Pune")


@MEDIA
class AssetTrackingTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("a@x.com"), mk_company("b@x.com")
        self.c = APIClient()
        self.c.force_authenticate(user=self.co)
        self.o = APIClient()
        self.o.force_authenticate(user=self.other)
        Department.objects.create(company=self.co, name="Technology")
        mk = lambda n, e: self.c.post(B + "directory/", {"name": n, "email": e, "department": "Technology",
                                                         "designation": "Engineer", "date_of_joining": "2020-01-01"},
                                      format="json").json()["data"]["employee_code"]
        self.rahul, self.rohan, self.vikram = mk("Rahul Sharma", "r@x.com"), mk("Rohan Kulkarni", "ro@x.com"), mk("Vikram Rao", "v@x.com")

    def P(self, url, data=None, c=None):
        return (c or self.c).post(B + url, data or {}, format="json")

    def G(self, url, c=None):
        return (c or self.c).get(B + url)

    def reg(self, tag, name="MacBook", cat="Laptop", **kw):
        r = self.P("assets/", {"asset_tag": tag, "device_name": name, "category": cat, **kw})
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]

    # ---------------- Asset Master ----------------
    def test_master_crud_and_duplicates(self):
        a = self.reg("AST-MBP-0142", serial_number="C02G8493MD6R", vendor="Apple", warranty_until="2027-03-01")
        self.assertEqual(a["display_status"], "Available")
        self.assertEqual(a["warranty_status"], "Active")
        self.assertEqual(self.P("assets/", {"asset_tag": "ast-mbp-0142", "device_name": "x"}).status_code, 400)   # dup tag
        r = self.P("assets/", {"asset_tag": "AST-NEW", "device_name": "x", "serial_number": "c02g8493md6r"})      # dup serial
        self.assertEqual(r.status_code, 400)
        self.assertIn("Serial", r.json()["message"])
        self.assertEqual(self.P("assets/", {"asset_tag": "AST-Z", "device_name": "x", "category": "Rocket"}).status_code, 400)
        self.assertEqual(self.P("assets/", {"asset_tag": "AST-R", "device_name": "x", "status": "Reserved"}).status_code, 400)
        u = self.P(f"assets/{a['id']}/update/", {"vendor": "Apple India", "notes": "n"}).json()["data"]
        self.assertEqual(u["vendor"], "Apple India")
        self.assertEqual(self.G("assets/?search=C02G").json()["meta"]["total"], 1)
        self.assertEqual(self.G("assets/?category=Monitor").json()["meta"]["total"], 0)
        self.assertEqual(self.G("assets/", self.o).json()["meta"]["total"], 0)            # company isolation
        self.assertEqual(self.G(f"assets/{a['id']}/", self.o).status_code, 404)
        self.assertEqual(self.P(f"assets/{a['id']}/delete/").status_code, 200)
        self.assertEqual(self.G("assets/").json()["meta"]["total"], 0)

    def test_reserve_assign_reassign_flow(self):
        a = self.reg("AST-MBP-0143")
        r = self.P(f"assets/{a['id']}/reserve/", {"employee_code": self.rohan}).json()["data"]
        self.assertEqual(r["display_status"], "Reserved")
        self.assertEqual(r["assigned_to_label"], "-- (Reserved for Rohan Kulkarni)")
        self.assertEqual(self.P(f"assets/{a['id']}/reserve/", {"employee_code": self.rahul}).status_code, 409)
        # reserved for Rohan -> Rahul blocked, force overrides is not needed here
        blocked = self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul})
        self.assertEqual(blocked.status_code, 400)
        self.assertIn("reserved", blocked.json()["message"])
        ok = self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rohan, "condition_out": "New"})
        self.assertEqual(ok.status_code, 201, ok.content)
        d = ok.json()["data"]
        self.assertEqual((d["asset"]["display_status"], d["asset"]["assigned_to"]), ("Assigned", "Rohan Kulkarni"))
        self.assertIsNone(d["asset"]["reserved_for"])
        self.assertEqual(self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul}).status_code, 400)  # already allocated
        self.assertEqual(self.P(f"assets/{a['id']}/reassign/", {"employee_code": self.rohan}).status_code, 400)  # same person
        rr = self.P(f"assets/{a['id']}/reassign/", {"employee_code": self.rahul, "condition_in": "Good"})
        self.assertEqual(rr.status_code, 201, rr.content)
        self.assertEqual(rr.json()["data"]["asset"]["assigned_to"], "Rahul Sharma")
        self.assertEqual(rr.json()["data"]["previous_allocation"]["status"], "Returned")
        self.assertEqual(AssetAllocation.objects.filter(asset_id=a["id"], status="Allocated").count(), 1)   # never 2 open rows
        self.assertEqual(self.P(f"assets/{a['id']}/update/", {"status": "Available"}).status_code, 400)       # must return first
        self.assertEqual(self.P(f"assets/{a['id']}/delete/").status_code, 409)
        ev = self.G(f"assets/{a['id']}/history/").json()["data"]["events"]
        self.assertEqual([e["type"] for e in ev].count("ALLOCATED"), 2)
        self.assertEqual([e["type"] for e in ev].count("RETURNED"), 1)

    def test_unreserve_and_force(self):
        a = self.reg("AST-1")
        self.assertEqual(self.P(f"assets/{a['id']}/unreserve/").status_code, 409)
        self.P(f"assets/{a['id']}/reserve/", {"employee_code": self.rohan})
        self.assertEqual(self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul, "force": True}).status_code, 201)
        b = self.reg("AST-2")
        self.P(f"assets/{b['id']}/reserve/", {"employee_code": self.rohan})
        u = self.P(f"assets/{b['id']}/unreserve/").json()["data"]
        self.assertEqual((u["status"], u["reserved_for"]), ("Available", None))

    def test_summary_options_export(self):
        a = self.reg("AST-A", serial_number="S1", purchase_cost="1000", warranty_until=str(timezone.localdate() + timedelta(days=30)))
        self.reg("AST-B", "Dell Monitor", "Monitor", serial_number="S2", purchase_cost="500")
        self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul})
        s = self.G("assets/summary/").json()["data"]
        self.assertEqual((s["total"], s["by_status"]["Allocated"], s["by_status"]["Available"]), (2, 1, 1))
        self.assertEqual((s["warranty_expiring_60d"], s["total_purchase_cost"]), (1, 1500.0))
        o = self.G("assets/options/").json()["data"]
        self.assertIn("Laptop", [x["code"] for x in o["categories"]])
        self.assertEqual({e["employee_code"] for e in o["employees"]}, {self.rahul, self.rohan, self.vikram})
        r = self.G("assets/export/?category=Laptop")
        self.assertEqual(r.status_code, 200)
        self.assertIn("text/csv", r["Content-Type"])
        body = r.content.decode()
        self.assertIn("AST-A", body)
        self.assertNotIn("AST-B", body)
        self.assertIn("Rahul Sharma", body)

    # ---------------- Asset Return (offboarding) ----------------
    def test_return_tab_with_exit_clearance(self):
        m = self.reg("AST-DEL-0091", "Dell UltraSharp 27-inch 4K Monitor", "Monitor")
        lap = self.reg("AST-MBP-0142")
        self.P(f"assets/{m['id']}/assign/", {"employee_code": self.vikram})
        self.P(f"assets/{lap['id']}/assign/", {"employee_code": self.rahul})
        self.assertEqual(self.G("asset-returns/").json()["summary"]["message"], "No asset returns pending.")
        # HR starts Vikram's exit -> his asset is automatically pending (no extra write needed)
        self.P(f"profile360/{self.vikram}/exit/initiate/", {"last_working_day": str(timezone.localdate() - timedelta(days=1)), "reason": "Resigned"})
        r = self.G("asset-returns/").json()
        self.assertEqual(r["summary"]["message"], f"1 asset return pending from Vikram Rao ({self.vikram}) as part of departmental exit clearance.")
        self.assertEqual((r["summary"]["overdue"], len(r["data"])), (1, 1))
        self.assertEqual(r["data"][0]["source"], "EXIT_CLEARANCE")
        self.assertEqual(self.G("assets/").json()["data"][0]["display_status"].startswith("Assigned"), True)
        row = [x for x in self.G("assets/").json()["data"] if x["asset_tag"] == "AST-DEL-0091"][0]
        self.assertEqual(row["display_status"], "Assigned (Return Pending)")
        self.assertEqual(self.P(f"assets/{m['id']}/assign/", {"employee_code": self.rohan}).status_code, 400)
        # new assignment to an exiting employee is blocked
        self.assertEqual(self.P(f"assets/{lap['id']}/reassign/", {"employee_code": self.vikram}).status_code, 400)
        alloc = r["data"][0]["id"]
        rc = self.P(f"asset-returns/{alloc}/receive/", {"condition_in": "Good", "clear_exit_item": True}).json()
        self.assertEqual(rc["code"], "ASSET_RETURN_RECEIVED")
        self.assertTrue(rc["data"]["exit_item_cleared"])
        self.assertEqual(rc["data"]["asset_status"], "Available")
        self.assertEqual(self.P(f"asset-returns/{alloc}/receive/").status_code, 404)                 # cannot receive twice
        self.assertEqual(self.G("asset-returns/").json()["summary"]["pending_assets"], 0)
        self.assertEqual(self.G("asset-returns/?scope=returned").json()["meta"]["total"], 1)
        it = [i for i in self.G(f"profile360/{self.vikram}/exit/").json()["data"]["items"] if i["department"] == "IT"][0]
        self.assertTrue(it["cleared"])

    def test_return_request_idempotent_cancel_receive_all(self):
        a, b = self.reg("AST-1"), self.reg("AST-2", "Mouse", "Peripheral")
        for x in (a, b):
            self.P(f"assets/{x['id']}/assign/", {"employee_code": self.rahul})
        self.assertEqual(self.P("asset-returns/request/", {"employee_code": self.vikram}).status_code, 404)  # holds nothing
        r = self.P("asset-returns/request/", {"employee_code": self.rahul, "due_date": "2026-12-31", "reason": "Laptop refresh"})
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual(len(r.json()["data"]["requested"]), 2)
        self.assertEqual(self.P("asset-returns/request/", {"employee_code": self.rahul}).status_code, 409)    # no duplicates
        g = self.G("asset-returns/by-employee/").json()
        self.assertEqual((len(g["data"]), g["data"][0]["pending_count"], g["data"][0]["earliest_due"]), (1, 2, "2026-12-31"))
        self.assertEqual(self.G("assets/").json()["data"][0]["display_status"], "Assigned (Return Pending)")
        al = g["data"][0]["assets"][0]["id"]
        c = self.P(f"asset-returns/{al}/cancel/").json()
        self.assertFalse(c["data"]["return_pending"])
        self.assertEqual(self.P(f"asset-returns/{al}/cancel/").status_code, 409)
        ra = self.P("asset-returns/receive-all/", {"employee_code": self.rahul, "asset_status": "Under Repair"})
        self.assertEqual(len(ra.json()["data"]["received"]), 2)
        self.assertEqual(set(AssetMaster.objects.values_list("status", flat=True)), {"Under Repair"})
        self.assertEqual(self.P("asset-returns/receive-all/", {"employee_code": self.rahul}).status_code, 404)
        self.assertEqual(self.G("asset-returns/?scope=bad").status_code, 400)
        self.assertEqual(self.G("asset-returns/", self.o).json()["meta"]["total"], 0)

    def test_old_return_endpoint_clears_pending(self):
        a = self.reg("AST-1")
        al = self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul}).json()["data"]["allocation"]["id"]
        self.P("asset-returns/request/", {"allocation_id": al})
        self.assertEqual(self.P(f"asset-allocations/{al}/return/", {"condition_in": "ok"}).status_code, 200)
        self.assertFalse(AssetAllocation.objects.get(pk=al).return_pending)
        self.assertEqual(self.G("asset-returns/").json()["summary"]["pending_assets"], 0)

    # ---------------- Asset History (maintenance & lifecycle) ----------------
    def test_history_crud_sync_duplicates(self):
        a = self.reg("AST-MBP-0142")
        body = {"asset_tag": "AST-MBP-0142", "event_type": "Battery Replacement", "event_date": "2026-09-01",
                "vendor": "Apple Care", "cost": "8500", "description": "Battery at 78% health", "next_service_due": str(timezone.localdate() + timedelta(days=10))}
        r = self.P("asset-history/", body)
        self.assertEqual(r.status_code, 201, r.content)
        mid = r.json()["data"]["id"]
        self.assertEqual(self.P("asset-history/", body).status_code, 400)                              # duplicate entry
        self.assertEqual(self.P("asset-history/", {**body, "event_type": "Nope"}).status_code, 400)
        self.assertEqual(self.P("asset-history/", {**body, "asset_tag": "NOPE"}).status_code, 400)
        self.assertEqual(self.P("asset-history/", {**body, "description": "x", "cost": "-1"}).status_code, 400)
        # warranty entry extends the asset warranty
        self.P("asset-history/", {"asset_id": a["id"], "event_type": "Warranty Extension", "warranty_until": "2028-01-01"})
        self.assertEqual(self.G(f"assets/{a['id']}/").json()["data"]["warranty_until"], "2028-01-01")
        # repair in progress -> asset Under Repair; completed -> Available again
        rep = self.P("asset-history/", {"asset_id": a["id"], "event_type": "Repair", "status": "In Progress", "description": "screen"}).json()["data"]
        self.assertEqual(self.G(f"assets/{a['id']}/").json()["data"]["status"], "Under Repair")
        self.P(f"asset-history/{rep['id']}/update/", {"status": "Completed", "cost": "12000"})
        self.assertEqual(self.G(f"assets/{a['id']}/").json()["data"]["status"], "Available")
        # list filters / detail / update / delete / isolation
        self.assertEqual(self.G("asset-history/?asset=AST-MBP-0142").json()["meta"]["total"], 3)
        self.assertEqual(self.G("asset-history/?event_type=Repair&status=Completed").json()["meta"]["total"], 1)
        self.assertEqual(self.G("asset-history/?from=2026-09-01&to=2026-09-30").json()["meta"]["total"], 1)
        self.assertEqual(self.G("asset-history/?from=bad").status_code, 400)
        self.assertEqual(self.G("asset-history/?employee=EMP-1").status_code, 200)
        self.assertEqual(self.G(f"asset-history/{mid}/").json()["data"]["vendor"], "Apple Care")
        self.assertEqual(self.P(f"asset-history/{mid}/update/", {"asset_tag": "X"}).status_code, 400)
        self.assertEqual(self.G(f"asset-history/{mid}/", self.o).status_code, 404)
        s = self.G("asset-history/summary/").json()["data"]
        self.assertEqual((s["total_entries"], s["total_cost"], len(s["service_due_30d"])), (3, 20500.0, 1))
        self.assertEqual(self.P(f"asset-history/{mid}/delete/").status_code, 200)
        self.assertEqual(self.G("asset-history/").json()["meta"]["total"], 2)
        self.assertEqual(AssetMaintenance.objects.filter(pk=mid, is_active=False).count(), 1)         # soft delete

    def test_lifecycle_timeline(self):
        a = self.reg("AST-1")
        self.P(f"assets/{a['id']}/assign/", {"employee_code": self.rahul})
        al = self.G("asset-allocations/").json()["data"][0]["id"]
        self.P(f"asset-allocations/{al}/audit/", {"condition": "Good"})
        self.P("asset-history/", {"asset_id": a["id"], "event_type": "Inspection"})
        ev = self.G("asset-history/lifecycle/?asset=AST-1").json()["data"]
        self.assertEqual({e["type"] for e in ev}, {"ALLOCATED", "AUDIT", "MAINTENANCE"})
        self.assertEqual(self.G("asset-history/lifecycle/?asset=NOPE").status_code, 404)
        self.assertEqual(len(self.G("asset-history/lifecycle/").json()["data"]), 3)
        self.assertEqual(len(self.G("asset-history/lifecycle/", self.o).json()["data"]), 0)
        
@MEDIA
class AssetAllocationWorkflowTests(TestCase):
    """Allocate / return / history contract used by the HR Portal Asset Allocation, Return and History pages."""

    def setUp(self):
        self.co = mk_company("w@x.com")
        self.c = APIClient()
        self.c.force_authenticate(user=self.co)
        Department.objects.create(company=self.co, name="Technology")
        mk = lambda n, e: self.c.post(B + "directory/", {"name": n, "email": e, "department": "Technology",
                                                         "designation": "Engineer", "date_of_joining": "2020-01-01"},
                                      format="json").json()["data"]["employee_code"]
        self.rahul, self.vikram = mk("Rahul Sharma", "r2@x.com"), mk("Vikram Rao", "v2@x.com")

    def P(self, url, data=None):
        return self.c.post(B + url, data or {}, format="json")

    def G(self, url):
        return self.c.get(B + url)

    def reg(self, tag, **kw):
        r = self.P("assets/", {"asset_tag": tag, "device_name": "MacBook Pro", "category": "Laptop", **kw})
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]

    def test_allocate_existing_asset_validates_dates_and_never_duplicates(self):
        a = self.reg("AST-1", serial_number="SN-1")
        bad = self.P("asset-allocations/", {"asset_id": a["id"], "employee_code": self.rahul,
                                            "allocated_on": "2026-05-10", "expected_return": "2026-05-01"})
        self.assertEqual(bad.status_code, 400)
        self.assertEqual(AssetAllocation.objects.count(), 0)                    # rolled back
        ok_ = self.P("asset-allocations/", {"asset_id": a["id"], "employee_code": self.rahul,
                                            "allocated_on": "2026-05-01", "expected_return": "2026-12-31",
                                            "condition_out": "Good"})
        self.assertEqual(ok_.status_code, 201, ok_.content)
        d = ok_.json()["data"]
        self.assertEqual((d["asset_tag"], d["device_name"], d["serial_number"]), ("AST-1", "MacBook Pro", "SN-1"))
        self.assertEqual(d["assigned_custodian"]["name"], "Rahul Sharma")
        self.assertEqual(self.P("asset-allocations/", {"asset_tag": "AST-1", "employee_code": self.vikram}).status_code, 400)
        self.assertEqual(AssetMaster.objects.filter(company=self.co).count(), 1)

    def test_register_new_asset_inside_allocation_is_atomic(self):
        r = self.P("asset-allocations/", {"employee_code": self.rahul,
                                          "new_asset": {"asset_tag": "AST-NEW-1", "device_name": "Dell Monitor",
                                                        "category": "Monitor", "serial_number": "MON-9",
                                                        "warranty_until": "2028-01-01"}})
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual(AssetMaster.objects.get(asset_tag="AST-NEW-1").status, "Allocated")
        dup = self.P("asset-allocations/", {"employee_code": self.rahul,
                                            "new_asset": {"asset_tag": "AST-NEW-1", "device_name": "x"}})
        self.assertEqual(dup.status_code, 400)
        self.assertEqual(AssetAllocation.objects.count(), 1)
        self.assertEqual(AssetMaster.objects.filter(asset_tag__iexact="AST-NEW-1").count(), 1)

    def test_employee_in_exit_cannot_be_allocated_an_asset(self):
        a = self.reg("AST-X")
        self.P(f"profile360/{self.vikram}/exit/initiate/",
               {"last_working_day": str(timezone.localdate() - timedelta(days=1)), "reason": "Resigned"})
        self.assertEqual(self.P("asset-allocations/", {"asset_id": a["id"], "employee_code": self.vikram}).status_code, 400)

    def test_return_keeps_original_record_remarks_and_validates(self):
        a = self.reg("AST-R1")
        al = self.P("asset-allocations/", {"asset_id": a["id"], "employee_code": self.rahul, "allocated_on": "2026-05-01",
                                           "notes": "Charger + sleeve"}).json()["data"]["id"]
        self.assertEqual(self.P(f"asset-returns/{al}/receive/", {"asset_status": "Sold"}).status_code, 400)
        self.assertEqual(self.P(f"asset-returns/{al}/receive/", {"returned_on": "2026-04-01"}).status_code, 400)
        future = str(timezone.localdate() + timedelta(days=1))
        self.assertEqual(self.P(f"asset-returns/{al}/receive/", {"returned_on": future}).status_code, 400)
        self.assertEqual(AssetAllocation.objects.get(pk=al).status, "Allocated")
        r = self.P(f"asset-returns/{al}/receive/", {"returned_on": "2026-05-20", "condition_in": "Good",
                                                    "asset_status": "Under Repair", "notes": "Screen cracked"})
        self.assertEqual(r.status_code, 200, r.content)
        row = AssetAllocation.objects.get(pk=al)
        self.assertEqual((row.status, str(row.returned_on), row.condition_in), ("Returned", "2026-05-20", "Good"))
        self.assertIn("Charger + sleeve", row.notes)                             # allocation remark survives
        self.assertIn("Screen cracked", row.notes)
        self.assertEqual(AssetMaster.objects.get(pk=a["id"]).status, "Under Repair")
        self.assertEqual(self.P(f"asset-returns/{al}/receive/").status_code, 404)  # no double return
        self.assertEqual(self.P(f"asset-allocations/{al}/return/").status_code, 409)

    def test_history_lists_returned_cycles_and_search_by_serial(self):
        a = self.reg("AST-H1", serial_number="SN-HIST")
        al = self.P("asset-allocations/", {"asset_id": a["id"], "employee_code": self.rahul}).json()["data"]["id"]
        self.P(f"asset-allocations/{al}/return/", {"condition_in": "Good"})
        self.P(f"assets/{a['id']}/reassign/", {"employee_code": self.vikram})         # not Allocated -> 400, no change
        self.assertEqual(self.G("asset-allocations/?status=Returned").json()["meta"]["total"], 1)
        self.assertEqual(self.G("asset-allocations/").json()["meta"]["total"], 1)     # history keeps every cycle
        self.assertEqual(self.G("asset-allocations/?search=SN-HIST").json()["meta"]["total"], 1)
        self.assertEqual(self.G("asset-allocations/?search=NOPE").json()["meta"]["total"], 0)

    def test_options_expose_conditions_and_employee_department(self):
        o = self.G("assets/options/").json()["data"]
        self.assertIn("Good", o["conditions"])
        emp = [e for e in o["employees"] if e["employee_code"] == self.rahul][0]
        self.assertEqual(emp["department"], "Technology")
        self.assertFalse(emp["in_exit"])
        
        
        
