python-tdd/src/apps/epic/models.py

import random
import uuid

from datetime import timedelta
from django.db import models
from django.db.models import UniqueConstraint
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from django.utils import timezone

from apps.lyric.models import Token


class Room(models.Model):
    GATHERING = "GATHERING"
    OPEN = "OPEN"
    RENEWAL_DUE = "RENEWAL_DUE"
    GATE_STATUS_CHOICES = [
        (GATHERING, "GATHERING GAMERS"),
        (OPEN, "Open"),
        (RENEWAL_DUE, "Renewal Due"),
    ]

    PRIVATE = "PRIVATE"
    PUBLIC = "PUBLIC"
    INVITE_ONLY = "INVITE ONLY"
    VISIBILITY_CHOICES = [
        (PRIVATE, "Private"),
        (PUBLIC, "Public"),
        (INVITE_ONLY, "Invite Only"),
    ]

    ROLE_SELECT = "ROLE_SELECT"
    SIG_SELECT = "SIG_SELECT"
    IN_GAME = "IN_GAME"
    TABLE_STATUS_CHOICES = [
        (ROLE_SELECT, "Role Select"),
        (SIG_SELECT, "Significator Select"),
        (IN_GAME, "In Game"),
    ]

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=200)
    owner = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="owned_rooms"
    )
    visibility = models.CharField(max_length=20, choices=VISIBILITY_CHOICES, default=PRIVATE)
    gate_status = models.CharField(max_length=20, choices=GATE_STATUS_CHOICES, default=GATHERING)
    table_status = models.CharField(
        max_length=20, choices=TABLE_STATUS_CHOICES, null=True, blank=True
    )
    renewal_period = models.DurationField(null=True, blank=True, default=timedelta(days=7))
    created_at = models.DateTimeField(auto_now_add=True)
    board_state = models.JSONField(default=dict)
    seed_count = models.IntegerField(default=12)


class GateSlot(models.Model):
    EMPTY = "EMPTY"
    RESERVED = "RESERVED"
    FILLED = "FILLED"
    STATUS_CHOICES = [
        (EMPTY, "Empty"),
        (RESERVED, "Reserved"),
        (FILLED, "Filled"),
    ]

    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name="gate_slots")
    slot_number = models.IntegerField()
    gamer = models.ForeignKey(
        settings.AUTH_USER_MODEL, null=True, blank=True,
        on_delete=models.SET_NULL, related_name="gate_slots"
    )
    funded_by = models.ForeignKey(
        settings.AUTH_USER_MODEL, null=True, blank=True,
        on_delete=models.SET_NULL, related_name="funded_slots"
    )
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=EMPTY)
    reserved_at = models.DateTimeField(null=True, blank=True)
    filled_at = models.DateTimeField(null=True, blank=True)
    debited_token_type = models.CharField(max_length=8, null=True, blank=True)
    debited_token_expires_at = models.DateTimeField(null=True, blank=True)


class RoomInvite(models.Model):
    PENDING = "PENDING"
    ACCEPTED = "ACCEPTED"
    DECLINED = "DECLINED"
    STATUS_CHOICES = [
        (PENDING, "Pending"),
        (ACCEPTED, "Accepted"),
        (DECLINED, "Declined"),
    ]

    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name="invites")
    inviter = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="sent_invites"
    )
    invitee_email = models.EmailField()
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=PENDING)
    created_at = models.DateTimeField(auto_now_add=True)


@receiver(post_save, sender=Room)
def create_gate_slots(sender, instance, created, **kwargs):
    if created:
        for i in range(1, 7):
            GateSlot.objects.create(room=instance, slot_number=i)


def select_token(user):
    if user.is_staff:
        pass_token = user.tokens.filter(token_type=Token.PASS).first()
        if pass_token:
            return pass_token
    coin = user.tokens.filter(token_type=Token.COIN, current_room__isnull=True).first()
    if coin:
        return coin
    free = user.tokens.filter(
        token_type=Token.FREE,
        expires_at__gt=timezone.now(),
    ).order_by("expires_at").first()
    if free:
        return free
    return user.tokens.filter(token_type=Token.TITHE).first()


def debit_token(user, slot, token):
    slot.debited_token_type = token.token_type
    if token.token_type == Token.COIN:
        token.current_room = slot.room
        period = slot.room.renewal_period or timedelta(days=7)
        token.next_ready_at = timezone.now() + period
        token.save()
    elif token.token_type == Token.CARTE:
        pass  # current_room already set in drop_token; token not consumed
    elif token.token_type != Token.PASS:
        slot.debited_token_expires_at = token.expires_at
        token.delete()
    slot.gamer = user
    slot.status = GateSlot.FILLED
    slot.filled_at = timezone.now()
    slot.save()

    room = slot.room
    if not room.gate_slots.filter(status=GateSlot.EMPTY).exists():
        room.gate_status = Room.OPEN
        room.save()


SIG_SEAT_ORDER = ["PC", "NC", "EC", "SC", "AC", "BC"]


class TableSeat(models.Model):
    PC = "PC"
    BC = "BC"
    SC = "SC"
    AC = "AC"
    NC = "NC"
    EC = "EC"
    ROLE_CHOICES = [
        (PC, "Player"),
        (BC, "Builder"),
        (SC, "Shepherd"),
        (AC, "Alchemist"),
        (NC, "Narrator"),
        (EC, "Economist"),
    ]
    PARTNER_MAP = {PC: BC, BC: PC, SC: AC, AC: SC, NC: EC, EC: NC}

    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name="table_seats")
    gamer = models.ForeignKey(
        settings.AUTH_USER_MODEL, null=True, blank=True,
        on_delete=models.SET_NULL, related_name="table_seats"
    )
    slot_number = models.IntegerField()
    role = models.CharField(max_length=2, choices=ROLE_CHOICES, null=True, blank=True)
    role_revealed = models.BooleanField(default=False)
    seat_position = models.IntegerField(null=True, blank=True)
    significator = models.ForeignKey(
        "TarotCard", null=True, blank=True,
        on_delete=models.SET_NULL, related_name="significator_seats",
    )


class DeckVariant(models.Model):
    """A named deck variant, e.g. Earthman (108 cards) or Fiorentine Minchiate (78 cards)."""

    name = models.CharField(max_length=100, unique=True)
    slug = models.SlugField(unique=True)
    card_count = models.IntegerField()
    description = models.TextField(blank=True)
    is_default = models.BooleanField(default=False)

    @property
    def short_key(self):
        """First dash-separated word of slug — used as an HTML id component."""
        return self.slug.split('-')[0]

    def __str__(self):
        return f"{self.name} ({self.card_count} cards)"


class TarotCard(models.Model):
    MAJOR = "MAJOR"
    MINOR = "MINOR"
    ARCANA_CHOICES = [
        (MAJOR, "Major Arcana"),
        (MINOR, "Minor Arcana"),
    ]

    WANDS = "WANDS"
    CUPS = "CUPS"
    SWORDS = "SWORDS"
    PENTACLES = "PENTACLES"   # Fiorentine 4th suit
    SUIT_CHOICES = [
        (WANDS, "Wands"),
        (CUPS, "Cups"),
        (SWORDS, "Swords"),
        (PENTACLES, "Pentacles"),
    ]

    deck_variant = models.ForeignKey(
        DeckVariant, null=True, blank=True,
        on_delete=models.CASCADE, related_name="cards",
    )
    name = models.CharField(max_length=200)
    arcana = models.CharField(max_length=5, choices=ARCANA_CHOICES)
    suit = models.CharField(max_length=10, choices=SUIT_CHOICES, null=True, blank=True)
    number = models.IntegerField()  # 0–21 major (Fiorentine); 0–51 major (Earthman); 1–14 minor
    slug = models.SlugField(max_length=120)
    correspondence = models.CharField(max_length=200, blank=True)  # standard / Italian equivalent
    group = models.CharField(max_length=100, blank=True)           # Earthman major grouping
    keywords_upright = models.JSONField(default=list)
    keywords_reversed = models.JSONField(default=list)

    class Meta:
        ordering = ["deck_variant", "arcana", "suit", "number"]
        unique_together = [("deck_variant", "slug")]

    @staticmethod
    def _to_roman(n):
        if n == 0:
            return '0'
        val  = [50, 40, 10,  9,  5,  4,  1]
        syms = ['L','XL','X','IX','V','IV','I']
        result = ''
        for v, s in zip(val, syms):
            while n >= v:
                result += s
                n -= v
        return result

    @property
    def corner_rank(self):
        if self.arcana == self.MAJOR:
            return self._to_roman(self.number)
        court = {11: 'M', 12: 'J', 13: 'Q', 14: 'K'}
        return court.get(self.number, str(self.number))

    @property
    def name_group(self):
        """Returns 'Group N:' prefix if the name contains ': ', else ''."""
        if ': ' in self.name:
            return self.name.split(': ', 1)[0] + ':'
        return ''

    @property
    def name_title(self):
        """Returns the title after 'Group N: ', or the full name if no colon."""
        if ': ' in self.name:
            return self.name.split(': ', 1)[1]
        return self.name

    @property
    def suit_icon(self):
        if self.arcana == self.MAJOR:
            return ''
        return {
            self.WANDS:     'fa-wand-sparkles',
            self.CUPS:      'fa-trophy',
            self.SWORDS:    'fa-gun',
            self.PENTACLES: 'fa-star',
        }.get(self.suit, '')

    def __str__(self):
        return self.name


class TarotDeck(models.Model):
    """One shuffled deck per room, scoped to the founder's chosen DeckVariant."""

    room = models.OneToOneField(Room, on_delete=models.CASCADE, related_name="tarot_deck")
    deck_variant = models.ForeignKey(
        DeckVariant, null=True, blank=True,
        on_delete=models.SET_NULL, related_name="active_decks",
    )
    drawn_card_ids = models.JSONField(default=list)
    created_at = models.DateTimeField(auto_now_add=True)

    @property
    def remaining_count(self):
        total = self.deck_variant.card_count if self.deck_variant else 0
        return total - len(self.drawn_card_ids)

    def draw(self, n=1):
        """Draw n cards at random. Returns list of (TarotCard, reversed: bool) tuples."""
        available = list(
            TarotCard.objects.filter(deck_variant=self.deck_variant)
            .exclude(id__in=self.drawn_card_ids)
        )
        if len(available) < n:
            raise ValueError(
                f"Not enough cards remaining: {len(available)} available, {n} requested"
            )
        drawn = random.sample(available, n)
        self.drawn_card_ids = self.drawn_card_ids + [card.id for card in drawn]
        self.save(update_fields=["drawn_card_ids"])
        return [(card, random.choice([True, False])) for card in drawn]

    def shuffle(self):
        """Reset the deck so all variant cards are available again."""
        self.drawn_card_ids = []
        self.save(update_fields=["drawn_card_ids"])


# ── SigReservation — provisional card hold during SIG_SELECT ──────────────────

class SigReservation(models.Model):
    LEVITY = 'levity'
    GRAVITY = 'gravity'
    POLARITY_CHOICES = [(LEVITY, 'Levity'), (GRAVITY, 'Gravity')]

    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name='sig_reservations')
    gamer = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='sig_reservations'
    )
    card = models.ForeignKey(
        'TarotCard', on_delete=models.CASCADE, related_name='sig_reservations'
    )
    role = models.CharField(max_length=2)
    polarity = models.CharField(max_length=7, choices=POLARITY_CHOICES)
    reserved_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        constraints = [
            UniqueConstraint(
                fields=['room', 'gamer'],
                name='one_sig_reservation_per_gamer_per_room',
            ),
            UniqueConstraint(
                fields=['room', 'card', 'polarity'],
                name='one_reservation_per_card_per_polarity_per_room',
            ),
        ]


# ── Significator deck helpers ─────────────────────────────────────────────────

def sig_deck_cards(room):
    """Return 36 TarotCard objects forming the Significator deck (18 unique × 2).

    PC/BC pair → WANDS + PENTACLES court cards (numbers 11–14): 8 unique
    SC/AC pair → SWORDS + CUPS court cards (numbers 11–14):     8 unique
    NC/EC pair → MAJOR arcana numbers 0 and 1:                  2 unique
    Total: 18 unique × 2 (levity + gravity piles) = 36 cards.
    """
    deck_variant = room.owner.equipped_deck
    if deck_variant is None:
        return []
    wands_pentacles = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MINOR,
        suit__in=[TarotCard.WANDS, TarotCard.PENTACLES],
        number__in=[11, 12, 13, 14],
    ))
    swords_cups = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MINOR,
        suit__in=[TarotCard.SWORDS, TarotCard.CUPS],
        number__in=[11, 12, 13, 14],
    ))
    major = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MAJOR,
        number__in=[0, 1],
    ))
    unique_cards = wands_pentacles + swords_cups + major  # 18 unique
    return unique_cards + unique_cards  # × 2 = 36


def _sig_unique_cards(room):
    """Return the 18 unique TarotCard objects that form one sig pile."""
    deck_variant = room.owner.equipped_deck
    if deck_variant is None:
        return []
    wands_pentacles = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MINOR,
        suit__in=[TarotCard.WANDS, TarotCard.PENTACLES],
        number__in=[11, 12, 13, 14],
    ))
    swords_cups = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MINOR,
        suit__in=[TarotCard.SWORDS, TarotCard.CUPS],
        number__in=[11, 12, 13, 14],
    ))
    major = list(TarotCard.objects.filter(
        deck_variant=deck_variant,
        arcana=TarotCard.MAJOR,
        number__in=[0, 1],
    ))
    return wands_pentacles + swords_cups + major


def levity_sig_cards(room):
    """The 18 cards available to the levity group (PC/NC/SC)."""
    return _sig_unique_cards(room)


def gravity_sig_cards(room):
    """The 18 cards available to the gravity group (BC/EC/AC)."""
    return _sig_unique_cards(room)


def sig_seat_order(room):
    """Return TableSeats in canonical PC→NC→EC→SC→AC→BC order."""
    _order = {r: i for i, r in enumerate(SIG_SEAT_ORDER)}
    seats = list(room.table_seats.all())
    return sorted(seats, key=lambda s: _order.get(s.role, 99))


def active_sig_seat(room):
    """Return the first seat without a significator in canonical order, or None."""
    for seat in sig_seat_order(room):
        if seat.significator_id is None:
            return seat
    return None