# ============================================================
# ADDITIVE tests - Time, Biometrics & Perimeter Security (Attendance Hub) + eSSL sync / PDF import
#   python manage.py test People.tests_att
# ============================================================
import io
import os
import sqlite3
import tempfile
from datetime import date, datetime, time, timedelta
from decimal import Decimal

from django.core.management import call_command
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.leave_models import ReportingHierarchy, WFHPolicy, WFHRequest
from Employee.models import AttendanceEmp, EMP_check_in_check_out, EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People import att_engine as en
from People.att_models import (AttendanceGeofence, AttendancePolicy, AttendancePunchMeta, AttendanceRegularization, BiometricDevice,
                               BiometricEnrollment, BiometricPunch, EsslSource, EsslSyncRun, FieldForceAgent, FieldTrackPoint, PerimeterEvent)

H = "/api/attendance-hub"
ME = "/employee/attendance-hub"
INSIDE = {"latitude": 18.5199, "longitude": 73.8556}
OUTSIDE = {"latitude": 19.0760, "longitude": 72.8777}
REAL_PDF = "/mnt/user-data/uploads/BasicWorkDurationReport_August.pdf"


def yesterday():
    return timezone.localdate() - timedelta(days=1)


def at(day, hhmm):
    h, m = [int(x) for x in hhmm.split(":")]
    return timezone.make_aware(datetime.combine(day, time(h, m)))


@override_settings(MEDIA_ROOT="/tmp/att_test_media", ESSL_ALLOW_SQLITE_SOURCE=True)
class ABase(APITestCase):

    def mk_company(self, n):
        return company_details.objects.create(email=f"at{n}@x.com", password="pw", contact_no=f"94000000{n:02d}", status=True, is_verified=True,
                                              office_latitude=18.5196, office_longitude=73.8553, allowed_radius=200)

    def mk_emp(self, code, name, role=None, shift=None, basic="60000"):
        e = EmployeeDT.objects.create(company=self.co, employee_code=code, name=name, email=f"{code}@x.com", Designation="Engineer",
                                      Basic_Salary=Decimal(basic), Work_sift=shift)
        EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        self.co, self.other = self.mk_company(1), self.mk_company(2)
        mk = lambda **k: EmployeeRole.objects.create(company=self.co, **k)
        self.hr_role = mk(role_name="HR", role_code="hr", can_view_attendance=True, can_create_attendance=True, can_edit_attendance=True,
                          can_delete_attendance=True)
        self.mgr_role = mk(role_name="Mgr", role_code="mgr", can_view_attendance=True, can_create_attendance=True,
                           can_edit_attendance=True, can_delete_attendance=True, can_manage_attendance=True)
        self.view_role = mk(role_name="V", role_code="v", can_view_attendance=True)
        self.asha = self.mk_emp("EMP001", "Asha")
        self.ravi = self.mk_emp("EMP002", "Ravi")
        self.meera = self.mk_emp("EMP003", "Meera")
        self.fiona = self.mk_emp("EMP004", "Fiona")
        self.hr = self.mk_emp("EMP100", "Elena", role=self.hr_role)
        self.boss = self.mk_emp("EMP101", "Boss", role=self.mgr_role)
        self.viewer = self.mk_emp("EMP102", "Viewer", role=self.view_role)
        self.stranger = self.mk_emp("EMP103", "Stranger")
        self.outsider = EmployeeDT.objects.create(company=self.other, employee_code="EMP900", name="Out", email="o@x.com")
        ReportingHierarchy.objects.create(company=self.co, Employee_ID="EMP001", manager_code="EMP002")
        self.admin = client_for(company_token(self.co))
        self.other_admin = client_for(company_token(self.other))
        self.cl = {n: client_for(employee_token(e)) for n, e in (("hr", self.hr), ("boss", self.boss), ("view", self.viewer), ("str", self.stranger),
                                                                   ("asha", self.asha), ("ravi", self.ravi), ("fiona", self.fiona), ("meera", self.meera))}

    def punch_in(self, who="asha", where=INSIDE, **kw):
        return self.cl[who].post(f"{ME}/punch/in/", {**where, **kw}, format="json", REMOTE_ADDR=kw.pop("ip", "203.0.113.5") if "ip" in kw else "203.0.113.5")

    def rec(self, emp, day, tin, tout=None, **meta):
        r = EMP_check_in_check_out.objects.create(Employee_ID=emp.employee_code, company=self.co, Name=emp.name, login_date=day,
                                                  login_time=tin + ":00", logout_date=day if tout else None, logout_time=tout + ":00" if tout else None,
                                                  checkin_latitude=meta.pop("lat", None), checkin_longitude=meta.pop("lng", None))
        if meta:
            AttendancePunchMeta.objects.create(company=self.co, checkin=r, **meta)
        return r


class AuthTests(ABase):
    GETS = ("meta/", "dashboard/", "policy/", "daily/", "geofences/", "devices/", "enrollments/", "punches/", "field/agents/", "field/points/",
            "late-early/", "regularizations/", "perimeter-events/", "gateway/", "essl/sources/", "essl/runs/")

    def test_matrix(self):
        for u in self.GETS:
            url = f"{H}/{u}"
            self.assertEqual(APIClient().get(url).status_code, 401, url)
            self.assertEqual(self.cl["str"].get(url).status_code, 403, url)
            self.assertEqual(self.cl["view"].get(url).status_code, 200, url)
            self.assertEqual(self.admin.get(url).status_code, 200, url)

    def test_write_needs_permission_and_isolation(self):
        body = {"name": "Hub", "latitude": 18.5, "longitude": 73.8}
        self.assertEqual(self.cl["view"].post(f"{H}/geofences/", body, format="json").status_code, 403)
        r = self.cl["hr"].post(f"{H}/geofences/", body, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        gid = r.json()["data"]["id"]
        self.assertEqual(self.other_admin.get(f"{H}/geofences/{gid}/").status_code, 404)
        self.assertEqual(self.other_admin.get(f"{H}/geofences/").json()["meta"]["total"], 0)
        self.assertEqual(self.cl["view"].delete(f"{H}/geofences/{gid}/").status_code, 403)

    def test_employee_endpoints_need_employee_token(self):
        self.assertEqual(APIClient().get(f"{ME}/today/").status_code, 401)
        self.assertIn(self.admin.get(f"{ME}/today/").status_code, (401, 403))

    def test_essl_needs_manage(self):
        body = {"name": "eSSL", "source_type": "sqlite", "host": "/tmp/x.db"}
        self.assertEqual(self.cl["hr"].post(f"{H}/essl/sources/", body, format="json").status_code, 403)       # edit is not manage
        self.assertEqual(self.cl["boss"].post(f"{H}/essl/sources/", body, format="json").status_code, 201)
        self.assertEqual(self.cl["hr"].get(f"{H}/essl/sources/").status_code, 200)
        self.assertEqual(self.cl["hr"].post(f"{H}/essl/import/pdf/", {}, format="multipart").status_code, 403)


class PolicyTests(ABase):
    def test_defaults_save_validate(self):
        d = self.admin.get(f"{H}/policy/").json()["data"]
        self.assertEqual((d["configured"], d["shift_start"], d["grace_minutes"], d["late_cutoff"]), (False, "09:00", 15, "09:15"))
        r = self.admin.patch(f"{H}/policy/", {"shift_start": "10:00", "grace_minutes": 10, "perimeter_enforced": False}, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["late_cutoff"], r.json()["data"]["configured"]), (200, "10:10", True))
        for bad in ({"shift_start": "25:00"}, {"grace_minutes": 500}, {"shift_start": "19:00"}, {"ingestion_mode": " "}):
            self.assertEqual(self.admin.patch(f"{H}/policy/", bad, format="json").status_code, 400, bad)
        self.assertEqual(AttendancePolicy.objects.count(), 1)

    def test_policy_drives_late_logic_and_reports(self):
        d = yesterday()
        self.rec(self.asha, d, "09:40", "18:00")
        self.assertEqual(len(self.admin.get(f"{H}/late-early/?from={d}&to={d}").json()["data"]["rows"]), 1)
        self.admin.patch(f"{H}/policy/", {"shift_start": "09:30", "grace_minutes": 15}, format="json")
        self.assertEqual(self.admin.get(f"{H}/late-early/?from={d}&to={d}").json()["data"]["rows"], [])
        from People.reports_engine import punctuality_cutoff
        self.assertEqual(punctuality_cutoff(self.co), 9 * 60 + 45)       # reports follow the saved policy


class GeofenceTests(ABase):
    def test_crud_and_validation(self):
        r = self.admin.post(f"{H}/geofences/", {"name": "Pune Tech HQ", "latitude": 18.5196, "longitude": 73.8553, "radius_m": 200,
                                                "ip_ranges": ["192.168.1.0/24"], "is_primary": True}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        gid = r.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{H}/geofences/", {"name": "pune tech hq", "latitude": 1, "longitude": 1}, format="json").status_code, 409)
        for bad in ({"name": "x", "latitude": 99, "longitude": 1}, {"name": "x", "latitude": 1}, {"name": "x", "latitude": 1, "longitude": 1, "radius_m": 5},
                    {"name": "x", "latitude": 1, "longitude": 1, "ip_ranges": ["nope"]}, {"name": "x", "latitude": 1, "longitude": 1, "ip_ranges": "1.1.1.1"}):
            self.assertEqual(self.admin.post(f"{H}/geofences/", bad, format="json").status_code, 400, bad)
        r = self.admin.post(f"{H}/geofences/", {"name": "Mumbai Hub", "latitude": 19.07, "longitude": 72.87, "is_primary": True}, format="json")
        self.assertEqual(AttendanceGeofence.objects.filter(is_primary=True).count(), 1)         # only one primary
        self.assertEqual(self.admin.patch(f"{H}/geofences/{gid}/", {"radius_m": 300}, format="json").json()["data"]["radius_m"], 300)
        self.assertEqual(self.admin.delete(f"{H}/geofences/{gid}/").status_code, 200)

    def test_simulator_company_default_and_saved(self):
        s = self.admin.post(f"{H}/geofences/simulate/", INSIDE, format="json").json()["data"]
        self.assertTrue(s["inside"])
        self.assertEqual(s["geofence"]["source"], "company_profile")
        far = self.admin.post(f"{H}/geofences/simulate/", OUTSIDE, format="json").json()["data"]
        self.assertFalse(far["inside"])
        self.assertTrue(far["reason"].startswith("Outside authorized Wi-Fi & 200m GPS radius ("))
        self.admin.post(f"{H}/geofences/", {"name": "HQ", "latitude": 18.5196, "longitude": 73.8553, "radius_m": 200, "ip_ranges": ["192.168.1.0/24"]}, format="json")
        ok_ip = self.admin.post(f"{H}/geofences/simulate/", {**INSIDE, "ip": "192.168.1.44"}, format="json").json()["data"]
        bad_ip = self.admin.post(f"{H}/geofences/simulate/", {**INSIDE, "ip": "8.8.8.8"}, format="json").json()["data"]
        self.assertEqual((ok_ip["inside"], ok_ip["ip_whitelisted"]), (True, True))
        self.assertEqual((bad_ip["inside"], bad_ip["ip_whitelisted"]), (False, False))
        self.assertIn("IP is not in the authorized", bad_ip["reason"])
        emp = self.admin.post(f"{H}/geofences/simulate/", {**OUTSIDE, "employee_code": "EMP001"}, format="json").json()["data"]
        self.assertEqual((emp["allowed"], emp["event_status"]), (False, "Blocked by Perimeter Lock"))      # no WFH policy -> no quota
        self.assertEqual(self.admin.post(f"{H}/geofences/simulate/", {"latitude": "x"}, format="json").status_code, 400)


class EmployeePunchTests(ABase):
    def test_inside_punch_in_out(self):
        r = self.punch_in()
        self.assertEqual(r.status_code, 201, r.json())
        d = r.json()["data"]
        self.assertEqual((d["verification"]["perimeter_status"], d["record"]["perimeter_status"], d["record"]["source"]),
                         ("In-Perimeter Verified", "In-Perimeter Verified", "GPS Mobile Punch"))
        self.assertEqual(self.punch_in().status_code, 409)
        self.asha.refresh_from_db()
        self.assertEqual(self.asha.check_st, "check_in")
        self.assertTrue(self.cl["asha"].get(f"{ME}/today/").json()["data"]["checked_in"])
        o = self.cl["asha"].post(f"{ME}/punch/out/", INSIDE, format="json")
        self.assertEqual(o.status_code, 200, o.json())
        self.assertIsNotNone(o.json()["data"]["punch_out"])
        self.asha.refresh_from_db()
        self.assertIsNone(self.asha.check_st)
        self.assertEqual(self.cl["asha"].post(f"{ME}/punch/out/", INSIDE, format="json").status_code, 409)
        self.assertEqual(AttendancePunchMeta.objects.get().checkout_source, "GPS Mobile Punch")

    def test_outside_blocked_logs_event_then_wfh_paths(self):
        r = self.punch_in(where=OUTSIDE)
        self.assertEqual((r.status_code, r.json()["code"]), (403, "PERIMETER_BLOCKED"))
        self.assertEqual(PerimeterEvent.objects.get().status, "Blocked by Perimeter Lock")
        self.assertFalse(EMP_check_in_check_out.objects.exists())
        # WFH quota left -> redirected to the WFH portal
        WFHPolicy.objects.create(company=self.co, is_enabled=True, weekly_quota_days=2)
        r = self.punch_in(where=OUTSIDE)
        self.assertEqual((r.status_code, r.json()["code"]), (403, "WFH_REDIRECT"))
        self.assertEqual(PerimeterEvent.objects.filter(status="Redirected to WFH Portal").count(), 1)
        # approved WFH today -> allowed as Authorized WFH
        WFHRequest.objects.create(company=self.co, Employee_ID="EMP001", Name="Asha", wfh_date=timezone.localdate(), status="Approved")
        r = self.punch_in(where=OUTSIDE)
        self.assertEqual(r.status_code, 201, r.json())
        self.assertEqual(r.json()["data"]["verification"]["perimeter_status"], "Authorized WFH")

    def test_ip_whitelist_dual_verification(self):
        self.admin.post(f"{H}/geofences/", {"name": "HQ", "latitude": 18.5196, "longitude": 73.8553, "ip_ranges": ["192.168.1.0/24"]}, format="json")
        r = self.cl["asha"].post(f"{ME}/punch/in/", INSIDE, format="json", REMOTE_ADDR="8.8.8.8")
        self.assertEqual(r.status_code, 403)
        self.assertIn("IP is not in the authorized", r.json()["message"])
        r = self.cl["asha"].post(f"{ME}/punch/in/", INSIDE, format="json", REMOTE_ADDR="192.168.1.44")
        self.assertEqual(r.status_code, 201)

    def test_policy_switches_and_field_agent_block(self):
        self.admin.patch(f"{H}/policy/", {"allow_mobile_punch": False}, format="json")
        r = self.cl["asha"].post(f"{ME}/punch/in/", {**INSIDE, "source": "mobile"}, format="json")
        self.assertEqual((r.status_code, r.json()["code"]), (403, "PUNCH_CHANNEL_DISABLED"))
        self.admin.patch(f"{H}/policy/", {"allow_mobile_punch": True, "perimeter_enforced": False}, format="json")
        r = self.punch_in(where=OUTSIDE)
        self.assertEqual((r.status_code, r.json()["data"]["verification"]["perimeter_status"]), (201, "Unverified"))
        FieldForceAgent.objects.create(company=self.co, employee=self.fiona)
        r = self.cl["fiona"].post(f"{ME}/punch/in/", INSIDE, format="json")
        self.assertEqual((r.status_code, r.json()["code"]), (403, "FIELD_FORCE_USE_TRACKER"))

    def test_perimeter_check_logs_and_my_lists(self):
        c = self.cl["asha"].post(f"{ME}/perimeter/check/", OUTSIDE, format="json").json()["data"]
        self.assertFalse(c["allowed"])
        self.assertFalse(PerimeterEvent.objects.exists())                       # the simulator never saves anything
        self.assertEqual(self.cl["asha"].post(f"{ME}/perimeter/check/", {"latitude": "x"}, format="json").status_code, 400)
        self.punch_in(where=OUTSIDE)
        self.assertEqual(self.cl["asha"].get(f"{ME}/perimeter-events/").json()["meta"]["total"], 1)
        self.assertEqual(self.cl["meera"].get(f"{ME}/perimeter-events/").json()["meta"]["total"], 0)

    def test_legacy_check_in_endpoint_still_works(self):
        r = self.cl["asha"].post("/employee/check-in/", {"latitude": 18.5196, "longitude": 73.8553, "location_type": "office"}, format="json")
        self.assertIn(r.status_code, (200, 201, 400), r.content[:200])        # existing behaviour is untouched
        self.assertTrue(self.cl["ravi"].get(f"{ME}/today/").json()["data"]["perimeter"]["enforced"])


class DeviceTests(ABase):
    def mk_device(self, **kw):
        r = self.admin.post(f"{H}/devices/", {"name": "eSSL SilkBio-101TC", "vendor": "eSSL", "location_label": "Pune Tech HQ - Main Reception Turnstile",
                                              "ip_address": "192.168.1.201", "port": 4370, "sync_protocol": "Push API / TCP-IP", **kw}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        return r.json()["data"]

    def test_crud_key_once_rotate(self):
        d = self.mk_device()
        self.assertEqual(d["device_code"], "BIO-DEV-01")
        self.assertTrue(d["api_key"].startswith("bdk_biodev01_"))
        self.assertNotIn("api_key", self.admin.get(f"{H}/devices/{d['id']}/").json()["data"])
        self.assertEqual(self.mk_device(name="ZKTeco uFace 800 Plus", vendor="ZKTeco")["device_code"], "BIO-DEV-02")
        self.assertEqual(self.admin.post(f"{H}/devices/", {"device_code": "BIO-DEV-01", "name": "dup"}, format="json").status_code, 409)
        for bad in ({"name": "x", "vendor": "Nope"}, {"name": "x", "ip_address": "999.1.1.1"}, {"name": "x", "port": 70000}, {"vendor": "eSSL"}):
            self.assertEqual(self.admin.post(f"{H}/devices/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.admin.patch(f"{H}/devices/{d['id']}/", {"firmware": "v4.8.2"}, format="json").json()["data"]["firmware"], "v4.8.2")
        self.assertEqual(self.admin.patch(f"{H}/devices/{d['id']}/", {"device_code": "X"}, format="json").status_code, 400)
        new = self.admin.post(f"{H}/devices/{d['id']}/rotate-key/", {}, format="json").json()["data"]["api_key"]
        self.assertNotEqual(new, d["api_key"])
        self.assertEqual(APIClient().post(f"{H}/device/heartbeat/", {}, format="json", HTTP_X_DEVICE_KEY=d["api_key"]).status_code, 401)
        self.assertEqual(APIClient().post(f"{H}/device/heartbeat/", {}, format="json", HTTP_X_DEVICE_KEY=new).status_code, 200)
        self.assertEqual(self.admin.get(f"{H}/devices/?vendor=ZKTeco").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.delete(f"{H}/devices/{d['id']}/").status_code, 200)

    def test_ping_is_ssrf_guarded_and_sync(self):
        d = self.mk_device()
        r = self.admin.post(f"{H}/devices/{d['id']}/ping/", {}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertFalse(r.json()["data"]["reachable"])                          # private LAN blocked by AdminCenter's guard
        self.assertEqual(self.admin.post(f"{H}/devices/sync-all/", {}, format="json").json()["data"]["devices_synced"], 1)
        self.admin.patch(f"{H}/devices/{d['id']}/", {"status": "Maintenance"}, format="json")
        self.assertEqual(self.admin.post(f"{H}/devices/{d['id']}/sync/", {}, format="json").status_code, 409)

    def test_gateway_config(self):
        g = self.admin.get(f"{H}/gateway/").json()["data"]
        self.assertEqual((g["connector_status"], g["central_gateway_url"]), ("Not Configured", None))
        self.assertEqual(self.admin.patch(f"{H}/gateway/", {"central_gateway_url": "ftp://x"}, format="json").status_code, 400)
        r = self.admin.patch(f"{H}/gateway/", {"central_gateway_url": "https://api.zenithhr.internal/v2/biometric/sync",
                                               "ingestion_mode": "Direct TCP/IP Polling (Zero Buffer Loss)", "reconcile_interval_seconds": 60}, format="json")
        self.assertEqual(r.json()["data"]["auto_reconcile_schedule"], "Every 60 Seconds (Live Real-Time)")
        p = self.admin.post(f"{H}/gateway/ping/", {}, format="json")
        self.assertEqual(p.status_code, 200)
        self.assertFalse(p.json()["data"]["reachable"])
        self.assertEqual(self.cl["view"].post(f"{H}/gateway/ping/", {}, format="json").status_code, 403)


class IngestTests(ABase):
    def setUp(self):
        super().setUp()
        d = self.admin.post(f"{H}/devices/", {"name": "SilkBio", "vendor": "eSSL"}, format="json").json()["data"]
        self.key, self.dev_id = d["api_key"], d["id"]
        BiometricEnrollment.objects.create(company=self.co, employee=self.asha, biometric_id="FP-0001", verification_mode="Fingerprint")
        self.dev = APIClient()

    def push(self, punches, key=None):
        return self.dev.post(f"{H}/device/ingest/", {"punches": punches}, format="json", HTTP_X_DEVICE_KEY=key or self.key)

    def test_auth(self):
        self.assertEqual(self.dev.post(f"{H}/device/ingest/", {"punches": []}, format="json").status_code, 401)
        self.assertEqual(self.push([{"biometric_id": "x", "punch_time": "2026-01-01T09:00:00"}], key="wrong").status_code, 401)
        self.assertEqual(self.cl["hr"].post(f"{H}/device/ingest/", {"punches": []}, format="json").status_code, 401)      # JWT is not a device key
        self.assertEqual(self.push([]).status_code, 400)
        self.assertEqual(self.push([{}] * 501).status_code, 400)

    def test_flow_idempotent_and_statuses(self):
        d = yesterday()
        t_in, t_out = at(d, "09:20").isoformat(), at(d, "18:05").isoformat()
        r = self.push([{"biometric_id": "FP-0001", "punch_time": t_in, "direction": "IN", "verification_mode": "SilkBio Optical Fingerprint", "match_score": 99.8},
                       {"biometric_id": "FP-0001", "punch_time": t_in, "direction": "IN"},
                       {"biometric_id": "FP-0001", "punch_time": at(d, "09:30").isoformat(), "direction": "IN"},
                       {"biometric_id": "FP-9999", "punch_time": t_in, "direction": "IN"},
                       {"biometric_id": "FP-0001", "punch_time": t_out, "direction": "OUT"},
                       {"biometric_id": "FP-0001", "punch_time": (timezone.now() + timedelta(hours=2)).isoformat()},
                       {"punch_time": t_in}, {"biometric_id": "FP-0001", "punch_time": "nope"},
                       {"biometric_id": "FP-0001", "punch_time": t_in, "direction": "SIDEWAYS"},
                       {"biometric_id": "FP-0001", "punch_time": "2020-01-01T09:00:00"}])
        self.assertEqual(r.status_code, 200, r.json())
        res = r.json()["data"]["results"]
        self.assertEqual([x["status"] for x in res], ["accepted", "already_received", "accepted", "accepted", "accepted"] + ["rejected"] * 5)
        self.assertEqual([x.get("sync_status") for x in res[:5]], ["Reconciled", "Reconciled", "Duplicate", "Unmatched", "Reconciled"])
        rec = EMP_check_in_check_out.objects.get(Employee_ID="EMP001")
        self.assertEqual((rec.login_date, rec.login_time, rec.logout_time), (d, "09:20:00", "18:05:00"))
        self.assertEqual(AttendancePunchMeta.objects.get().perimeter_status, "Device Verified")
        self.assertEqual(self.push([{"biometric_id": "FP-0001", "punch_time": t_out, "direction": "OUT"}]).json()["data"]["summary"], {"already_received": 1})
        self.assertEqual(BiometricPunch.objects.filter(device_code="BIO-DEV-01").count(), 4)
        row = self.admin.get(f"{H}/daily/?date={d}").json()["data"][0]
        self.assertEqual((row["source"], row["perimeter_status"], row["device_mode"]), ("Biometric Device", "Device Verified", "Biometric Device (SilkBio)"))

    def test_enrolling_later_reconciles_unmatched_in_time_order(self):
        d = yesterday()
        self.push([{"biometric_id": "FP-0777", "punch_time": at(d, "18:00").isoformat(), "direction": "OUT"},
                   {"biometric_id": "FP-0777", "punch_time": at(d, "09:00").isoformat(), "direction": "IN"}])
        self.assertEqual(self.admin.get(f"{H}/punches/unmatched/").json()["data"]["results"][0]["punches"], 2)
        r = self.admin.post(f"{H}/enrollments/", {"employee_code": "EMP002", "biometric_id": "FP-0777"}, format="json")
        self.assertEqual(r.status_code, 201)
        self.assertEqual(self.admin.get(f"{H}/punches/?sync_status=Reconciled&employee_code=EMP002").json()["meta"]["total"], 2)
        rec = EMP_check_in_check_out.objects.get(Employee_ID="EMP002")
        self.assertEqual((rec.login_time, rec.logout_time), ("09:00:00", "18:00:00"))

    def test_disabled_device_and_cross_company(self):
        self.admin.patch(f"{H}/devices/{self.dev_id}/", {"status": "Disabled"}, format="json")
        self.assertEqual(self.push([{"biometric_id": "FP-0001", "punch_time": at(yesterday(), "09:00").isoformat()}]).status_code, 403)
        self.assertEqual(self.dev.post(f"{H}/device/heartbeat/", {}, format="json", HTTP_X_DEVICE_KEY=self.key).status_code, 403)
        self.assertEqual(self.other_admin.get(f"{H}/devices/{self.dev_id}/").status_code, 404)

    def test_heartbeat_marks_online_on_dashboard(self):
        self.assertEqual(self.dev.post(f"{H}/device/heartbeat/", {"firmware": "v2.0"}, format="json", HTTP_X_DEVICE_KEY=self.key).status_code, 200)
        d = self.admin.get(f"{H}/dashboard/").json()["data"]
        self.assertEqual(d["badges"]["devices_online"], 1)
        self.assertEqual(d["hardware_network"]["devices"][0]["connection"], "Online")
        self.assertEqual(d["hardware_network"]["devices"][0]["firmware"], "v2.0")


class PunchBufferAndEnrollmentTests(ABase):
    def test_enrollment_crud_bulk(self):
        r = self.admin.post(f"{H}/enrollments/", {"employee_code": "EMP001", "biometric_id": "FP-0248", "verification_mode": "Fingerprint"}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        eid = r.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{H}/enrollments/", {"employee_code": "EMP002", "biometric_id": "FP-0248"}, format="json").status_code, 409)
        for bad in ({"employee_code": "NOPE", "biometric_id": "x"}, {"employee_code": "EMP001"}, {"employee_code": "EMP001", "biometric_id": "y", "verification_mode": "Telepathy"}):
            self.assertEqual(self.admin.post(f"{H}/enrollments/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.admin.patch(f"{H}/enrollments/{eid}/", {"verification_mode": "Iris"}, format="json").json()["data"]["verification_mode"], "Iris")
        b = self.admin.post(f"{H}/enrollments/bulk/", {"items": [
            {"essl_code": "4", "employee_code": "EMP002"}, {"biometric_id": "FP-0248", "employee_code": "EMP003"},
            {"essl_code": "5", "employee_code": "NOPE"}, {"employee_code": "EMP003"}]}, format="json").json()["data"]
        self.assertEqual((b["created"], b["skipped"], b["errors"]), (1, 1, 2))
        self.assertEqual(self.admin.post(f"{H}/enrollments/bulk/", {"items": []}, format="json").status_code, 400)
        self.assertEqual(self.admin.get(f"{H}/enrollments/?employee=EMP002").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.delete(f"{H}/enrollments/{eid}/").status_code, 200)

    def test_punch_crud_manual(self):
        d = yesterday()
        body = {"biometric_id": "FP-0248", "punch_time": at(d, "09:10").isoformat(), "direction": "IN"}
        self.assertEqual(self.admin.post(f"{H}/punches/", body, format="json").json()["data"]["sync_status"], "Unmatched")      # not enrolled
        self.assertEqual(self.admin.post(f"{H}/punches/", body, format="json").status_code, 409)
        pid = BiometricPunch.objects.get().id
        r = self.admin.patch(f"{H}/punches/{pid}/", {"employee_code": "EMP001"}, format="json")                            # HR maps it by hand
        self.assertEqual((r.status_code, r.json()["data"]["sync_status"]), (200, "Reconciled"))
        self.assertEqual(self.admin.patch(f"{H}/punches/{pid}/", {"direction": "OUT"}, format="json").status_code, 409)      # reconciled = locked
        self.assertEqual(self.admin.delete(f"{H}/punches/{pid}/").status_code, 409)
        for bad in ({"employee_code": "EMP001", "punch_time": "nope"}, {"employee_code": "EMP001", "punch_time": (timezone.now() + timedelta(days=1)).isoformat()},
                    {"punch_time": at(d, "09:00").isoformat()}, {"employee_code": "EMP001", "punch_time": at(d, "09:00").isoformat(), "match_score": 500}):
            self.assertEqual(self.admin.post(f"{H}/punches/", bad, format="json").status_code, 400, bad)
        # a manual punch by employee_code needs no enrollment; an OUT without a check-in fails and can be removed / re-processed
        r2 = self.admin.post(f"{H}/punches/", {"employee_code": "EMP002", "punch_time": at(d, "09:11").isoformat(), "direction": "OUT"}, format="json")
        self.assertEqual(r2.json()["data"]["sync_status"], "Failed")
        self.assertEqual(self.admin.delete(f"{H}/punches/{r2.json()['data']['id']}/").status_code, 200)
        self.admin.post(f"{H}/punches/", {"employee_code": "EMP002", "punch_time": at(d, "09:12").isoformat(), "direction": "OUT"}, format="json")
        self.assertEqual(self.admin.post(f"{H}/punches/reprocess/", {}, format="json").json()["data"], {"results": {"Failed": 1}, "total": 1})
        self.assertEqual(self.admin.get(f"{H}/punches/?sync_status=Failed&employee_code=EMP002").json()["meta"]["total"], 1)
        ok_in = self.admin.post(f"{H}/punches/", {"employee_code": "EMP003", "punch_time": at(d, "09:00").isoformat()}, format="json")
        self.assertEqual(ok_in.json()["data"]["sync_status"], "Reconciled")


class DailyTests(ABase):
    def test_log_filters_crud_export(self):
        d = yesterday()
        a = self.rec(self.asha, d, "09:10", "18:00", source="Biometric Device", perimeter_status="Device Verified")
        self.rec(self.ravi, d, "10:15", "18:30", lat=18.5, lng=73.8)                      # legacy (no meta)
        rows = self.admin.get(f"{H}/daily/?date={d}").json()["data"]
        by = {r["employee"]["employee_code"]: r for r in rows}
        self.assertEqual((by["EMP001"]["status"], by["EMP001"]["punch_in_label"]), ("Present", "09:10 AM"))
        self.assertEqual((by["EMP002"]["status"], by["EMP002"]["source"], by["EMP002"]["perimeter_status"], by["EMP002"]["meta_recorded"]),
                         ("Late", "GPS Mobile Punch", "Unverified", False))
        self.assertEqual(by["EMP002"]["gps"]["label"], "18.5000° N, 73.8000° E")
        self.assertEqual(self.admin.get(f"{H}/daily/?date={d}&status=Late").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.get(f"{H}/daily/?date={d}&source=Biometric Device").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.get(f"{H}/daily/?date={d}&source=GPS Mobile Punch").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.get(f"{H}/daily/?date={d}&perimeter_status=Unverified").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.get(f"{H}/daily/?date={d}&search=asha").json()["meta"]["total"], 1)
        # manual entry / edit / delete
        self.assertEqual(self.admin.post(f"{H}/daily/", {"employee_code": "EMP003", "date": str(d), "punch_in": "09:00"}, format="json").status_code, 400)   # reason
        r = self.admin.post(f"{H}/daily/", {"employee_code": "EMP003", "date": str(d), "punch_in": "09:00", "punch_out": "17:00", "reason": "Forgot to punch"}, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["perimeter_status"], r.json()["data"]["total_working_hours"] is not None), (201, "Manual Entry", True))
        rid = r.json()["data"]["id"]
        self.assertEqual(self.admin.patch(f"{H}/daily/{rid}/", {"punch_in": "10:00"}, format="json").status_code, 400)                                 # reason
        u = self.admin.patch(f"{H}/daily/{rid}/", {"punch_in": "09:30", "reason": "Corrected"}, format="json")
        self.assertEqual(u.json()["data"]["punch_in"], "09:30:00")
        self.assertEqual(self.admin.patch(f"{H}/daily/{rid}/", {"punch_out": "08:00", "reason": "x"}, format="json").status_code, 400)
        self.assertEqual(self.admin.delete(f"{H}/daily/{rid}/").status_code, 200)
        self.assertEqual(self.admin.get(f"{H}/daily/{rid}/").status_code, 404)
        for bad in ({"employee_code": "EMP003", "date": str(timezone.localdate() + timedelta(days=1)), "punch_in": "09:00", "reason": "x"},
                    {"employee_code": "EMP003", "punch_in": "9am", "reason": "x"}):
            self.assertEqual(self.admin.post(f"{H}/daily/", bad, format="json").status_code, 400, bad)
        csv_resp = self.admin.get(f"{H}/daily/export/?date={d}")
        self.assertEqual(csv_resp.status_code, 200)
        self.assertIn("Date,Employee Code", csv_resp.content.decode("utf-8-sig").splitlines()[0])
        self.assertEqual(self.other_admin.get(f"{H}/daily/{a.id}/").status_code, 404)

    def test_formula_injection_in_export(self):
        d = yesterday()
        e = self.mk_emp("EMP777", "=HYPERLINK(\"x\")")
        self.rec(e, d, "09:00", "17:00")
        self.assertIn("'=HYPERLINK", self.admin.get(f"{H}/daily/export/?date={d}").content.decode("utf-8-sig"))


class LateEarlyAndRegularizationTests(ABase):
    def test_late_early_rows(self):
        d = yesterday()
        self.rec(self.asha, d, "09:42", "18:00")
        self.rec(self.ravi, d, "09:10", "17:20")
        self.rec(self.meera, d, "09:05", "17:50")
        night = self.mk_emp("EMP555", "Nina", shift="Night Shift")
        self.rec(night, d, "22:00", "06:00")
        rows = self.admin.get(f"{H}/late-early/?from={d}&to={d}").json()["data"]["rows"]
        kinds = {(r["employee"]["employee_code"], r["type"]) for r in rows}
        self.assertEqual(kinds, {("EMP001", "Late Arrival"), ("EMP002", "Early Departure")})
        late = [r for r in rows if r["type"] == "Late Arrival"][0]
        self.assertEqual((late["recorded_arrival"], late["scheduled_shift"], late["grace_period"], late["late_by_minutes"], late["action"]),
                         ("09:42 AM", "09:00 AM", "15 Mins Exceeded", 42, "Request Regularization"))
        self.assertEqual(len(self.admin.get(f"{H}/late-early/?from={d}&to={d}&kind=early").json()["data"]["rows"]), 1)
        self.assertEqual(self.admin.get(f"{H}/late-early/?kind=bad").status_code, 400)
        self.assertEqual([r["type"] for r in self.cl["asha"].get(f"{ME}/late-early/?from={d}&to={d}").json()["data"]], ["Late Arrival"])

    def test_regularization_full_flow(self):
        d = yesterday()
        self.rec(self.asha, d, "09:42")                                                       # missing out punch -> late + open
        body = {"date": str(d), "punch_in_time": "09:00", "punch_out_time": "18:00", "reason": "Biometric sensor glitch"}
        r = self.cl["asha"].post(f"{ME}/regularizations/", body, format="json")
        self.assertEqual((r.status_code, r.json()["data"]["request_id"], r.json()["data"]["status"]), (201, "REG-001", "Pending Approval"))
        rid = r.json()["data"]["id"]
        self.assertEqual(self.cl["asha"].post(f"{ME}/regularizations/", body, format="json").status_code, 409)
        self.assertEqual(self.admin.get(f"{H}/late-early/?from={d}&to={d}").json()["data"]["rows"][0]["regularization"]["request_id"], "REG-001")
        self.assertEqual(self.cl["asha"].patch(f"{ME}/regularizations/{rid}/", {"reason": "Edited"}, format="json").json()["data"]["reason"], "Edited")
        self.assertEqual(self.cl["meera"].get(f"{ME}/regularizations/{rid}/").status_code, 404)
        self.assertEqual(self.cl["ravi"].get(f"{ME}/team/regularizations/").json()["meta"]["total"], 1)
        self.assertEqual(self.cl["meera"].get(f"{ME}/team/regularizations/").status_code, 403)
        self.assertEqual(self.cl["meera"].post(f"{ME}/team/regularizations/{rid}/approve/", {}, format="json").status_code, 403)
        self.assertEqual(self.cl["ravi"].post(f"{ME}/team/regularizations/{rid}/reject/", {}, format="json").status_code, 400)
        a = self.cl["ravi"].post(f"{ME}/team/regularizations/{rid}/approve/", {"comment": "Verified"}, format="json")
        self.assertEqual((a.status_code, a.json()["data"]["status"], a.json()["data"]["reviewed_by"]), (200, "Approved", "employee:EMP002"))
        rec = EMP_check_in_check_out.objects.get(Employee_ID="EMP001", login_date=d)
        self.assertEqual((rec.login_time, rec.logout_time), ("09:00:00", "18:00:00"))
        self.assertEqual(AttendancePunchMeta.objects.get(checkin=rec).perimeter_status, "Regularized")
        day = AttendanceEmp.objects.get(Employee_ID="EMP001", date=d)
        self.assertEqual(day.status, "Present")
        self.assertEqual(self.admin.get(f"{H}/late-early/?from={d}&to={d}").json()["data"]["rows"], [])
        self.assertEqual(self.cl["asha"].delete(f"{ME}/regularizations/{rid}/").status_code, 409)       # approved = locked
        self.assertEqual(self.admin.delete(f"{H}/regularizations/{rid}/").status_code, 409)
        self.assertEqual(EMP_check_in_check_out.objects.filter(Employee_ID="EMP001").count(), 1)          # no duplicate record

    def test_hr_create_reject_edit_cancel_and_validation(self):
        d = yesterday()
        for bad in ({"employee_code": "EMP001", "date": str(timezone.localdate() + timedelta(days=1)), "punch_in_time": "09:00", "reason": "x"},
                    {"employee_code": "EMP001", "date": str(timezone.localdate() - timedelta(days=90)), "punch_in_time": "09:00", "reason": "x"},
                    {"employee_code": "EMP001", "date": str(d), "punch_in_time": "09:00", "punch_out_time": "08:00", "reason": "x"},
                    {"employee_code": "EMP001", "date": str(d), "punch_in_time": "09:00"}, {"employee_code": "NOPE", "date": str(d), "punch_in_time": "09:00", "reason": "x"}):
            self.assertEqual(self.admin.post(f"{H}/regularizations/", bad, format="json").status_code, 400, bad)
        r = self.admin.post(f"{H}/regularizations/", {"employee_code": "EMP002", "date": str(d), "punch_in_time": "09:30", "reason": "Client site"}, format="json")
        rid = r.json()["data"]["id"]
        self.assertEqual(r.json()["data"]["requested_by"], "HR")
        self.assertEqual(self.admin.post(f"{H}/regularizations/{rid}/reject/", {}, format="json").status_code, 400)
        rj = self.admin.post(f"{H}/regularizations/{rid}/reject/", {"comment": "Not verified"}, format="json")
        self.assertEqual(rj.json()["data"]["status"], "Rejected")
        self.assertEqual(self.admin.post(f"{H}/regularizations/{rid}/approve/", {}, format="json").status_code, 409)
        self.assertEqual(self.admin.patch(f"{H}/regularizations/{rid}/", {"reason": "x"}, format="json").status_code, 409)
        self.assertEqual(self.admin.delete(f"{H}/regularizations/{rid}/").status_code, 200)
        # a rejected request does not block a new one; auto_approve writes the punch at once
        r = self.admin.post(f"{H}/regularizations/", {"employee_code": "EMP002", "date": str(d), "punch_in_time": "09:30", "punch_out_time": "17:30",
                                                      "reason": "Client site", "auto_approve": True}, format="json")
        self.assertEqual(r.json()["data"]["status"], "Approved")
        self.assertEqual(self.admin.get(f"{H}/regularizations/?status=Approved&search=REG").json()["meta"]["total"], 1)
        e = self.admin.post(f"{H}/regularizations/", {"employee_code": "EMP003", "date": str(d), "punch_in_time": "09:30", "reason": "x"}, format="json").json()["data"]
        c = self.cl["meera"].delete(f"{ME}/regularizations/{e['id']}/")
        self.assertEqual((c.status_code, c.json()["data"]["status"]), (200, "Cancelled"))


class PerimeterEventAndFieldTests(ABase):
    def test_event_lifecycle(self):
        self.punch_in(where=OUTSIDE)
        e = self.admin.get(f"{H}/perimeter-events/").json()["data"][0]
        self.assertEqual((e["status"], e["employee_label"], e["attempted_action"]), ("Blocked by Perimeter Lock", "Asha (EMP001)", "Mobile Web Punch"))
        self.assertIn("km", e["breach_reason"])
        self.assertEqual(self.admin.patch(f"{H}/perimeter-events/{e['id']}/", {"status": "Resolved"}, format="json").status_code, 400)
        self.assertEqual(self.admin.patch(f"{H}/perimeter-events/{e['id']}/", {"resolution_note": "Called employee"}, format="json").status_code, 200)
        self.assertEqual(self.admin.post(f"{H}/perimeter-events/{e['id']}/override/", {}, format="json").status_code, 400)
        o = self.admin.post(f"{H}/perimeter-events/{e['id']}/override/", {"note": "Approved by HR head"}, format="json")
        self.assertEqual((o.json()["data"]["status"], o.json()["data"]["resolved_by"] is not None), ("Overridden by HR", True))
        self.assertEqual(self.admin.post(f"{H}/perimeter-events/{e['id']}/resolve/", {}, format="json").status_code, 409)
        m = self.admin.post(f"{H}/perimeter-events/", {"employee_code": "EMP002", "attempted_action": "Web Check-in Punch", "breach_reason": "VPN",
                                                       "detected_ip": "152.58.12.98", "status": "Redirected to WFH Portal"}, format="json")
        self.assertEqual(m.status_code, 201, m.json())
        self.assertEqual(self.admin.get(f"{H}/perimeter-events/?status=Redirected to WFH Portal").json()["meta"]["total"], 1)
        self.assertEqual(self.admin.post(f"{H}/perimeter-events/", {"attempted_action": "x"}, format="json").status_code, 400)
        self.assertEqual(self.admin.delete(f"{H}/perimeter-events/{m.json()['data']['id']}/").status_code, 200)
        self.assertEqual(self.other_admin.get(f"{H}/perimeter-events/{e['id']}/").status_code, 404)

    def test_field_force_crud_summary_claim_and_employee_ping(self):
        a = self.admin.post(f"{H}/field/agents/", {"employee_code": "EMP004", "territory": "Mumbai Metropolitan Region (MMR)", "per_km_rate": 12}, format="json")
        self.assertEqual(a.status_code, 201, a.json())
        aid = a.json()["data"]["id"]
        self.assertEqual(self.admin.post(f"{H}/field/agents/", {"employee_code": "EMP004"}, format="json").status_code, 409)
        self.assertEqual(self.admin.post(f"{H}/field/agents/", {"employee_code": "EMP004x"}, format="json").status_code, 400)
        d = timezone.localdate()
        base = timezone.now().replace(hour=9, minute=0, second=0, microsecond=0)
        pts = [("Punch-In", 19.076, 72.8777), ("Client Check-In", 19.0596, 72.8295), ("Interval Ping", 19.0657, 72.8688), ("Client Check-In", 19.0712, 72.8624)]
        pid = None
        for i, (t, la, lo) in enumerate(pts):
            r = self.admin.post(f"{H}/field/points/", {"agent_id": aid, "recorded_at": (base + timedelta(hours=i)).isoformat(), "point_type": t, "latitude": la,
                                                       "longitude": lo, "client_name": "Tata Consultancy" if t == "Client Check-In" else None,
                                                       "battery_percent": 98 - i, "speed_kmh": 28, "site_verified": t == "Client Check-In" and i == 1}, format="json")
            self.assertEqual(r.status_code, 201, r.json())
            pid = pid or r.json()["data"]["id"]
        for bad in ({"agent_id": aid, "recorded_at": "x", "latitude": 1, "longitude": 1}, {"agent_id": aid, "recorded_at": base.isoformat(), "latitude": 99, "longitude": 1},
                    {"agent_id": 9999, "recorded_at": base.isoformat(), "latitude": 1, "longitude": 1}, {"agent_id": aid, "recorded_at": base.isoformat(), "latitude": 1,
                                                                                                          "longitude": 1, "battery_percent": 500}):
            self.assertEqual(self.admin.post(f"{H}/field/points/", bad, format="json").status_code, 400, bad)
        s = self.admin.get(f"{H}/field/summary/?employee_code=EMP004&date={d}").json()["data"]
        expect = sum(en.haversine_m(pts[i][1], pts[i][2], pts[i + 1][1], pts[i + 1][2]) for i in range(3)) / 1000
        self.assertAlmostEqual(s["total_distance_km"], round(expect, 1), places=1)
        self.assertEqual((s["client_visits"], s["verified_client_visits"], s["points"], s["ping_status"]), (2, 1, 4, "Ping Every 30 Mins"))
        self.assertAlmostEqual(s["travel_claim_amount"], round(round(expect, 2) * 12, 2), places=1)
        self.assertEqual(len(s["trail"]), 4)
        self.assertEqual(self.admin.get(f"{H}/field/route/?agent_id={aid}&date={d}").json()["data"]["route"][0]["type"], "Punch-In")
        c = self.admin.get(f"{H}/field/travel-claim/?agent_id={aid}&date={d}&download=csv")
        self.assertIn("Distance (km)", c.content.decode("utf-8-sig"))
        self.assertEqual(self.admin.patch(f"{H}/field/points/{pid}/", {"notes": "Regional base"}, format="json").json()["data"]["notes"], "Regional base")
        self.assertEqual(self.admin.get(f"{H}/field/points/?employee_code=EMP004&point_type=Client Check-In").json()["meta"]["total"], 2)
        self.assertEqual(self.admin.get(f"{H}/field/summary/?employee_code=EMP001").status_code, 404)
        # employee side
        before = FieldTrackPoint.objects.count()
        r = self.cl["fiona"].post(f"{ME}/field/ping/", {"point_type": "Punch-In", "latitude": 19.076, "longitude": 72.8777, "battery_percent": 80, "site_verified": True}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        self.assertIsNotNone(r.json()["data"]["attendance_record_id"])
        self.assertEqual(FieldTrackPoint.objects.get(pk=r.json()["data"]["point"]["id"]).site_verified, False)        # the client cannot self-verify a site
        self.assertEqual(AttendancePunchMeta.objects.get().perimeter_status, "Field Force")
        self.assertEqual(self.cl["fiona"].post(f"{ME}/field/ping/", {"latitude": 19.07, "longitude": 72.87}, format="json").status_code, 201)
        self.assertEqual(self.cl["fiona"].post(f"{ME}/field/ping/", {"latitude": 19.07}, format="json").status_code, 400)
        self.assertEqual(self.cl["asha"].post(f"{ME}/field/ping/", {"latitude": 19.07, "longitude": 72.87}, format="json").status_code, 403)
        self.assertEqual(self.cl["fiona"].get(f"{ME}/field/trail/").status_code, 200)
        self.assertEqual(self.cl["asha"].get(f"{ME}/field/trail/").status_code, 403)
        self.assertEqual(FieldTrackPoint.objects.count(), before + 2)
        self.assertEqual(self.admin.delete(f"{H}/field/agents/{aid}/").status_code, 200)


class DashboardTests(ABase):
    def test_cards_and_charts(self):
        today = timezone.localdate()
        dev = BiometricDevice.objects.create(company=self.co, device_code="BIO-DEV-01", name="eSSL SilkBio-101TC", vendor="eSSL", status="Enabled",
                                             last_seen_at=timezone.now(), branch=None)
        self.rec(self.asha, today, "09:05", "18:00", source="Biometric Device", perimeter_status="Device Verified", device=dev)
        self.rec(self.ravi, today, "09:10", None, source="GPS Mobile Punch", perimeter_status="In-Perimeter Verified")
        self.rec(self.meera, today, "09:20", None, source="Web Portal Punch", perimeter_status="Authorized WFH")
        for i in range(3):
            BiometricPunch.objects.create(company=self.co, device=dev, device_code="BIO-DEV-01", biometric_id=f"F{i}", punch_time=timezone.now() - timedelta(minutes=i),
                                          sync_status="Reconciled" if i < 2 else "Unmatched")
        PerimeterEvent.objects.create(company=self.co, employee=self.stranger, employee_code="EMP103", event_time=timezone.now(), attempted_action="Web Check-in Punch",
                                      breach_reason="Outside", status="Blocked by Perimeter Lock")
        WFHPolicy.objects.create(company=self.co, is_enabled=True, weekly_quota_days=2)
        WFHRequest.objects.create(company=self.co, Employee_ID="EMP003", Name="Meera", wfh_date=today, status="Approved")
        ag = FieldForceAgent.objects.create(company=self.co, employee=self.fiona)
        FieldTrackPoint.objects.create(company=self.co, agent=ag, recorded_at=timezone.now(), latitude=19.0, longitude=72.8)
        d = self.admin.get(f"{H}/dashboard/").json()["data"]
        c = d["cards"]
        self.assertEqual(c["todays_verified_punches"]["value"], 4)                    # 3 check-ins + 1 check-out
        self.assertEqual(c["todays_verified_punches"]["caption"], "67% Synced via Hardware API")
        self.assertEqual((c["perimeter_compliance"]["value"], c["perimeter_compliance"]["caption"]), (75.0, "Strict Wi-Fi & 200m GPS Enforced"))
        self.assertEqual((c["active_field_force"]["label"], c["active_field_force"]["caption"]), ("1 Active", "30 min Continuous Interval Ping"))
        self.assertEqual((c["approved_wfh_today"]["label"], c["approved_wfh_today"]["caption"]), ("1 Employees", "2 Day/Week Quota Compliant"))
        src = {s["key"]: s["count"] for s in d["punch_source_breakdown"]["series"]}
        self.assertEqual((src["biometric"], src["mobile_gps"], src["web_portal"]), (1, 1, 1))
        self.assertEqual(d["perimeter_audit"]["badge"], "1 Breaches Today")
        wk = d["perimeter_audit"]["weekly"][-1]
        self.assertEqual((wk["inside_perimeter"], wk["authorized_wfh"], wk["blocked_out_of_bounds"]), (2, 1, 1))
        hw = d["hardware_network"]["devices"][0]
        self.assertEqual((hw["connection"], hw["today_punches"], hw["operational_percent"]), ("Online", 3, 66.7))
        self.assertEqual(d["badges"]["perimeter_engine"], "Perimeter Engine Active")
        self.assertEqual(self.admin.get(f"{H}/dashboard/?date=bad").status_code, 400)


# ------------------------------------------------------------------
# eSSL MySQL -> HRMS sync (a SQLite file stands in for the eSSL database)
# ------------------------------------------------------------------

class EsslSyncTests(ABase):
    def setUp(self):
        super().setUp()
        self.tmp = tempfile.mkdtemp()
        self.db = os.path.join(self.tmp, "essl.db")
        self.d = yesterday()
        self.con = sqlite3.connect(self.db)
        self.tables = set()
        BiometricEnrollment.objects.create(company=self.co, employee=self.asha, biometric_id="11", verification_mode="Fingerprint")
        BiometricEnrollment.objects.create(company=self.co, employee=self.ravi, biometric_id="12", verification_mode="Fingerprint")

    def tearDown(self):
        self.con.close()

    def log(self, rid, user, when, device=1, direction=None):
        t = f"DeviceLogs_{when.month}_{when.year}"
        if t not in self.tables:
            self.con.execute(f"CREATE TABLE {t} (DeviceLogId INTEGER PRIMARY KEY, DeviceId INTEGER, UserId TEXT, LogDate TEXT, Direction TEXT)")
            self.tables.add(t)
        self.con.execute(f"INSERT INTO {t} VALUES (?,?,?,?,?)", (rid, device, str(user), when.strftime("%Y-%m-%d %H:%M:%S"), direction))
        self.con.commit()

    def source(self, **kw):
        r = self.admin.post(f"{H}/essl/sources/", {"name": "eSSL Server", "source_type": "sqlite", "host": self.db, "password": "s3cret!",
                                                   "start_from_date": str(self.d), "device_map": {"1": "BIO-DEV-01"}, **kw}, format="json")
        self.assertEqual(r.status_code, 201, r.json())
        return r.json()["data"]

    def test_source_crud_security(self):
        s = self.source()
        self.assertNotIn("password", s)
        self.assertTrue(s["password_set"])
        obj = EsslSource.objects.get(pk=s["id"])
        self.assertNotIn("s3cret!", obj.password_enc)                                        # stored encrypted
        self.assertEqual(self.admin.post(f"{H}/essl/sources/", {"name": "ESSL server", "source_type": "sqlite", "host": "x"}, format="json").status_code, 409)
        for bad in ({"name": "a", "host": "x", "table_pattern": "x; DROP TABLE y"}, {"name": "a", "host": "x", "table_pattern": "NoYear_{month}"},
                    {"name": "a", "host": "x", "id_column": "id; drop"}, {"name": "a", "host": "x", "user_column": "u u"}, {"name": "a", "host": "x", "batch_size": 99999},
                    {"name": "a", "host": "x", "device_map": ["x"]}, {"name": "a", "host": "x", "source_type": "oracle"}, {"name": "", "host": "x"}):
            self.assertEqual(self.admin.post(f"{H}/essl/sources/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.admin.patch(f"{H}/essl/sources/{s['id']}/", {"poll_interval_seconds": 10, "enabled": False}, format="json").json()["data"]["enabled"], False)
        self.assertTrue(self.admin.patch(f"{H}/essl/sources/{s['id']}/", {"password": "n3w"}, format="json").json()["data"]["password_set"])
        self.assertEqual(self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").status_code, 409)           # disabled
        self.assertEqual(self.other_admin.get(f"{H}/essl/sources/{s['id']}/").status_code, 404)
        self.assertEqual(self.admin.delete(f"{H}/essl/sources/{s['id']}/").status_code, 200)

    def test_connection_test_and_blocked_hosts(self):
        s = self.source()
        self.log(1, 11, at(self.d, "09:10"))
        t = self.admin.post(f"{H}/essl/sources/{s['id']}/test/", {}, format="json").json()["data"]
        self.assertTrue(t["connected"])
        self.assertTrue(any(x["exists"] and x["rows"] == 1 for x in t["tables"]))
        pre = self.admin.post(f"{H}/essl/sources/test/", {"name": "n", "source_type": "sqlite", "host": self.db}, format="json").json()["data"]
        self.assertTrue(pre["connected"])
        self.assertEqual(EsslSource.objects.count(), 1)                                      # testing did not save anything
        bad = self.admin.post(f"{H}/essl/sources/test/", {"name": "m", "source_type": "mysql", "host": "169.254.169.254"}, format="json").json()["data"]
        self.assertFalse(bad["connected"])
        self.assertIn("blocked", bad["message"])
        loop = self.admin.post(f"{H}/essl/sources/test/", {"name": "m", "source_type": "mysql", "host": "127.0.0.1"}, format="json").json()["data"]
        self.assertFalse(loop["connected"])
        with override_settings(ESSL_ALLOW_SQLITE_SOURCE=False):
            off = self.admin.post(f"{H}/essl/sources/{s['id']}/test/", {}, format="json").json()["data"]
            self.assertFalse(off["connected"])

    def test_sync_cursor_direction_gap_unmatched_idempotent(self):
        s = self.source(min_gap_minutes=2)
        self.log(1, 11, at(self.d, "09:10"))                                 # auto direction -> IN
        self.log(2, 11, at(self.d, "09:11"))                                 # double scan within 2 min -> Duplicate
        self.log(3, 12, at(self.d, "09:30"), direction="in")                 # explicit direction
        self.log(4, 99, at(self.d, "09:31"))                                 # not enrolled -> Unmatched
        self.log(5, 11, at(self.d, "18:05"))                                 # auto -> OUT
        self.log(6, 12, at(self.d, "18:40"), direction="out")
        r = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]
        run = r["run"]
        self.assertEqual((run["status"], run["rows_fetched"], run["reconciled"], run["duplicates"], run["unmatched"]), ("Success", 6, 4, 1, 1))
        self.assertEqual(run["detail"]["unmatched_ids"], ["99"])
        key = f"{self.d.year}_{self.d.month}"
        self.assertEqual(r["source"]["cursor"][key], 6)
        a = EMP_check_in_check_out.objects.get(Employee_ID="EMP001")
        self.assertEqual((a.login_time, a.logout_time), ("09:10:00", "18:05:00"))
        b = EMP_check_in_check_out.objects.get(Employee_ID="EMP002")
        self.assertEqual((b.login_time, b.logout_time), ("09:30:00", "18:40:00"))
        self.assertEqual(AttendancePunchMeta.objects.filter(checkin=a).get().perimeter_status, "Device Verified")
        self.assertEqual(BiometricPunch.objects.filter(device_code="BIO-DEV-01").count(), 6)
        # idempotent: nothing new, nothing duplicated
        again = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual((again["rows_fetched"], again["reconciled"]), (0, 0))
        self.assertEqual(EMP_check_in_check_out.objects.count(), 2)
        # re-reading from the start creates nothing new either
        self.admin.post(f"{H}/essl/sources/{s['id']}/reset-cursor/", {"mode": "start"}, format="json")
        again = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual((again["rows_fetched"], again["accepted"]), (6, 0))
        self.assertEqual(BiometricPunch.objects.count(), 6)
        # the unmatched user is mapped later -> reconciled automatically
        self.admin.post(f"{H}/enrollments/", {"employee_code": "EMP003", "biometric_id": "99"}, format="json")
        self.assertEqual(EMP_check_in_check_out.objects.filter(Employee_ID="EMP003").count(), 1)

    def test_batches_drain_reset_latest_and_history(self):
        s = self.source(batch_size=3)
        for i in range(1, 8):
            self.log(i, 11 if i % 2 else 12, at(self.d, f"09:{i * 5:02d}"), direction="in" if i % 2 else "out")
        one = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]
        self.assertEqual(one["run"]["rows_fetched"], 3)                     # batch limit
        dr = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/?drain=true", {}, format="json").json()["data"]
        self.assertEqual(dr["totals"]["rows_fetched"], 4)
        self.admin.post(f"{H}/essl/sources/{s['id']}/reset-cursor/", {"mode": "latest"}, format="json")
        self.log(8, 11, at(self.d, "17:00"), direction="out")
        new = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual(new["rows_fetched"], 1)
        self.assertEqual(self.admin.post(f"{H}/essl/sources/{s['id']}/reset-cursor/", {"mode": "set"}, format="json").status_code, 400)
        self.assertEqual(self.admin.post(f"{H}/essl/sources/{s['id']}/reset-cursor/", {"mode": "x"}, format="json").status_code, 400)
        runs = self.admin.get(f"{H}/essl/runs/?source_id={s['id']}").json()
        self.assertGreaterEqual(runs["meta"]["total"], 4)
        self.assertEqual({r["status"] for r in runs["data"]}, {"Success", "Partial"})        # OUT punches without a check-in are reported as failed
        rid = runs["data"][0]["id"]
        self.assertEqual(self.admin.get(f"{H}/essl/runs/{rid}/").status_code, 200)
        self.assertEqual(self.other_admin.get(f"{H}/essl/runs/{rid}/").status_code, 404)
        self.assertEqual(self.admin.delete(f"{H}/essl/runs/{rid}/").status_code, 200)

    def test_start_from_date_missing_table_and_errors(self):
        s = self.source()
        self.assertEqual(self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]["status"], "Success")   # no table yet
        self.log(1, 11, at(self.d - timedelta(days=3), "09:00"))            # older than start_from_date
        self.log(2, 11, at(self.d, "09:00"))
        self.log(3, 11, timezone.localtime(timezone.now() + timedelta(hours=3)))   # future -> ignored
        run = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual((run["accepted"], run["reconciled"]), (1, 1))
        bad = self.admin.post(f"{H}/essl/sources/", {"name": "broken", "source_type": "sqlite", "host": os.path.join(self.tmp, "nope.db")}, format="json").json()["data"]
        r = self.admin.post(f"{H}/essl/sources/{bad['id']}/sync/", {}, format="json")
        self.assertEqual((r.json()["data"]["run"]["status"], r.json()["data"]["source"]["last_status"]), ("Error", "Error"))
        self.assertTrue(r.json()["data"]["run"]["error"])

    def test_auto_enroll_and_concurrent_guard(self):
        s = self.source(auto_enroll=True)
        self.log(1, "EMP003", at(self.d, "09:05"))
        run = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual(run["reconciled"], 1)
        self.assertTrue(BiometricEnrollment.objects.filter(biometric_id="EMP003", employee=self.meera).exists())
        EsslSource.objects.filter(pk=s["id"]).update(last_status="Running", running_since=timezone.now())
        blocked = self.admin.post(f"{H}/essl/sources/{s['id']}/sync/", {}, format="json").json()["data"]["run"]
        self.assertEqual(blocked["status"], "Error")
        self.assertIn("already running", blocked["error"])

    def test_management_command_and_sync_all_and_dashboard(self):
        s = self.source()
        self.log(1, 11, at(self.d, "09:00"), direction="in")
        out = io.StringIO()
        call_command("essl_sync", "--once", "--source-id", str(s["id"]), stdout=out)
        self.assertIn("Success: fetched=1 reconciled=1", out.getvalue())
        call_command("essl_sync", "--loop", "--interval", "1", "--max-seconds", "1", "--company-id", str(self.co.company_id), stdout=io.StringIO())
        self.assertEqual(self.admin.post(f"{H}/essl/sources/sync-all/", {}, format="json").json()["data"]["sources"], 1)
        d = self.admin.get(f"{H}/dashboard/").json()["data"]["sync_engine"]
        self.assertTrue(d["connected"])
        self.assertEqual(d["essl_sources"][0]["name"], "eSSL Server")


# ------------------------------------------------------------------
# eSSL "Monthly Status Report (Basic Work Duration)" PDF import
# ------------------------------------------------------------------

def make_report_pdf(employees, period="Aug 01 2026 To Aug 31 2026"):
    from reportlab.lib.pagesizes import landscape, A4
    from reportlab.pdfgen import canvas
    buf = io.BytesIO()
    W, Hh = landscape(A4)
    c = canvas.Canvas(buf, pagesize=(W, Hh))
    c.setFont("Helvetica", 6)
    top = lambda t: Hh - t
    c.setFont("Helvetica-Bold", 9)
    c.drawString(300, top(20), "Monthly Status Report (Basic Work Duration)")
    c.setFont("Helvetica", 6)
    c.drawString(350, top(40), period)
    c.drawString(8, top(60), "Company:")
    c.drawString(60, top(60), "Default")
    c.drawString(700, top(60), "Printed On : Sep 09 2026 12:18")
    c.drawString(8, top(100), "Department:")
    c.drawString(60, top(100), "Default")
    y = 120
    for e in employees:
        c.drawString(8, top(y), "Emp. Code:")
        c.drawString(105, top(y), e["code"])
        c.drawString(260, top(y), "Emp. Name:")
        c.drawString(320, top(y), e["name"])
        for i, lab in enumerate(("Status", "InTime", "OutTime", "Total")):
            c.drawString(7, top(y + 14 + i * 14.8), lab)
        for d, cell in e["days"].items():
            x = 38.0 + (d - 1) * COLW + 2.6
            st = cell[0]
            if st == "WO½P":
                c.drawString(x, top(y + 14), "WO½")
                c.drawString(x, top(y + 22), "P")
            else:
                c.drawString(x, top(y + 14), st)
            if cell[1]:
                c.drawString(x, top(y + 28.8), cell[1])
            if cell[2]:
                c.drawString(x, top(y + 43.6), cell[2])
            c.drawString(x, top(y + 58.4), cell[3] if len(cell) > 3 else "00:00")
        y += 90
    c.showPage()
    c.save()
    return buf.getvalue()


COLW = 25.2


def unittest_skip_if_missing(path):
    import unittest
    return unittest.skipUnless(os.path.exists(path), "real eSSL PDF not available")


@override_settings(MEDIA_ROOT="/tmp/att_test_media", ESSL_ALLOW_SQLITE_SOURCE=True)
class EsslPdfTests(ABase):
    def pdf(self):
        return make_report_pdf([
            {"code": "4", "name": "Rahul Four", "days": {1: ("A", "18:54", "", "00:00"), 3: ("P", "09:51", "16:19", "6:28"), 8: ("WO½P", "10:29", "14:11", "3:42"),
                                                        10: ("A", "", "", "00:00"), 11: ("½P", "15:00", "18:19", "3:17")}},
            {"code": "320", "name": "Three Twenty", "days": {1: ("WOP", "11:00", "21:14", "10:14"), 4: ("P", "10:55", "20:17", "9:21")}},
            {"code": "9", "name": "Nobody", "days": {2: ("A", "", "", "00:00")}}])

    def post(self, data=None, content=None, name="rep.pdf", client=None, **extra):
        f = io.BytesIO(content if content is not None else self.pdf())
        f.name = name
        return (client or self.admin).post(f"{H}/essl/import/pdf/", {"file": f, **(data or {})}, format="multipart", **extra)

    def test_parser_reads_layout(self):
        from People import essl_pdf
        p = essl_pdf.parse_report(io.BytesIO(self.pdf()))
        self.assertEqual((str(p["period"][0]), str(p["period"][1]), p["company"]), ("2026-08-01", "2026-08-31", "Default"))
        by = {e["code"]: e for e in p["employees"]}
        self.assertEqual(len(by), 3)
        self.assertEqual(by["4"]["name"], "Rahul Four")
        self.assertEqual(by["4"]["days"][3], {"status": "P", "status_label": "Present", "in": "09:51", "out": "16:19", "total": "6:28"})
        self.assertEqual(by["4"]["days"][8]["status"], "WO½P")                                  # wrapped two-line status
        self.assertEqual(by["4"]["days"][1]["in"], "18:54")
        self.assertIsNone(by["4"]["days"][1]["out"])
        self.assertEqual(essl_pdf.summarize(p)["missing_out_days"], 1)
        with self.assertRaises(essl_pdf.PdfFormatError):
            essl_pdf.parse_report(io.BytesIO(make_report_pdf([]).replace(b"Monthly Status", b"Monthly Xtatus")))

    def test_dry_run_default_writes_nothing(self):
        r = self.post()
        self.assertEqual(r.status_code, 200, r.json())
        d = r.json()["data"]
        self.assertTrue(d["dry_run"])
        self.assertEqual((d["report"]["employees_in_report"], d["report"]["punch_days"]), (3, 6))
        self.assertEqual({u["essl_code"] for u in d["unmatched_employees"]}, {"4", "320"})
        self.assertEqual((BiometricPunch.objects.count(), EsslSyncRun.objects.count()), (0, 0))

    def test_import_with_mapping_enrollments_and_day_status(self):
        r = self.post({"dry_run": "false", "employee_map": '{"4": "EMP001", "320": "EMP002"}', "save_enrollments": "true"})
        self.assertEqual(r.status_code, 201, r.json())
        d = r.json()["data"]
        self.assertEqual(len(d["matched_employees"]), 2)
        self.assertEqual(len(d["enrollments_created"]), 2)
        self.assertEqual((d["stats"]["reconciled"], d["stats"]["failed"], d["stats"]["unmatched"]), (11, 0, 0))
        rec = EMP_check_in_check_out.objects.get(Employee_ID="EMP001", login_date=date(2026, 8, 3))
        self.assertEqual((rec.login_time, rec.logout_time), ("09:51:00", "16:19:00"))
        self.assertEqual(AttendancePunchMeta.objects.get(checkin=rec).source, "Biometric Device")
        open_rec = EMP_check_in_check_out.objects.get(Employee_ID="EMP001", login_date=date(2026, 8, 1))
        self.assertIsNone(open_rec.logout_time)                                               # the report had no out punch that day
        st = {a.date.day: a.status for a in AttendanceEmp.objects.filter(Employee_ID="EMP001")}
        self.assertEqual(st, {3: "Present", 8: "Half Day", 11: "Half Day"})                   # present_only: no A / WO rows
        self.assertEqual(AttendanceEmp.objects.get(Employee_ID="EMP002", date=date(2026, 8, 1)).status, "Present")   # WOP
        self.assertEqual(BiometricEnrollment.objects.filter(biometric_id__in=["4", "320"]).count(), 2)
        run = EsslSyncRun.objects.get()
        self.assertEqual((run.kind, run.file_name, run.status), ("pdf-import", "rep.pdf", "Success"))
        # repeat = nothing new
        again = self.post({"dry_run": "false"}).json()["data"]
        self.assertEqual((again["already_received"], again["stats"]["accepted"], again["day_statuses_written"]), (11, 0, 0))
        self.assertEqual(EMP_check_in_check_out.objects.filter(Employee_ID="EMP001").count(), 4)
        self.assertEqual(AttendanceEmp.objects.filter(Employee_ID="EMP001").count(), 3)
        # live punches of the same people now also map (enrollment was saved)
        self.assertEqual(en.resolve_employee(self.co, "4"), self.asha)

    def test_day_status_modes_overwrite_and_include_codes(self):
        AttendanceEmp.objects.create(Employee_ID="EMP001", company=self.co, Name="Asha", date=date(2026, 8, 3), status="Absent")
        r = self.post({"dry_run": "false", "employee_map": '{"4": "EMP001"}', "include_codes": "4", "day_status": "all"}).json()["data"]
        self.assertEqual(r["day_statuses_skipped_existing"], 1)
        self.assertEqual(AttendanceEmp.objects.get(Employee_ID="EMP001", date=date(2026, 8, 3)).status, "Absent")      # existing row kept
        self.assertEqual(AttendanceEmp.objects.get(Employee_ID="EMP001", date=date(2026, 8, 10)).status, "Absent")      # 'all' also writes A
        self.assertFalse(EMP_check_in_check_out.objects.filter(Employee_ID="EMP002").exists())
        self.post({"dry_run": "false", "employee_map": '{"4": "EMP001"}', "include_codes": "4", "day_status": "present_only", "overwrite_day_status": "true"})
        self.assertEqual(AttendanceEmp.objects.get(Employee_ID="EMP001", date=date(2026, 8, 3)).status, "Present")
        none = self.post({"dry_run": "false", "employee_map": '{"320": "EMP002"}', "day_status": "none"}).json()["data"]
        self.assertEqual(none["day_statuses_written"], 0)

    def test_auto_enroll_and_validation_and_permissions(self):
        self.mk_emp("320", "Coincidence")                                                     # HRMS code equals the eSSL code
        r = self.post({"dry_run": "false", "auto_enroll": "true", "save_enrollments": "true"}).json()["data"]
        self.assertEqual([m["essl_code"] for m in r["matched_employees"]], ["320"])
        self.assertEqual(self.post({"day_status": "weird"}).status_code, 400)
        self.assertEqual(self.post({"employee_map": "not json"}).status_code, 400)
        self.assertEqual(self.post(content=b"hello, not a pdf").status_code, 400)
        self.assertEqual(self.post(content=make_report_pdf([]).replace(b"Monthly Status", b"Monthly Xtatus")).status_code, 400)
        self.assertEqual(self.admin.post(f"{H}/essl/import/pdf/", {}, format="multipart").status_code, 400)
        self.assertEqual(self.post(client=self.cl["hr"]).status_code, 403)                   # edit is not manage
        self.assertEqual(self.post(client=APIClient()).status_code, 401)
        self.assertEqual(self.post({"employee_map": '{"4": "EMP001"}'}, client=self.cl["boss"]).status_code, 200)

    @unittest_skip_if_missing(REAL_PDF)
    def test_real_essl_report(self):
        with open(REAL_PDF, "rb") as fh:
            data = fh.read()
        d = self.post(content=data, name="BasicWorkDurationReport_August.pdf").json()["data"]
        self.assertEqual((d["report"]["employees_in_report"], d["report"]["punch_days"], d["report"]["missing_out_days"]), (118, 314, 22))
        self.assertEqual(d["period"], {"from": "2026-08-01", "to": "2026-08-31"})
        m = self.post({"dry_run": "false", "employee_map": '{"4": "EMP001", "320": "EMP002", "28": "EMP003"}'}, content=data).json()["data"]
        r = EMP_check_in_check_out.objects.get(Employee_ID="EMP001", login_date=date(2026, 8, 3))
        self.assertEqual((r.login_time, r.logout_time), ("09:51:00", "16:19:00"))
        first = EMP_check_in_check_out.objects.get(Employee_ID="EMP002", login_date=date(2026, 8, 1))
        self.assertEqual((first.login_time, first.logout_time), ("11:00:00", "21:14:00"))
        self.assertEqual(m["stats"]["failed"], 0)
