# ============================================================
# ADDITIVE: Employee Relations, Grievances & Cases
#
# Reused as-is (NOT duplicated):
#   people          -> Employee.EmployeeDT                     (FK)
#   manager lookup  -> Employee.ReportingHierarchy             (read only)
#   warning letter  -> People.letters.issue_letter + People.EmployeeLetter  (template "DISCIPLINARY_WARNING", PDF included)
#   audit fields    -> People.models.Audit                     (abstract, same convention)
#   central audit   -> AdminCenter.AdminAuditEvent             (optional: written only if AdminCenter is installed)
# One case registry (ERCase) feeds HR Cases + Grievances + Complaints tabs (filtered views, no copies).
# Every table carries `company` (B2B isolation) and soft-delete via is_active.
# ============================================================
import os
import uuid

from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models

from Company.models import company_details
from Employee.models import EmployeeDT
from People.models import Audit, EmployeeLetter

# confidential files live OUTSIDE MEDIA_ROOT, so they are never served by the /media/ URL - only by the audited download API
vault_storage = FileSystemStorage(location=os.path.join(settings.BASE_DIR, "private_media"))


def vault_path(instance, filename):
    ext = os.path.splitext(filename)[1].lower()[:8]
    return f"er_vault/{instance.company_id}/{uuid.uuid4().hex}{ext}"


CATEGORIES = ["Disciplinary", "Grievance", "Complaint", "Misconduct", "Harassment", "Policy Violation", "Legal", "Other"]
SEVERITIES = ["Low", "Medium", "High", "Critical"]
CASE_STATUS = ["Open", "In Investigation", "Pending Review", "Escalated", "Resolved", "Closed", "Withdrawn"]


class RelationsSetting(Audit):
    """One row per company: who sits on the committees and who may open the confidential vault."""
    FREQ = [("Monthly", "Monthly"), ("Quarterly", "Quarterly"), ("Half-Yearly", "Half-Yearly"), ("Yearly", "Yearly")]
    company = models.OneToOneField(company_details, on_delete=models.CASCADE, related_name="relations_setting")
    hr_head = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="+")
    legal_counsel = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="+")
    icc_presiding_officer = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="+")
    icc_meeting_frequency = models.CharField(max_length=12, choices=FREQ, default="Quarterly")
    vault_members = models.ManyToManyField(EmployeeDT, blank=True, related_name="+")
    hearing_notice_days = models.PositiveSmallIntegerField(default=2)      # min days between notice and hearing (natural justice)
    warning_valid_months = models.PositiveSmallIntegerField(default=12)


class ERCase(Audit):
    SOURCES = [("HR", "HR"), ("Employee", "Employee"), ("Manager", "Manager"), ("Anonymous", "Anonymous")]
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_cases")
    case_no = models.CharField(max_length=30)                                          # CASE-01
    category = models.CharField(max_length=20, db_index=True)
    sub_category = models.CharField(max_length=80, blank=True, null=True)              # POSH / Code of Conduct / Manager behaviour ...
    subject = models.CharField(max_length=300)
    description = models.TextField(blank=True, null=True)
    severity = models.CharField(max_length=10, default="Medium", db_index=True)
    status = models.CharField(max_length=20, default="Open", db_index=True)
    employee = models.ForeignKey(EmployeeDT, on_delete=models.PROTECT, null=True, blank=True, related_name="er_cases")   # employee the case is about (empty for policy-level / anonymous grievances)
    raised_by = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="er_cases_raised")  # null = anonymous
    source = models.CharField(max_length=10, choices=SOURCES, default="HR")
    is_confidential = models.BooleanField(default=True)
    tracking_hash = models.CharField(max_length=64, blank=True, null=True, db_index=True)   # anonymous follow-up token (hash only)
    investigator = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="er_cases_assigned")
    incident_date = models.DateField(null=True, blank=True)
    target_date = models.DateField(null=True, blank=True)
    opened_at = models.DateTimeField(auto_now_add=True)
    resolved_at = models.DateTimeField(null=True, blank=True)
    resolution_type = models.CharField(max_length=40, blank=True, null=True)           # Substantiated / Unsubstantiated / Settled ...
    resolution_summary = models.TextField(blank=True, null=True)
    resolved_by = models.CharField(max_length=150, blank=True, null=True)
    closed_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["-id"]
        unique_together = (("company", "case_no"),)
        indexes = [models.Index(fields=["company", "status"]), models.Index(fields=["company", "category"]), models.Index(fields=["company", "employee"])]


class CaseNote(Audit):
    """Timeline + investigation notes of a case. is_internal=False notes are visible to the person who raised the case."""
    TYPES = ["Note", "Created", "Assigned", "Status", "Resolved", "Reopened", "Document", "Update"]
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_case_notes")
    case = models.ForeignKey(ERCase, on_delete=models.CASCADE, related_name="notes")
    note_type = models.CharField(max_length=10, default="Note")
    text = models.TextField()
    is_internal = models.BooleanField(default=True)
    author = models.CharField(max_length=150, blank=True, null=True)
    author_name = models.CharField(max_length=150, blank=True, null=True)

    class Meta:
        ordering = ["id"]


class DisciplinaryAction(Audit):
    TYPES = ["Show Cause Notice", "Inquiry", "Hearing", "Suspension", "Demotion", "Termination", "Fine", "Other"]
    STATUS = ["Notice Issued", "Hearing Scheduled", "Hearing Held", "Decision Issued", "Appealed", "Closed", "Cancelled"]
    OUTCOMES = ["Pending", "Penalty Imposed", "Warning Issued", "Exonerated", "Dismissed"]
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_disciplinary")
    case = models.ForeignKey(ERCase, on_delete=models.SET_NULL, null=True, blank=True, related_name="disciplinary_actions")
    employee = models.ForeignKey(EmployeeDT, on_delete=models.PROTECT, related_name="er_disciplinary")
    action_type = models.CharField(max_length=20)
    charge = models.TextField()                                                      # allegation put to the employee
    status = models.CharField(max_length=20, default="Notice Issued", db_index=True)
    notice_served_on = models.DateField(null=True, blank=True)
    hearing_date = models.DateField(null=True, blank=True)
    hearing_time = models.TimeField(null=True, blank=True)
    hearing_location = models.CharField(max_length=200, blank=True, null=True)
    committee = models.ManyToManyField(EmployeeDT, blank=True, related_name="+")
    employee_response = models.TextField(blank=True, null=True)
    response_at = models.DateTimeField(null=True, blank=True)
    minutes = models.TextField(blank=True, null=True)
    outcome = models.CharField(max_length=20, default="Pending")
    penalty = models.CharField(max_length=300, blank=True, null=True)
    decision_date = models.DateField(null=True, blank=True)
    decided_by = models.CharField(max_length=150, blank=True, null=True)

    class Meta:
        ordering = ["-id"]
        indexes = [models.Index(fields=["company", "status"]), models.Index(fields=["company", "employee"])]


class WarningLetter(Audit):
    LEVELS = ["Verbal Warning", "Written Warning", "Final Written Warning", "Show Cause Notice"]
    STATUS = ["Draft", "Issued", "Acknowledged", "Withdrawn"]
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_warnings")
    warning_no = models.CharField(max_length=30)                                      # WRN-2026-02
    employee = models.ForeignKey(EmployeeDT, on_delete=models.PROTECT, related_name="er_warnings")
    case = models.ForeignKey(ERCase, on_delete=models.SET_NULL, null=True, blank=True, related_name="warnings")
    disciplinary = models.ForeignKey(DisciplinaryAction, on_delete=models.SET_NULL, null=True, blank=True, related_name="warnings")
    level = models.CharField(max_length=25)
    reason = models.TextField()
    incident_date = models.DateField(null=True, blank=True)
    issued_on = models.DateField(null=True, blank=True)
    valid_until = models.DateField(null=True, blank=True)
    status = models.CharField(max_length=14, default="Draft", db_index=True)
    letter = models.ForeignKey(EmployeeLetter, on_delete=models.SET_NULL, null=True, blank=True, related_name="+")   # existing letter engine
    issued_by = models.CharField(max_length=150, blank=True, null=True)
    acknowledged_at = models.DateTimeField(null=True, blank=True)
    acknowledgement_remarks = models.TextField(blank=True, null=True)
    withdrawn_reason = models.TextField(blank=True, null=True)

    class Meta:
        ordering = ["-id"]
        unique_together = (("company", "warning_no"),)
        indexes = [models.Index(fields=["company", "employee"])]


class LegalCase(Audit):
    TYPES = ["Legal Notice", "Labour Tribunal", "Industrial Dispute", "Court Case", "Arbitration", "Other"]
    STATUS = ["Open", "Under Review", "Hearing Scheduled", "Settled", "Won", "Lost", "Withdrawn", "Closed"]
    ACTIVE = ("Open", "Under Review", "Hearing Scheduled")
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_legal_cases")
    legal_no = models.CharField(max_length=30)                                        # LEG-2026-01
    case_type = models.CharField(max_length=20)
    title = models.CharField(max_length=300)
    employee = models.ForeignKey(EmployeeDT, on_delete=models.SET_NULL, null=True, blank=True, related_name="er_legal_cases")
    claimant = models.CharField(max_length=200, blank=True, null=True)                # free text when not an employee
    forum = models.CharField(max_length=200, blank=True, null=True)                   # court / tribunal
    court_case_number = models.CharField(max_length=80, blank=True, null=True)
    case = models.ForeignKey(ERCase, on_delete=models.SET_NULL, null=True, blank=True, related_name="legal_cases")
    filed_on = models.DateField(null=True, blank=True)
    next_hearing_date = models.DateField(null=True, blank=True)
    counsel_name = models.CharField(max_length=150, blank=True, null=True)
    claim_amount = models.DecimalField(max_digits=14, decimal_places=2, null=True, blank=True)
    status = models.CharField(max_length=20, default="Open", db_index=True)
    outcome = models.TextField(blank=True, null=True)
    notes = models.TextField(blank=True, null=True)
    closed_on = models.DateField(null=True, blank=True)

    class Meta:
        ordering = ["-id"]
        unique_together = (("company", "legal_no"),)


class CaseDocument(Audit):
    TYPES = ["Evidence", "Statement", "Notice", "Letter", "Order", "Report", "Other"]
    LEVELS = ["Confidential", "Restricted"]
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_documents")
    case = models.ForeignKey(ERCase, on_delete=models.SET_NULL, null=True, blank=True, related_name="documents")
    disciplinary = models.ForeignKey(DisciplinaryAction, on_delete=models.SET_NULL, null=True, blank=True, related_name="documents")
    legal_case = models.ForeignKey(LegalCase, on_delete=models.SET_NULL, null=True, blank=True, related_name="documents")
    title = models.CharField(max_length=250)
    doc_type = models.CharField(max_length=15, default="Evidence")
    description = models.TextField(blank=True, null=True)
    confidentiality = models.CharField(max_length=14, default="Confidential")
    file = models.FileField(storage=vault_storage, upload_to=vault_path, max_length=300)
    file_name = models.CharField(max_length=255)
    file_size = models.PositiveIntegerField(default=0)
    content_type = models.CharField(max_length=100, blank=True, null=True)
    sha256 = models.CharField(max_length=64, db_index=True)
    uploaded_by = models.CharField(max_length=150, blank=True, null=True)

    class Meta:
        ordering = ["-id"]


class DocumentAccessLog(models.Model):
    """Append-only: who uploaded / opened / downloaded / changed / deleted a vault document."""

    # ---- audit fields (additive) ----
    created_by = models.CharField(
        max_length=150,
        null=True,
        blank=True,
        help_text="Who created this record (e.g. admin:<id> / employee:<id>)",
    )
    updated_by = models.CharField(
        max_length=150,
        null=True,
        blank=True,
        help_text="Who last updated this record (e.g. admin:<id> / employee:<id>)",
    )
    id_version = models.PositiveIntegerField(
        default=1,
        help_text="Record version counter",
    )
    is_active = models.BooleanField(
        default=True,
    )
    company = models.ForeignKey(company_details, on_delete=models.CASCADE, related_name="er_document_logs")
    document = models.ForeignKey(CaseDocument, on_delete=models.CASCADE, related_name="access_logs")
    action = models.CharField(max_length=12)                                          # UPLOAD / VIEW / DOWNLOAD / UPDATE / DELETE
    actor = models.CharField(max_length=150, blank=True, null=True)
    actor_name = models.CharField(max_length=150, blank=True, null=True)
    ip_address = models.GenericIPAddressField(blank=True, null=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-id"]
