# python manage.py test Timesheet
from datetime import timedelta
from decimal import Decimal

from django.test import TestCase
from django.utils import timezone
from rest_framework.test import APIClient

from Company.models import company_details
from Employee.leave_models import ReportingHierarchy
from Employee.models import Department, EmployeeDT, EmployeeRole
from Timesheet.models import OvertimeClaim, TimesheetEntry


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")


def client(user):
    c = APIClient()
    c.force_authenticate(user=user)
    return c


def mk_emp(co, name, dept=None, **kw):
    e = EmployeeDT(company=co, name=name, email=f"{name.split()[0].lower()}@x.com", Employee_Status="Activate", is_active=True,
                   department=dept, Department=dept.name if dept else None, **kw)
    e.save()
    return e


class TimesheetTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("ts1@x.com"), mk_company("ts2@x.com")
        self.a = client(self.co)
        self.dept = Department.objects.create(company=self.co, name="Technology & Engineering")
        self.boss = mk_emp(self.co, "Amit Joshi", self.dept)
        self.rahul = mk_emp(self.co, "Rahul Sharma", self.dept, Overtime_Rate=Decimal("650"))
        self.vik = mk_emp(self.co, "Vikram Rao", self.dept, Overtime_Rate=Decimal("550"))
        for e in (self.rahul, self.vik):
            ReportingHierarchy.objects.create(company=self.co, Employee_ID=e.employee_code, manager_code=self.boss.employee_code, hod_code=self.boss.employee_code)
        self.P = lambda u, d=None: self.a.post(u, d or {}, format="json")
        self.t = timezone.localdate()
        self.zen = self.j(self.P("/api/timesheet/projects/", {"code": "PRJ-ZEN-01", "title": "Zenith Cloud Migration Platform",
                          "client_department": "Technology & Engineering", "budget_hours": 1000}), 201)["data"]

    def j(self, r, code=None):
        if code:
            self.assertEqual(r.status_code, code, r.content)
        return r.json()

    def me(self, emp):
        return client(EmployeeDT.objects.get(pk=emp.pk))

    def entry(self, emp, hours, day=None, **kw):
        body = {"employee_code": emp.employee_code, "project": "PRJ-ZEN-01", "work_date": str(day or self.t), "task_summary": "Database Indexing", "hours": hours}
        body.update(kw)
        return self.j(self.P("/api/timesheet/entries/", body), 201)["data"]

    # ---------- projects + allocation ----------
    def test_projects_and_allocations(self):
        self.assertEqual(self.P("/api/timesheet/projects/", {"code": "prj-zen-01", "title": "dup"}).status_code, 400)
        self.assertEqual(self.P("/api/timesheet/projects/", {"title": "x", "start_date": "2026-05-02", "end_date": "2026-05-01"}).status_code, 400)
        auto = self.j(self.P("/api/timesheet/projects/", {"title": "Auto code"}), 201)["data"]
        self.assertEqual(auto["code"], "PRJ-02")
        al = self.j(self.P("/api/timesheet/allocations/", {"project": "PRJ-ZEN-01", "employee_code": self.rahul.employee_code, "role": "Backend", "allocation_percent": 50}), 201)["data"]
        self.assertEqual(self.P("/api/timesheet/allocations/", {"project": self.zen["id"], "employee_code": self.rahul.employee_code}).status_code, 400)   # duplicate
        r = self.P(f"/api/timesheet/projects/{auto['id']}/allocate/", {"employee_codes": [self.rahul.employee_code, self.vik.employee_code], "allocation_percent": 60})
        out = self.j(r, 201)["data"]
        self.assertEqual((len(out["allocations"]), len(out["failed"])), (1, 1))        # rahul would be 110% -> blocked, vik ok
        row = [x for x in self.j(self.a.get("/api/timesheet/projects/"))["data"] if x["code"] == "PRJ-ZEN-01"][0]
        self.assertEqual((row["allocated_engineers"], row["budget_status"]), ("0.5 FTE", "On Budget (0%)"))
        self.j(self.a.patch(f"/api/timesheet/allocations/{al['id']}/", {"allocation_percent": 100}, format="json"), 200)
        self.j(self.a.patch(f"/api/timesheet/projects/{self.zen['id']}/", {"status": "Completed"}, format="json"), 200)
        self.assertEqual(self.j(self.a.get(f"/api/timesheet/projects/{self.zen['id']}/"))["data"]["budget_status"], "Completed")
        self.j(self.a.delete(f"/api/timesheet/allocations/{al['id']}/"), 200)
        self.assertEqual(self.a.get(f"/api/timesheet/allocations/{al['id']}/").status_code, 404)

    # ---------- entries, overtime, approvals ----------
    def test_entries_overtime_and_approval(self):
        e1 = self.entry(self.rahul, 8.5)
        self.assertEqual((e1["overtime_hours"], e1["status"], e1["hours_label"], e1["overtime_label"]), (0.5, "Submitted", "8.5 Hrs", "0.5 OT"))
        self.assertEqual(e1["approver_code"], self.boss.employee_code)
        e2 = self.entry(self.rahul, 2, task_summary="Second task")                       # same day: 10.5 total -> OT 2.5, goes to the later entry
        self.assertEqual(e2["overtime_hours"], 2.0)
        self.assertEqual(self.P("/api/timesheet/entries/", {"employee_code": self.rahul.employee_code, "project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 20}).status_code, 400)  # >24 day
        self.assertEqual(self.P("/api/timesheet/entries/", {"employee_code": self.rahul.employee_code, "project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 0}).status_code, 400)
        self.assertEqual(self.P("/api/timesheet/entries/", {"employee_code": "NOPE", "project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 1}).status_code, 400)
        self.j(self.a.patch(f"/api/timesheet/entries/{e2['id']}/", {"hours": 1}, format="json"), 200)
        self.assertEqual(self.j(self.a.get(f"/api/timesheet/entries/{e2['id']}/"))["data"]["overtime_hours"], 1.0)
        q = self.j(self.a.get("/api/timesheet/approvals/"), 200)["data"]
        self.assertEqual(q["pending_count"], 2)
        self.assertEqual(self.P(f"/api/timesheet/entries/{e1['id']}/reject/", {}).status_code, 400)           # remarks needed
        self.j(self.P(f"/api/timesheet/approvals/{e1['id']}/reject/", {"remarks": "wrong project"}), 200)
        self.assertEqual(self.P(f"/api/timesheet/entries/{e1['id']}/approve/").status_code, 409)               # already rejected
        self.j(self.P(f"/api/timesheet/entries/{e1['id']}/reopen/"), 200)
        r = self.j(self.P("/api/timesheet/approvals/approve-all-pending/", {}), 200)["data"]
        self.assertEqual(r["approved"], 2)
        q = self.j(self.a.get("/api/timesheet/approvals/"), 200)["data"]
        self.assertEqual(q["pending_count"], 0)
        self.assertIn("have been verified and processed into monthly billing", q["message"])
        csv = self.a.get("/api/timesheet/entries/export/?status=Approved")
        self.assertEqual(csv.status_code, 200)
        self.assertIn(b"Rahul Sharma", csv.content)
        # claim from approved hours
        g = self.j(self.P("/api/timesheet/overtime-claims/generate/", {"month": self.t.month, "year": self.t.year}), 201)["data"]
        self.assertEqual(len(g["created"]), 1)
        c = g["created"][0]
        self.assertEqual((c["approved_ot_hours"], c["hourly_rate"], c["calculated_ot_pay"], c["status"], c["approving_manager"]), (1.5, 650.0, 975.0, "Pending", "Amit Joshi"))
        self.assertEqual(self.j(self.P("/api/timesheet/overtime-claims/generate/", {"month": self.t.month, "year": self.t.year}), 200)["data"]["skipped"][0]["reason"], "claim already exists")
        self.assertEqual(self.P("/api/timesheet/overtime-claims/", {"employee_code": self.rahul.employee_code, "month": self.t.month, "year": self.t.year}).status_code, 400)  # duplicate
        self.j(self.P(f"/api/timesheet/overtime-claims/{c['id']}/approve/"), 200)
        feed = self.j(self.a.get(f"/api/timesheet/overtime-claims/payroll-feed/?month={self.t.month}&year={self.t.year}"), 200)
        self.assertEqual(feed["totals"]["overtime_pay"], 975.0)
        self.assertEqual(self.j(self.P("/api/timesheet/overtime-claims/pass-to-payroll/", {"month": self.t.month, "year": self.t.year}), 200)["data"]["passed"], 1)
        # payroll lock
        self.assertEqual(self.a.patch(f"/api/timesheet/entries/{e2['id']}/", {"hours": 3}, format="json").status_code, 400)
        self.assertEqual(self.a.delete(f"/api/timesheet/entries/{e2['id']}/").status_code, 409)
        self.assertEqual(self.a.delete(f"/api/timesheet/overtime-claims/{c['id']}/").status_code, 409)
        manual = self.j(self.P("/api/timesheet/overtime-claims/", {"employee_code": self.vik.employee_code, "month": 9, "year": 2026, "approved_hours": 6, "status": "Approved"}), 201)["data"]
        self.assertEqual((manual["calculated_ot_pay"], manual["calculated_ot_pay_label"]), (3300.0, "₹3,300"))
        s = self.j(self.a.get(f"/api/timesheet/summary/?month={self.t.month}&year={self.t.year}"), 200)["data"]
        self.assertEqual(s["entries_by_status"]["Approved"], 2)

    def test_settings_manual_overtime_and_filters(self):
        self.j(self.a.put("/api/timesheet/settings/", {"standard_daily_hours": 9}, format="json"), 200)
        self.assertEqual(self.entry(self.rahul, 9.5)["overtime_hours"], 0.5)
        self.assertEqual(self.a.put("/api/timesheet/settings/", {"standard_daily_hours": 30}, format="json").status_code, 400)
        d2 = self.t - timedelta(days=1)
        self.assertEqual(self.entry(self.vik, 8, day=d2, overtime_hours=2)["overtime_hours"], 2.0)       # manual OT kept
        self.assertEqual(len(self.j(self.a.get(f"/api/timesheet/entries/?employee={self.vik.employee_code}"))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get(f"/api/timesheet/entries/?date_from={self.t}&date_to={self.t}"))["data"]), 1)
        self.assertEqual(len(self.j(self.a.get("/api/timesheet/entries/?project=PRJ-ZEN-01&search=indexing"))["data"]), 2)
        self.assertEqual(self.a.get("/api/timesheet/entries/?date_from=bad").status_code, 400)

    # ---------- employee side ----------
    def test_employee_self_service(self):
        me, boss = self.me(self.rahul), self.me(self.boss)
        self.assertEqual(me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 4}, format="json").status_code, 201)
        self.j(self.P("/api/timesheet/allocations/", {"project": "PRJ-ZEN-01", "employee_code": self.vik.employee_code}), 201)
        # allocation enforced once the project has allocations
        r = me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 4}, format="json")
        self.assertEqual(r.status_code, 400)
        self.assertIn("not allocated", r.json()["message"])
        self.j(self.P("/api/timesheet/allocations/", {"project": "PRJ-ZEN-01", "employee_code": self.rahul.employee_code, "allocation_percent": 50}), 201)
        self.assertEqual([p["project"]["code"] for p in self.j(me.get("/employee/timesheet/projects/"))["data"]], ["PRJ-ZEN-01"])
        fut = me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t + timedelta(days=2)), "task_summary": "x", "hours": 1}, format="json")
        self.assertEqual(fut.status_code, 400)
        old = me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t - timedelta(days=90)), "task_summary": "x", "hours": 1}, format="json")
        self.assertEqual(old.status_code, 400)
        d = self.j(me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t - timedelta(days=1)), "task_summary": "Docker hardening", "hours": 9, "save_as_draft": True}, format="json"), 201)["data"]
        self.assertEqual((d["status"], d["overtime_hours"]), ("Draft", 1.0))
        self.j(me.patch(f"/employee/timesheet/entries/{d['id']}/", {"hours": 8.5}, format="json"), 200)
        self.j(me.post(f"/employee/timesheet/entries/{d['id']}/update/", {"task_summary": "Docker hardening v2"}, format="json"), 200)
        sub = self.j(me.post("/employee/timesheet/entries/submit-week/", {"week": str(self.t - timedelta(days=1))}, format="json"), 200)["data"]
        self.assertEqual(sub["submitted"], 1)
        self.assertEqual(me.patch(f"/employee/timesheet/entries/{d['id']}/", {"hours": 1}, format="json").status_code, 409)     # submitted -> locked
        self.j(me.post(f"/employee/timesheet/entries/{d['id']}/recall/"), 200)
        self.j(me.post(f"/employee/timesheet/entries/{d['id']}/submit/"), 200)
        # another employee cannot see / touch it
        self.assertEqual(self.me(self.vik).get(f"/employee/timesheet/entries/{d['id']}/").status_code, 404)
        self.assertEqual(self.me(self.vik).get("/employee/timesheet/entries/").json()["data"], [])
        # manager queue
        pend = self.j(boss.get("/employee/timesheet/approvals/pending/"), 200)["data"]
        self.assertEqual(pend["pending_count"], 2)
        self.assertEqual(self.me(self.vik).post(f"/employee/timesheet/approvals/{d['id']}/approve/", {}, format="json").status_code, 404)
        self.assertEqual(boss.post(f"/employee/timesheet/approvals/{d['id']}/reject/", {}, format="json").status_code, 400)
        self.j(boss.post(f"/employee/timesheet/approvals/{d['id']}/approve/", {"remarks": "ok"}), 200)
        self.assertEqual(self.j(boss.post("/employee/timesheet/approvals/approve-all/", {}, format="json"), 200)["data"]["approved"], 1)
        self.assertEqual(len(self.j(boss.get("/employee/timesheet/team/entries/?status=Approved"))["data"]), 2)
        # overtime claim
        pv = self.j(me.get(f"/employee/timesheet/overtime/preview/?month={self.t.month}&year={self.t.year}"), 200)["data"]
        self.assertGreater(pv["approved_ot_hours"], 0)
        no = me.post("/employee/timesheet/overtime/", {"month": 1, "year": 2020}, format="json")
        self.assertEqual(no.status_code, 400)
        cl = self.j(me.post("/employee/timesheet/overtime/", {"month": self.t.month, "year": self.t.year, "remarks": "Sprint crunch"}, format="json"), 201)["data"]
        self.assertEqual(cl["approving_manager"], "Amit Joshi")
        self.assertEqual(me.post("/employee/timesheet/overtime/", {"month": self.t.month, "year": self.t.year}, format="json").status_code, 400)
        self.assertEqual(len(self.j(boss.get("/employee/timesheet/approvals/overtime/"))["data"]), 1)
        self.j(boss.post(f"/employee/timesheet/approvals/overtime/{cl['id']}/approve/", {}, format="json"), 200)
        self.assertEqual(me.delete(f"/employee/timesheet/overtime/{cl['id']}/").status_code, 409)             # approved -> cannot cancel
        self.assertEqual(self.j(me.get("/employee/timesheet/overtime/"))["data"][0]["status"], "Approved")
        dash = self.j(me.get("/employee/timesheet/dashboard/"), 200)["data"]
        self.assertEqual(dash["my_projects"], 1)
        self.assertEqual(me.get("/employee/timesheet/entries/export/").status_code, 200)
        # delete own draft
        dr = self.j(me.post("/employee/timesheet/entries/", {"project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "tmp", "hours": 1, "save_as_draft": True}, format="json"), 201)["data"]
        self.j(me.post(f"/employee/timesheet/entries/{dr['id']}/delete/"), 200)
        self.assertEqual(me.get(f"/employee/timesheet/entries/{dr['id']}/").status_code, 404)

    # ---------- permissions + B2B isolation ----------
    def test_permissions_and_isolation(self):
        e = self.entry(self.rahul, 8)
        b = client(self.other)
        self.assertEqual(self.j(b.get("/api/timesheet/entries/"), 200)["data"], [])
        self.assertEqual(self.j(b.get("/api/timesheet/projects/"), 200)["data"], [])
        self.assertEqual(b.get(f"/api/timesheet/entries/{e['id']}/").status_code, 404)
        self.assertEqual(b.post(f"/api/timesheet/entries/{e['id']}/approve/", {}, format="json").status_code, 404)
        self.assertEqual(b.post("/api/timesheet/entries/", {"employee_code": self.rahul.employee_code, "project": "PRJ-ZEN-01", "work_date": str(self.t), "task_summary": "x", "hours": 1}, format="json").status_code, 400)
        self.assertEqual(b.post("/api/timesheet/approvals/approve-all-pending/", {}, format="json").json()["data"]["approved"], 0)
        emp = EmployeeDT.objects.get(pk=self.rahul.pk)
        emp.role = None
        self.assertEqual(client(emp).get("/api/timesheet/entries/").status_code, 403)        # plain employee cannot use admin API
        role = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr", can_view_attendance=True)
        emp.role = role
        self.assertEqual(client(emp).get("/api/timesheet/entries/").status_code, 200)
        self.assertEqual(client(emp).post("/api/timesheet/projects/", {"title": "T"}, format="json").status_code, 403)
        self.assertEqual(client(emp).post(f"/api/timesheet/entries/{e['id']}/approve/", {}, format="json").status_code, 403)
        role.can_manage_attendance = True
        emp.role = role
        self.assertEqual(client(emp).post("/api/timesheet/projects/", {"title": "HR made"}, format="json").status_code, 201)
        self.assertEqual(APIClient().get("/api/timesheet/entries/").status_code, 401)
        self.assertEqual(APIClient().get("/employee/timesheet/dashboard/").status_code, 401)
        self.assertEqual(self.a.get("/employee/timesheet/dashboard/").status_code, 403)    # company token on employee API
        self.assertEqual(self.j(self.a.get("/api/timesheet/meta/"), 200)["data"]["tabs"][0], "timesheets")

    # ---------- CRUD completeness ----------
    def test_project_code_reusable_after_delete(self):
        p = self.j(self.P("/api/timesheet/projects/", {"code": "P-X", "title": "Temp"}), 201)["data"]
        self.j(self.a.delete(f"/api/timesheet/projects/{p['id']}/"), 200)
        self.assertEqual(self.a.get(f"/api/timesheet/projects/{p['id']}/").status_code, 404)
        self.j(self.P("/api/timesheet/projects/", {"code": "P-X", "title": "Again"}), 201)

    def test_employee_claim_crud(self):
        me = self.me(self.rahul)
        self.entry(self.rahul, 10, status="Approved")
        c = self.j(me.post("/employee/timesheet/overtime/", {"month": self.t.month, "year": self.t.year}, format="json"), 201)["data"]
        self.assertEqual(self.j(me.patch(f"/employee/timesheet/overtime/{c['id']}/", {"remarks": "a"}, format="json"), 200)["data"]["remarks"], "a")
        self.assertEqual(self.j(me.put(f"/employee/timesheet/overtime/{c['id']}/", {"remarks": "b"}, format="json"), 200)["data"]["remarks"], "b")
        self.assertEqual(self.j(me.post(f"/employee/timesheet/overtime/{c['id']}/update/", {"remarks": "c"}, format="json"), 200)["data"]["remarks"], "c")
        self.j(me.delete(f"/employee/timesheet/overtime/{c['id']}/"), 200)
        self.assertEqual(me.patch(f"/employee/timesheet/overtime/{c['id']}/", {"remarks": "d"}, format="json").status_code, 409)
        c2 = self.j(me.post("/employee/timesheet/overtime/", {"month": self.t.month, "year": self.t.year}, format="json"), 201)["data"]
        self.j(me.post(f"/employee/timesheet/overtime/{c2['id']}/delete/", {}, format="json"), 200)

    def test_overtime_on_directly_approved_and_edited_entry(self):
        e = self.entry(self.rahul, 10, status="Approved")
        self.assertEqual((e["status"], e["overtime_hours"]), ("Approved", 2.0))
        e = self.j(self.a.patch(f"/api/timesheet/entries/{e['id']}/", {"hours": 9}, format="json"), 200)["data"]
        self.assertEqual(e["overtime_hours"], 1.0)
