from django.db import models
from django.utils.timezone import now
from decimal import Decimal
import uuid
import secrets


# ============================================================
# HELPER FUNCTIONS
# ============================================================

def generate_company_id():
    """
    Generate unique 8 character company ID.
    """
    return uuid.uuid4().hex[:8].upper()


def generate_client_id():
    """
    Generate unique 8 character client ID.
    """
    return uuid.uuid4().hex[:8].upper()


def generate_api_key():
    """
    Generate secure 64 character API key.
    """
    return secrets.token_hex(32)


# ============================================================
# COMPANY DETAILS / TENANT
# ============================================================

class company_details(models.Model):

    # ========================================================
    # BASIC COMPANY INFORMATION
    # ========================================================

    company_id = models.CharField(
        max_length=8,
        unique=True,
        blank=True,
        default=generate_company_id,
        db_index=True
    )

    email = models.EmailField(
        unique=True
    )

    # Existing field - KEPT
    password = models.CharField(
        max_length=12
    )

    contact_no = models.CharField(
        max_length=15,
        unique=True
    )

    verification_code = models.CharField(
        max_length=6,
        blank=True,
        null=True
    )

    is_verified = models.BooleanField(
        default=False
    )

    status = models.BooleanField(
        default=False,
        db_index=True
    )

    Attendance_camera = models.BooleanField(
        default=False,
        blank=True,
        null=True
    )

    Company_logo = models.ImageField(
        upload_to='company/logos/',
        blank=True,
        null=True
    )

    Company_address = models.TextField(
        blank=True,
        null=True
    )

    Registered_Company_Name = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    Brand_Name = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    Company_Official_Email = models.EmailField(
        blank=True,
        null=True
    )

    Company_Official_Contact = models.CharField(
        max_length=15,
        blank=True,
        null=True
    )

    Website = models.CharField(
        max_length=50,
        blank=True,
        null=True
    )

    Domain_Name = models.CharField(
        max_length=50,
        blank=True,
        null=True
    )

    Industry_Type = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    REGISTERED_OFFICE_add = models.CharField(
        max_length=500,
        blank=True,
        null=True
    )

    CORPORATE_OFFICE_add = models.CharField(
        max_length=500,
        blank=True,
        null=True
    )

    CUSTOM_ADDRESS_TITLE_add = models.CharField(
        max_length=500,
        blank=True,
        null=True
    )

    LIVE_ANNOUNCEMENTS = models.CharField(
        max_length=1000,
        blank=True,
        null=True
    )

    COMPANY_POLICIES = models.CharField(
        max_length=2000,
        blank=True,
        null=True
    )

    # ========================================================
    # GEOLOCATION
    # ========================================================

    office_latitude = models.FloatField(
        blank=True,
        null=True
    )

    office_longitude = models.FloatField(
        blank=True,
        null=True
    )

    allowed_radius = models.IntegerField(
        default=200
    )

    # ========================================================
    # API
    # ========================================================

    api_key = models.CharField(
        max_length=64,
        unique=True,
        blank=True,
        null=True
    )

    # ========================================================
    # COMPANY STATUS
    # ========================================================

    COMPANY_STATUS_CHOICES = [
        ("ACTIVE", "Active"),
        ("INACTIVE", "Inactive"),
        ("SUSPENDED", "Suspended"),
        ("TRIAL", "Trial"),
        ("EXPIRED", "Expired"),
    ]

    company_status = models.CharField(
        max_length=20,
        choices=COMPANY_STATUS_CHOICES,
        default="TRIAL",
        db_index=True
    )

    # ========================================================
    # SUBSCRIPTION
    # ========================================================

    PLAN_CHOICES = [
        ("FREE", "Free"),
        ("BASIC", "Basic"),
        ("PRO", "Professional"),
        ("ENTERPRISE", "Enterprise"),
    ]

    plan = models.CharField(
        max_length=20,
        choices=PLAN_CHOICES,
        default="FREE",
        db_index=True
    )

    subscription_start_date = models.DateField(
        blank=True,
        null=True
    )

    subscription_end_date = models.DateField(
        blank=True,
        null=True
    )

    trial_start_date = models.DateField(
        blank=True,
        null=True
    )

    trial_end_date = models.DateField(
        blank=True,
        null=True
    )

    # ========================================================
    # LIMITS
    # ========================================================

    employee_limit = models.PositiveIntegerField(
        default=10
    )

    admin_limit = models.PositiveIntegerField(
        default=1
    )

    hr_limit = models.PositiveIntegerField(
        default=2
    )

    device_limit = models.PositiveIntegerField(
        default=1
    )

    # ========================================================
    # MODULE PERMISSIONS
    # ========================================================

    allow_attendance = models.BooleanField(
        default=True
    )

    allow_payroll = models.BooleanField(
        default=True
    )

    allow_leave = models.BooleanField(
        default=True
    )

    allow_expense = models.BooleanField(
        default=True
    )

    allow_invoice = models.BooleanField(
        default=True
    )

    allow_bank = models.BooleanField(
        default=True
    )

    allow_ai = models.BooleanField(
        default=True
    )

    allow_mobile_app = models.BooleanField(
        default=True
    )

    allow_biometric = models.BooleanField(
        default=True
    )

    allow_api = models.BooleanField(
        default=True
    )

    # ========================================================
    # SUPERADMIN CONTROL
    # ========================================================

    created_by_superadmin = models.BooleanField(
        default=True
    )

    notes = models.TextField(
        blank=True,
        null=True
    )

    # ========================================================
    # AUDIT
    # ========================================================

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    updated_at = models.DateTimeField(
        auto_now=True
    )

    # ---- 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,
    )

    # ========================================================
    # API KEY GENERATOR
    # ========================================================

    def generate_api_key(self):

        token = generate_api_key()

        self.api_key = token

        self.save(
            update_fields=["api_key", "updated_at"]
        )

        return token

    # ========================================================
    # SAVE
    # ========================================================

    def save(self, *args, **kwargs):

        if not self.company_id:
            self.company_id = generate_company_id()

        if not self.api_key:
            self.api_key = generate_api_key()

        super().save(*args, **kwargs)

    # ========================================================
    # EMPLOYEE STATISTICS
    # ========================================================

    def total_employees(self):

        try:
            return self.employees.count()
        except Exception:
            return 0

    def active_employees(self):

        try:
            return self.employees.filter(
                is_active=True
            ).count()
        except Exception:
            return 0

    def inactive_employees(self):

        try:
            return self.employees.filter(
                is_active=False
            ).count()
        except Exception:
            return 0

    # ========================================================
    # LIMIT CHECK
    # ========================================================

    def employee_limit_reached(self):

        return self.active_employees() >= self.employee_limit

    def available_employee_slots(self):

        remaining = (
            self.employee_limit -
            self.active_employees()
        )

        return max(remaining, 0)

    # ========================================================
    # COMPANY STATUS
    # ========================================================

    def is_company_active(self):

        if not self.status:
            return False

        if self.company_status in [
            "ACTIVE",
            "TRIAL"
        ]:
            return True

        return False

    # ========================================================
    # SUBSCRIPTION EXPIRY
    # ========================================================

    def subscription_expired(self):

        if not self.subscription_end_date:
            return False

        return self.subscription_end_date < now().date()

    # ========================================================
    # TRIAL EXPIRY
    # ========================================================

    def trial_expired(self):

        if not self.trial_end_date:
            return False

        return self.trial_end_date < now().date()

    # ========================================================
    # STRING
    # ========================================================

    def __str__(self):

        return (
            self.Registered_Company_Name
            if self.Registered_Company_Name
            else "Unnamed Company"
        )


# ============================================================
# ATTENDANCE STATUS
# ============================================================

class Attendance_Status(models.Model):

    last_run_date = models.DateField(
        null=True,
        blank=True
    )

    # ---- 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,
    )

    def __str__(self):

        return str(self.last_run_date)


# ============================================================
# EXPENSE
# ============================================================

class Expense(models.Model):

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="expenses"
    )

    Employee_ID = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    CATEGORY_CHOICES = [
        ("Salary", "Salary"),
        ("Office Supplies", "Office Supplies"),
        ("Utilities", "Utilities"),
        ("Marketing", "Marketing"),
        ("Travel", "Travel"),
    ]

    title = models.CharField(
        max_length=255
    )

    category = models.CharField(
        max_length=50,
        choices=CATEGORY_CHOICES
    )

    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2
    )

    date = models.DateField(
        default=now
    )

    description = models.TextField(
        blank=True,
        null=True
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    updated_at = models.DateTimeField(
        auto_now=True
    )

    # ---- 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,
    )

    def __str__(self):

        return self.title


# ============================================================
# CLIENT
# ============================================================

class Client(models.Model):

    client_id = models.CharField(
        max_length=8,
        unique=True,
        blank=True,
        default=generate_client_id
    )

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="clients"
    )

    Employee_ID = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    name = models.CharField(
        max_length=255
    )

    email = models.EmailField(
        unique=True
    )

    phone = models.CharField(
        max_length=15,
        blank=True,
        null=True
    )

    address = models.TextField(
        blank=True,
        null=True
    )

    gst_number = models.CharField(
        max_length=15,
        blank=True,
        null=True
    )

    pan_number = models.CharField(
        max_length=10,
        blank=True,
        null=True
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    bank_name = models.CharField(
        max_length=255,
        blank=True,
        null=True
    )

    account_number = models.CharField(
        max_length=20,
        blank=True,
        null=True,
        unique=True
    )

    ifsc_code = models.CharField(
        max_length=11,
        blank=True,
        null=True
    )

    account_type = models.CharField(
        max_length=10,
        choices=[
            ("Saving", "Saving"),
            ("Current", "Current")
        ],
        blank=True,
        null=True
    )

    is_active = models.BooleanField(
        default=True
    )

    # ---- 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",
    )

    def __str__(self):

        return self.name


# ============================================================
# BANK TRANSACTION
# ============================================================

class BankTransaction(models.Model):

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="bank_transactions"
    )

    client = models.ForeignKey(
        Client,
        on_delete=models.CASCADE,
        blank=True,
        null=True,
        related_name="bank_transactions"
    )

    Employee_ID = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    transaction_type = models.CharField(
        max_length=20,
        choices=[
            ("Credit", "Credit"),
            ("Debit", "Debit")
        ]
    )

    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2
    )

    date = models.DateField(
        default=now
    )

    description = models.TextField(
        blank=True,
        null=True
    )

    reference_number = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    # ---- 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,
    )

    def __str__(self):

        client_name = (
            self.client.name
            if self.client
            else "Company"
        )

        return (
            f"{client_name} - "
            f"{self.transaction_type} - "
            f"₹{self.amount}"
        )


# ============================================================
# INVOICE
# ============================================================

class Invoice(models.Model):

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="invoices"
    )

    Employee_ID = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    client = models.ForeignKey(
        Client,
        on_delete=models.CASCADE,
        blank=True,
        null=True,
        related_name="invoices"
    )

    invoice_number = models.CharField(
        max_length=20,
        unique=True,
        blank=True,
        null=True
    )

    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2
    )

    due_date = models.DateField()

    status = models.CharField(
        max_length=20,
        choices=[
            ("Pending", "Pending"),
            ("Paid", "Paid")
        ],
        default="Pending"
    )

    gst_percentage = models.DecimalField(
        max_digits=5,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    tds_percentage = models.DecimalField(
        max_digits=5,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    gst_amount = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    tds_amount = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    total_tax = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    grand_total = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        blank=True,
        null=True,
        default=Decimal("0.00")
    )

    payment_transaction_created = models.BooleanField(
        default=False
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    updated_at = models.DateTimeField(
        auto_now=True
    )

    # ---- 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,
    )

    def calculate_totals(self):

        amount = self.amount or Decimal("0.00")

        gst_percentage = (
            self.gst_percentage
            or Decimal("0.00")
        )

        tds_percentage = (
            self.tds_percentage
            or Decimal("0.00")
        )

        self.gst_amount = (
            amount *
            gst_percentage /
            Decimal("100")
        )

        self.tds_amount = (
            amount *
            tds_percentage /
            Decimal("100")
        )

        self.total_tax = (
            self.gst_amount +
            self.tds_amount
        )

        self.grand_total = (
            amount +
            self.gst_amount -
            self.tds_amount
        )

    def save(self, *args, **kwargs):

        old_status = None

        if self.pk:

            old_status = (
                Invoice.objects
                .filter(pk=self.pk)
                .values_list(
                    "status",
                    flat=True
                )
                .first()
            )

        self.calculate_totals()

        super().save(*args, **kwargs)

        # ----------------------------------------------------
        # Create bank transaction ONLY when invoice
        # changes to Paid.
        # ----------------------------------------------------

        if (
            self.status == "Paid"
            and not self.payment_transaction_created
        ):

            client_name = (
                self.client.name
                if self.client
                else "Client"
            )

            BankTransaction.objects.create(
                company=self.company,
                client=self.client,
                Employee_ID=self.Employee_ID,
                transaction_type="Credit",
                amount=self.grand_total,
                date=now().date(),
                description=(
                    f"Invoice Payment Received: "
                    f"{self.invoice_number} "
                    f"{client_name} - "
                    f"₹{self.grand_total}"
                ),
                reference_number=self.invoice_number
            )

            Invoice.objects.filter(
                pk=self.pk
            ).update(
                payment_transaction_created=True
            )

    def __str__(self):

        return (
            f"Invoice "
            f"{self.client} - "
            f"₹{self.grand_total}"
        )


# ============================================================
# PROFIT LOSS
# ============================================================

class ProfitLoss(models.Model):

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="profit_loss_reports"
    )

    Employee_ID = models.CharField(
        max_length=100,
        blank=True,
        null=True
    )

    month = models.CharField(
        max_length=50
    )

    revenue = models.DecimalField(
        max_digits=12,
        decimal_places=2
    )

    expenses = models.DecimalField(
        max_digits=12,
        decimal_places=2
    )

    net_profit = models.DecimalField(
        max_digits=12,
        decimal_places=2
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    # ---- 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,
    )

    def calculate_profit(self):

        self.net_profit = (
            self.revenue -
            self.expenses
        )

        return self.net_profit

    def save(self, *args, **kwargs):

        self.calculate_profit()

        super().save(*args, **kwargs)

    def __str__(self):

        return (
            f"{self.month} - "
            f"Profit: {self.net_profit}"
        )

# ============================================================
# AUTH LOG (additive)
# ------------------------------------------------------------
# Unified login/logout activity log for ALL actor types:
# SuperAdmin, Company Admin (tenant), and Employee.
# Kept in Company app so Employee and SuperAdmin apps
# (which already import Company.models) can log into it
# without any circular-import issues.
# ============================================================

class AuthLog(models.Model):

    ACTOR_SUPERADMIN = "SUPERADMIN"
    ACTOR_COMPANY_ADMIN = "COMPANY_ADMIN"
    ACTOR_EMPLOYEE = "EMPLOYEE"

    ACTOR_CHOICES = [
        (ACTOR_SUPERADMIN, "Super Admin"),
        (ACTOR_COMPANY_ADMIN, "Company Admin"),
        (ACTOR_EMPLOYEE, "Employee"),
    ]

    ACTION_LOGIN = "LOGIN"
    ACTION_LOGOUT = "LOGOUT"

    ACTION_CHOICES = [
        (ACTION_LOGIN, "Login"),
        (ACTION_LOGOUT, "Logout"),
    ]

    STATUS_SUCCESS = "SUCCESS"
    STATUS_FAILED = "FAILED"

    STATUS_CHOICES = [
        (STATUS_SUCCESS, "Success"),
        (STATUS_FAILED, "Failed"),
    ]

    actor_type = models.CharField(
        max_length=20,
        choices=ACTOR_CHOICES,
        db_index=True
    )

    # Human-friendly identifier of who tried to log in
    # (email / username / employee_code) - kept even if the
    # underlying record can't be resolved (e.g. wrong email).
    identifier = models.CharField(
        max_length=150,
        blank=True,
        null=True,
        db_index=True
    )

    # Best-effort ID of the resolved actor (company_id,
    # employee_code, or SuperAdminProfile.id as string).
    actor_id = models.CharField(
        max_length=100,
        blank=True,
        null=True,
        db_index=True
    )

    company = models.ForeignKey(
        company_details,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
        related_name="auth_logs"
    )

    action = models.CharField(
        max_length=10,
        choices=ACTION_CHOICES,
        db_index=True
    )

    status = models.CharField(
        max_length=10,
        choices=STATUS_CHOICES,
        default=STATUS_SUCCESS,
        db_index=True
    )

    reason = models.CharField(
        max_length=255,
        blank=True,
        null=True
    )

    ip_address = models.GenericIPAddressField(
        blank=True,
        null=True
    )

    user_agent = models.CharField(
        max_length=255,
        blank=True,
        null=True
    )

    created_at = models.DateTimeField(
        auto_now_add=True,
        db_index=True
    )

    # ---- 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,
    )

    class Meta:

        ordering = ["-created_at"]

        indexes = [
            models.Index(
                fields=["actor_type", "action", "created_at"]
            ),
            models.Index(
                fields=["company", "created_at"]
            ),
        ]

    def __str__(self):

        return (
            f"{self.actor_type} - "
            f"{self.action} - "
            f"{self.status} - "
            f"{self.created_at}"
        )


# ============================================================
# AUTH LOG HELPER (additive)
# ============================================================

def get_client_ip(request):
    """
    Best-effort client IP extraction (works behind
    reverse proxies that set X-Forwarded-For).
    """

    xff = request.META.get("HTTP_X_FORWARDED_FOR")

    if xff:
        return xff.split(",")[0].strip()

    return request.META.get("REMOTE_ADDR")


def log_auth_event(
    actor_type,
    action,
    status,
    request=None,
    identifier=None,
    actor_id=None,
    company=None,
    reason=None,
):
    """
    Write one row to AuthLog. Never raises - a logging
    failure must never break login/logout.
    """

    try:

        AuthLog.objects.create(
            actor_type=actor_type,
            identifier=identifier,
            actor_id=str(actor_id) if actor_id is not None else None,
            company=company,
            action=action,
            status=status,
            reason=reason,
            ip_address=get_client_ip(request) if request else None,
            user_agent=(
                request.META.get("HTTP_USER_AGENT", "")[:255]
                if request else None
            ),
        )

    except Exception:
        # Logging must never break the login/logout flow.
        pass


def blacklist_token(token):
    """
    Blacklist a SimpleJWT RefreshToken WITHOUT using its built-in
    .blacklist() method.

    Why: RefreshToken.blacklist() tries to resolve our token's
    "user_id" claim against django.contrib.auth's User table
    (via get_user_model().objects.get(id=user_id)) so it can
    attach a user to the OutstandingToken row. Our company/
    employee tokens carry a custom user_id (company_id /
    employee_code - a string, not a User pk), so that lookup
    raises ValueError instead of the DoesNotExist SimpleJWT
    expects, and blacklisting crashes. This helper records the
    same OutstandingToken/BlacklistedToken rows directly, with
    user left blank, which works for every actor type
    (SuperAdmin, Company Admin, Employee) uniformly.
    """

    from rest_framework_simplejwt.settings import api_settings
    from rest_framework_simplejwt.utils import datetime_from_epoch
    from rest_framework_simplejwt.token_blacklist.models import (
        OutstandingToken,
        BlacklistedToken,
    )

    jti = token.payload[api_settings.JTI_CLAIM]
    exp = token.payload["exp"]

    outstanding, _ = OutstandingToken.objects.get_or_create(
        jti=jti,
        defaults={
            "user": None,
            "created_at": token.current_time,
            "token": str(token),
            "expires_at": datetime_from_epoch(exp),
        },
    )

    BlacklistedToken.objects.get_or_create(token=outstanding)



# ============================================================
# ADDITIVE: COMPANY HOLIDAY
# Company Admin / HR can add & edit the yearly holiday list;
# it's read by the Company/HR dashboard and the Employee
# dashboard (see Company.views.CompanyDashboardView and
# Employee.views.EmployeeDashboardView).
# ============================================================

class Holiday(models.Model):

    company = models.ForeignKey(
        company_details,
        on_delete=models.CASCADE,
        related_name="holidays"
    )

    name = models.CharField(
        max_length=150
    )

    date = models.DateField()

    HOLIDAY_TYPE_CHOICES = [
        ("National", "National"),
        ("Regional", "Regional"),
        ("Optional", "Optional"),
        ("Company", "Company"),
        ("National","National"),
        ("Festival","Festival"),
    ]

    holiday_type = models.CharField(
        max_length=20,
        choices=HOLIDAY_TYPE_CHOICES,
        default="Company",
    )

    description = models.TextField(
        blank=True,
        null=True
    )

    is_active = models.BooleanField(
        default=True
    )

    # manual    = added by Admin/HR through /api/holidays/
    # automatic = imported from the holiday library (Calendarific)
    SOURCE_CHOICES = [
        ("manual", "Manual"),
        ("automatic", "Automatic"),
    ]

    source = models.CharField(
        max_length=20,
        choices=SOURCE_CHOICES,
        default="manual",
        db_index=True,
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )

    updated_at = models.DateTimeField(
        auto_now=True
    )

    # ---- 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",
    )

    class Meta:

        unique_together = (
            "company",
            "date",
            "name",
        )

        ordering = ["date"]

        indexes = [
            models.Index(
                fields=[
                    "company",
                    "date"
                ]
            )
        ]

    def __str__(self):

        return (
            f"{self.company} - "
            f"{self.name} ({self.date})"
        )
        
  
  
  