# ============================================================
# ADDITIVE: Time, Biometrics & Perimeter Security - Employee self-service API
# ------------------------------------------------------------
# Mounted at /employee/attendance-hub/   (see People/att_self_urls.py)
# Auth: Employee JWT. Employees only touch their OWN data; managers (Reporting Hierarchy) also get the
# team/ endpoints for direct reports. The existing /employee/check-in/ and /employee/check-out/ keep
# working unchanged - the punch/ endpoints below are the perimeter-VERIFIED path.
#
#   GET   today/                          my status, shift, WFH, perimeter policy
#   POST  perimeter/check/                {latitude, longitude}  -> perimeter simulator (nothing is saved)
#   POST  punch/in/  punch/out/           {latitude, longitude, source?: web|mobile, comment?}
#   GET   logs/                           my daily logs                       ?from= ?to=
#   GET   late-early/                     my late / early exceptions
#   GET|POST regularizations/             my requests / apply for one
#   GET|PATCH|DELETE regularizations/<id>/    edit (pending only) / cancel
#   GET   perimeter-events/               my blocked / redirected attempts
#   POST  field/ping/   GET field/trail/  (field force agents only)
#   --- managers ---
#   GET   team/daily/    GET team/late-early/    GET team/regularizations/
#   POST  team/regularizations/<id>/approve/ | reject/
# ============================================================
from datetime import timedelta

from django.db import transaction
from django.db.models import Q
from django.utils import timezone
from rest_framework.views import APIView

from Employee.leave_models import ReportingHierarchy
from Employee.models import EMP_check_in_check_out

from . import att_engine as en
from .att_models import (AttendancePunchMeta, AttendanceRegularization, FieldForceAgent, FieldTrackPoint, PerimeterEvent)
from .common import err, next_seq, ok, paginate, to_bool, to_date, to_decimal, to_int
from .views_att import date_range, parse_dt, validate_reg, valid_ip
from .views_employee_vault import EmployeeBase


class Base(EmployeeBase, APIView):
    def policy(self):
        return en.get_policy(self.company())

    def field_agent(self):
        return FieldForceAgent.objects.filter(company=self.company(), employee=self.me, is_active=True).first()

    def coords(self, d):
        try:
            lat = float(d["latitude"]) if d.get("latitude") not in (None, "") else None
            lng = float(d["longitude"]) if d.get("longitude") not in (None, "") else None
            if lat is not None and not (-90 <= lat <= 90) or lng is not None and not (-180 <= lng <= 180):
                raise ValueError("latitude / longitude out of range.")
            return lat, lng
        except (TypeError, ValueError):
            raise ValueError("latitude and longitude must be numbers.")

    def logs_for(self, codes, start, end, request):
        pol = self.policy()
        emap = en.employee_map(self.company(), codes)
        qs = (EMP_check_in_check_out.objects.filter(company=self.company(), is_active=True, Employee_ID__in=codes,
                                                    login_date__gte=start, login_date__lte=end)
              .select_related("punch_meta", "punch_meta__device", "punch_meta__device__branch").order_by("-login_date", "-id"))

        def meta(r):
            try:
                return r.punch_meta
            except AttendancePunchMeta.DoesNotExist:
                return None
        return paginate(request, qs, lambda r: en.punch_row(r, meta(r), emap.get(r.Employee_ID), pol, request))


class MyToday(Base):
    def get(self, request):
        co, me, today = self.company(), self.me, timezone.localdate()
        pol = self.policy()
        rec = en.open_record(co, me.employee_code, today)
        recs = EMP_check_in_check_out.objects.filter(company=co, Employee_ID=me.employee_code, login_date=today, is_active=True) \
            .select_related("punch_meta", "punch_meta__device", "punch_meta__device__branch").order_by("id")
        rows = []
        for r in recs:
            try:
                m = r.punch_meta
            except AttendancePunchMeta.DoesNotExist:
                m = None
            rows.append(en.punch_row(r, m, me, pol, request))
        return ok("MY_ATT_TODAY", "Today's attendance.", {
            "date": str(today), "checked_in": rec is not None, "records": rows, "shift": {"start": en.fmt12(pol.shift_start), "end": en.fmt12(pol.shift_end),
                                                                                         "grace_minutes": pol.grace_minutes},
            "perimeter": {"enforced": pol.perimeter_enforced, "hubs": [{"name": g["name"], "radius_m": g["radius_m"]} for g in en.geofences(co)],
                          "allow_web_punch": pol.allow_web_punch, "allow_mobile_punch": pol.allow_mobile_punch},
            "wfh_today": en.approved_wfh_today(co, me.employee_code, today), "wfh_remaining_this_week": en.wfh_remaining(co, me.employee_code, today),
            "is_field_force": self.field_agent() is not None,
            "pending_regularizations": AttendanceRegularization.objects.filter(company=co, employee=me, is_active=True, status="Pending Approval").count()})


class MyPerimeterCheck(Base):
    """POST perimeter/check/ - 'Simulate: Inside Office / Outside Perimeter' without saving anything."""

    def post(self, request):
        try:
            lat, lng = self.coords(request.data)
            ip = valid_ip(request.data["ip"]) if request.data.get("ip") else en.client_ip(request)
        except ValueError as e:
            return err("VALIDATION", str(e))
        dec = en.decide_punch(self.company(), self.me, lat, lng, ip, timezone.localdate())
        return ok("MY_PERIMETER_CHECK", "Perimeter check.", {k: dec[k] for k in (
            "allowed", "perimeter_status", "event_status", "reason", "policy_action", "wfh_today", "wfh_remaining_this_week", "evaluation")})


class MyPunchIn(Base):
    @transaction.atomic
    def post(self, request):
        co, me, d, pol = self.company(), self.me, request.data, self.policy()
        if self.field_agent():
            return err("FIELD_FORCE_USE_TRACKER", "Field representatives must use the field tracker (field/ping/ with Punch-In).", 403)
        try:
            lat, lng = self.coords(d)
        except ValueError as e:
            return err("VALIDATION", str(e))
        channel = str(d.get("source") or ("mobile" if lat is not None else "web")).lower()
        if channel not in ("web", "mobile"):
            return err("VALIDATION", "source must be web or mobile.")
        if (channel == "web" and not pol.allow_web_punch) or (channel == "mobile" and not pol.allow_mobile_punch):
            return err("PUNCH_CHANNEL_DISABLED", f"{channel.title()} punching is disabled by your company.", 403)
        ip = en.client_ip(request)
        today = timezone.localdate()
        if en.EMP_check_in_check_out.objects.filter(company=co, Employee_ID=me.employee_code, login_date=today, logout_time__isnull=True, is_active=True).exists():
            return err("ALREADY_CHECKED_IN", "You are already checked in. Please check out first.", 409)
        dec = en.decide_punch(co, me, lat, lng, ip, today)
        if not dec["allowed"]:
            ev = en.log_event(co, me, "Mobile Web Punch" if channel == "mobile" else "Web Check-in Punch", dec, ip, lat, lng)
            code = "WFH_REDIRECT" if dec["event_status"] == "Redirected to WFH Portal" else "PERIMETER_BLOCKED"
            return err(code, dec["reason"] or "Punch blocked by the perimeter lock.", 403,
                       errors={"policy_action": dec["policy_action"], "event_id": ev.id, "event_status": dec["event_status"],
                               "distance_m": dec["evaluation"]["distance_m"], "wfh_remaining_this_week": dec["wfh_remaining_this_week"]})
        ev = dec["evaluation"]
        try:
            rec = en.create_punch_in(co, me, timezone.now(), source="GPS Mobile Punch" if channel == "mobile" else "Web Portal Punch",
                                     verdict=dec["perimeter_status"], lat=lat, lng=lng, geofence_id=(ev.get("geofence") or {}).get("id"),
                                     distance=ev.get("distance_m"), ip=ip, comment=d.get("comment"), actor=f"employee:{me.employee_code}")
        except en.PunchConflict as e:
            return err("ALREADY_CHECKED_IN", str(e), 409)
        rec = EMP_check_in_check_out.objects.select_related("punch_meta").get(pk=rec.pk)
        return ok("MY_PUNCHED_IN", "Checked in - " + dec["perimeter_status"] + ".", {
            "record": en.punch_row(rec, rec.punch_meta, me, self.policy(), request), "verification": {
                "perimeter_status": dec["perimeter_status"], "distance_m": ev.get("distance_m"), "policy_action": dec["policy_action"]}}, 201)


class MyPunchOut(Base):
    @transaction.atomic
    def post(self, request):
        d = request.data
        try:
            lat, lng = self.coords(d)
        except ValueError as e:
            return err("VALIDATION", str(e))
        ev = en.evaluate_perimeter(self.company(), lat, lng, en.client_ip(request)) if lat is not None else None
        channel = "GPS Mobile Punch" if lat is not None else "Web Portal Punch"
        try:
            rec = en.close_punch(self.company(), self.me, timezone.now(), source=channel, lat=lat, lng=lng,
                                 inside=ev["inside"] if ev else None, comment=d.get("comment"), actor=f"employee:{self.me.employee_code}")
        except en.PunchConflict as e:
            return err("NOT_CHECKED_IN", str(e), 409)
        rec = EMP_check_in_check_out.objects.select_related("punch_meta").get(pk=rec.pk)
        try:
            m = rec.punch_meta
        except AttendancePunchMeta.DoesNotExist:
            m = None
        return ok("MY_PUNCHED_OUT", "Checked out.", en.punch_row(rec, m, self.me, self.policy(), request))


class MyLogs(Base):
    def get(self, request):
        try:
            start, end = date_range(request.query_params, 30)
        except ValueError as e:
            return err("VALIDATION", str(e))
        rows, meta = self.logs_for([self.me.employee_code], start, end, request)
        return ok("MY_ATT_LOGS", "My attendance logs.", rows, meta=meta)


class MyLateEarly(Base):
    def get(self, request):
        try:
            start, end = date_range(request.query_params, 30)
        except ValueError as e:
            return err("VALIDATION", str(e))
        rows = en.late_early_rows(self.company(), start, end, [self.me.employee_code], request.query_params.get("kind") or None, self.policy())
        page, meta = paginate(request, rows, lambda r: r)
        return ok("MY_LATE_EARLY", "My late / early exceptions.", page, meta=meta)


class MyPerimeterEvents(Base):
    def get(self, request):
        qs = PerimeterEvent.objects.filter(company=self.company(), employee=self.me, is_active=True)
        rows, meta = paginate(request, qs, lambda e: {
            "id": e.id, "event_time": e.event_time.isoformat(), "attempted_action": e.attempted_action, "breach_reason": e.breach_reason,
            "status": e.status, "distance_m": float(e.distance_m) if e.distance_m is not None else None})
        return ok("MY_PERIMETER_EVENTS", "My perimeter events.", rows, meta=meta)


# ---------------- regularization ----------------

class MyRegularizations(Base):
    def get(self, request):
        qs = AttendanceRegularization.objects.filter(company=self.company(), employee=self.me, is_active=True).select_related("employee")
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        rows, meta = paginate(request, qs, en.reg_row)
        return ok("MY_REGULARIZATIONS", "My regularization requests.", rows, meta=meta)

    @transaction.atomic
    def post(self, request):
        co, me, actor = self.company(), self.me, f"employee:{self.me.employee_code}"
        try:
            day, tin, tout, reason = validate_reg(request.data, False)
        except ValueError as e:
            return err("VALIDATION", str(e))
        if AttendanceRegularization.objects.filter(company=co, employee=me, attendance_date=day, status__in=["Pending Approval", "Approved"]).exists():
            return err("EXISTS", "You already have a regularization request for that date.", 409)
        r = AttendanceRegularization.objects.create(
            company=co, request_id=next_seq(AttendanceRegularization, co, "request_id", "REG-", 3), employee=me, attendance_date=day,
            punch_in_time=tin, punch_out_time=tout, reason=reason, requested_by="Employee", created_by=actor, updated_by=actor)
        return ok("MY_REGULARIZATION_CREATED", "Regularization requested.", en.reg_row(r), 201)


class MyRegularizationDetail(Base):
    def _get(self, pk):
        return AttendanceRegularization.objects.filter(company=self.company(), employee=self.me, is_active=True, pk=pk).select_related("employee").first()

    def get(self, request, pk):
        r = self._get(pk)
        return ok("MY_REGULARIZATION", "Regularization.", en.reg_row(r)) if r else err("NOT_FOUND", "Record not found.", 404)

    def patch(self, request, pk):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if r.status != "Pending Approval":
            return err("CONFLICT", f"A {r.status.lower()} request can no longer be edited.", 409)
        try:
            day, tin, tout, reason = validate_reg(request.data, False, r)
        except ValueError as e:
            return err("VALIDATION", str(e))
        if day != r.attendance_date and AttendanceRegularization.objects.filter(
                company=r.company, employee=r.employee, attendance_date=day, status__in=["Pending Approval", "Approved"]).exists():
            return err("EXISTS", "You already have a regularization request for that date.", 409)
        r.attendance_date, r.punch_in_time, r.punch_out_time, r.reason = day, tin, tout, reason
        r.updated_by = f"employee:{self.me.employee_code}"
        r.save()
        return ok("MY_REGULARIZATION_UPDATED", "Updated.", en.reg_row(r))

    put = patch

    def delete(self, request, pk):
        r = self._get(pk)
        if r is None:
            return err("NOT_FOUND", "Record not found.", 404)
        if r.status != "Pending Approval":
            return err("CONFLICT", f"A {r.status.lower()} request cannot be cancelled.", 409)
        r.status, r.updated_by = "Cancelled", f"employee:{self.me.employee_code}"
        r.save()
        return ok("MY_REGULARIZATION_CANCELLED", "Request cancelled.", en.reg_row(r))


# ---------------- field force ----------------

class MyFieldPing(Base):
    @transaction.atomic
    def post(self, request):
        ag, d, co, me = self.field_agent(), request.data, self.company(), self.me
        if ag is None:
            return err("NOT_FIELD_FORCE", "You are not registered as a field force agent.", 403)
        try:
            lat, lng = self.coords(d)
            if lat is None or lng is None:
                raise ValueError("latitude and longitude are required.")
            ptype = d.get("point_type") or "Interval Ping"
            if ptype not in dict(FieldTrackPoint.TYPES):
                raise ValueError("Invalid point_type. Allowed: " + ", ".join(dict(FieldTrackPoint.TYPES)))
            when = parse_dt(d["recorded_at"], "recorded_at") if d.get("recorded_at") else timezone.now()
            now = timezone.now()
            if when > now + timedelta(minutes=5) or when < now - timedelta(hours=24):
                raise ValueError("recorded_at must be within the last 24 hours.")
            spd = to_decimal(d.get("speed_kmh"))
            bat = to_int(d.get("battery_percent"))
            if (spd is not None and not (0 <= spd <= 400)) or (bat is not None and not (0 <= bat <= 100)):
                raise ValueError("speed_kmh / battery_percent out of range.")
        except ValueError as e:
            return err("VALIDATION", str(e))
        actor = f"employee:{me.employee_code}"
        att = None
        try:
            if ptype == "Punch-In" and not en.open_record(co, me.employee_code, timezone.localdate()):
                att = en.create_punch_in(co, me, when, source="Field Tracker", verdict="Field Force", lat=lat, lng=lng, actor=actor)
            elif ptype == "Punch-Out" and en.open_record(co, me.employee_code, timezone.localdate()):
                att = en.close_punch(co, me, when, source="Field Tracker", lat=lat, lng=lng, inside=True, actor=actor)
        except en.PunchConflict:
            pass
        p = FieldTrackPoint.objects.create(company=co, agent=ag, recorded_at=when, point_type=ptype, location_label=d.get("location_label"),
                                           client_name=d.get("client_name"), latitude=lat, longitude=lng, speed_kmh=spd, battery_percent=bat,
                                           notes=d.get("notes"), site_verified=False, created_by=actor, updated_by=actor)
        return ok("MY_FIELD_PING", "Location recorded.", {"point": en.point_row(p), "attendance_record_id": att.id if att else None,
                                                          "next_ping_in_minutes": ag.ping_interval_minutes}, 201)


class MyFieldTrail(Base):
    def get(self, request):
        ag = self.field_agent()
        if ag is None:
            return err("NOT_FIELD_FORCE", "You are not registered as a field force agent.", 403)
        try:
            day = to_date(request.query_params.get("date")) or timezone.localdate()
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("MY_FIELD_TRAIL", "My route for the day.", en.agent_day(ag, day))


# ---------------- manager / team ----------------

class TeamBase(Base):
    def codes(self):
        return list(ReportingHierarchy.objects.filter(company=self.company(), manager_code=self.me.employee_code, is_active=True)
                    .values_list("Employee_ID", flat=True))

    def guard(self):
        return None if self.codes() else err("NOT_A_MANAGER", "You have no direct reports.", 403)


class TeamDaily(TeamBase):
    def get(self, request):
        bad = self.guard()
        if bad:
            return bad
        p = request.query_params
        try:
            start, end = (to_date(p["date"]),) * 2 if p.get("date") else date_range(p, 1)
        except ValueError as e:
            return err("VALIDATION", str(e))
        codes = [p["employee_code"]] if p.get("employee_code") in self.codes() else self.codes()
        rows, meta = self.logs_for(codes, start, end, request)
        return ok("TEAM_ATT_DAILY", "Team attendance logs.", rows, meta=meta)


class TeamLateEarly(TeamBase):
    def get(self, request):
        bad = self.guard()
        if bad:
            return bad
        try:
            start, end = date_range(request.query_params, 7)
        except ValueError as e:
            return err("VALIDATION", str(e))
        rows = en.late_early_rows(self.company(), start, end, self.codes(), request.query_params.get("kind") or None, self.policy())
        page, meta = paginate(request, rows, lambda r: r)
        return ok("TEAM_LATE_EARLY", "Team late / early exceptions.", page, meta=meta)


class TeamRegularizations(TeamBase):
    def get(self, request):
        bad = self.guard()
        if bad:
            return bad
        qs = AttendanceRegularization.objects.filter(company=self.company(), employee__employee_code__in=self.codes(), is_active=True).select_related("employee")
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        rows, meta = paginate(request, qs, en.reg_row)
        return ok("TEAM_REGULARIZATIONS", "Team regularization requests.", rows, meta=meta)


class TeamRegularizationAct(TeamBase):
    decision = None

    @transaction.atomic
    def post(self, request, pk):
        bad = self.guard()
        if bad:
            return bad
        r = AttendanceRegularization.objects.filter(company=self.company(), pk=pk, is_active=True, employee__employee_code__in=self.codes()).select_related("employee").first()
        if r is None:
            return err("NOT_FOUND", "Request not found.", 404)
        if r.status != "Pending Approval":
            return err("CONFLICT", f"This request is already {r.status}.", 409)
        comment = str(request.data.get("comment") or "").strip()
        if self.decision == "Rejected" and not comment:
            return err("VALIDATION", "comment is required when rejecting.", errors={"comment": ["This field is required."]})
        en.decide_regularization(r, self.decision, comment or None, f"employee:{self.me.employee_code}")
        return ok(f"TEAM_REGULARIZATION_{self.decision.upper()}", f"Regularization {self.decision.lower()}.", en.reg_row(r))


class TeamApprove(TeamRegularizationAct):
    decision = "Approved"


class TeamReject(TeamRegularizationAct):
    decision = "Rejected"
