fvtt-hamalron/module/applications/tarot-deck-manager.mjs

const { HandlebarsApplicationMixin } = foundry.applications.api

export default class HamalronTarotDeckManager extends HandlebarsApplicationMixin(foundry.applications.api.ApplicationV2) {
  constructor(options = {}) {
    super(options)
    this.deck = []
    this.discard = []
  }

  /** @override */
  static DEFAULT_OPTIONS = {
    id: "tarot-deck-manager",
    classes: ["fvtt-hamalron", "tarot-deck-manager"],
    tag: "div",
    window: {
      title: "HAMALRON.TarotDeck.Title",
      icon: "fas fa-cards",
      resizable: true,
    },
    position: {
      width: 600,
      height: 700,
    },
    actions: {
      resetDeck: HamalronTarotDeckManager.#onResetDeck,
      drawCard: HamalronTarotDeckManager.#onDrawCard,
      drawMultiple: HamalronTarotDeckManager.#onDrawMultiple,
      shuffleDiscard: HamalronTarotDeckManager.#onShuffleDiscard,
      collectHands: HamalronTarotDeckManager.#onCollectHands,
      distributeCards: HamalronTarotDeckManager.#onDistributeCards,
      drawTension: HamalronTarotDeckManager.#onDrawTension,
      drawThreeTrumps: HamalronTarotDeckManager.#onDrawThreeTrumps,
      drawEightNumbered: HamalronTarotDeckManager.#onDrawEightNumbered,
      drawOneTrump: HamalronTarotDeckManager.#onDrawOneTrump,
    },
  }

  /** @override */
  static PARTS = {
    main: {
      template: "systems/fvtt-hamalron/templates/tarot-deck-manager.hbs",
    },
  }

  /**
   * Save the current deck state to settings
   */
  async saveDeckState() {
    const state = {
      deck: this.deck,
      discard: this.discard,
    }
    await game.settings.set("fvtt-hamalron", "tarotDeckState", state)
    console.log("Deck state saved:", state)
  }

  /**
   * Load the deck state from settings
   */
  async loadDeckState() {
    const state = game.settings.get("fvtt-hamalron", "tarotDeckState")
    if (state && state.deck && state.deck.length > 0) {
      this.deck = state.deck
      this.discard = state.discard || []
    } else {
      await this.resetDeck()
    }
  }

  /**
   * Reset the deck to a full tarot deck
   */
  async resetDeck() {
    this.deck = []
    this.discard = []

    let items = game.items.filter(i => i.type === "tarot")

    // Si aucune carte dans le monde, importer depuis le compendium système
    if (items.length === 0) {
      const pack = game.packs.get("fvtt-hamalron.hamalron-items")
      if (pack) {
        const docs = await pack.getDocuments()
        const tarotDocs = docs.filter(d => d.type === "tarot")
        if (tarotDocs.length > 0) {
          for (const doc of tarotDocs) {
            const imported = await Item.create(doc.toObject(), { temporary: false })
            if (imported) items.push(imported)
          }
        }
      }
    }

    // Dernier recours : créer les cartes depuis les données JSON
    if (items.length === 0) {
      try {
        const resp = await fetch("systems/fvtt-hamalron/assets/data/tarot.json")
        const data = await resp.json()
        if (Array.isArray(data) && data.length > 0) {
          for (const card of data) {
            const created = await Item.create({
              name: card.name,
              type: "tarot",
              img: "icons/svg/treasure.svg",
              system: {
                type: card.type,
                symbole: card.symbole,
                valeur: card.valeur,
                description: card.description || `<p>${card.name}</p>`,
                image: "icons/svg/treasure.svg",
              },
            })
            if (created) items.push(created)
          }
        }
      } catch (e) {
        console.warn("Hamalron | Failed to load tarot.json:", e)
      }
    }

    // Construire le deck
    this.deck = items.map(item => ({
      id: item.id,
      name: item.name,
      img: item.img,
      symbole: item.system.symbole,
      valeur: item.system.valeur,
      type: item.system.type,
      description: item.system.description,
    }))

    // Mélanger le deck
    this.shuffleDeck()
    await this.saveDeckState()
    this.render()
  }

  /**
   * Shuffle the deck using Fisher-Yates algorithm
   */
  shuffleDeck() {
    for (let i = this.deck.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [this.deck[i], this.deck[j]] = [this.deck[j], this.deck[i]]
    }
  }

  /**
   * Draw a card from the deck
   * @param {number} count - Number of cards to draw
   * @returns {Array} - Drawn cards
   */
  drawCards(count = 1) {
    if (this.deck.length === 0) {
      ui.notifications.warn("HAMALRON.TarotDeck.DeckEmpty", { localize: true })
      return []
    }

    const drawn = []
    for (let i = 0; i < count && this.deck.length > 0; i++) {
      const card = this.deck.shift()
      drawn.push(card)
    }

    return drawn
  }

  /**
   * Send drawn cards to chat
   * @param {Array} cards - Cards to send to chat
   */
  async sendCardsToChat(cards) {
    if (cards.length === 0) return

    const speaker = ChatMessage.getSpeaker({ alias: "Maître du Jeu" })

    for (const card of cards) {
      const content = await foundry.applications.handlebars.renderTemplate(
        "systems/fvtt-hamalron/templates/chat-tarot-draw.hbs",
        {
          card: card,
          symboleLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.symbole.${card.symbole}`),
          valeurLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.valeur.${card.valeur}`),
          typeLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.type.${card.type}`),
        }
      )

      await ChatMessage.create({
        speaker: speaker,
        content: content,
        style: CONST.CHAT_MESSAGE_STYLES.OTHER,
      })
    }
  }

  /** @override */
  async _prepareContext(options) {
    const context = await super._prepareContext(options)

    context.deckCount = this.deck.length
    context.discardCount = this.discard.length
    context.totalCards = this.deck.length + this.discard.length
    context.hasCards = this.deck.length > 0
    context.hasDiscard = this.discard.length > 0

    return context
  }

  /**
   * Handle reset deck action
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onResetDeck(event, target) {
    const confirmed = await foundry.applications.api.DialogV2.confirm({
      window: { title: "HAMALRON.TarotDeck.ResetConfirm" },
      content: `<p>${game.i18n.localize("HAMALRON.TarotDeck.ResetWarning")}</p>`,
      rejectClose: false,
      modal: true,
    })

    if (confirmed) {
      await this.resetDeck()
      ui.notifications.info("HAMALRON.TarotDeck.DeckReset", { localize: true })
    }
  }

  /**
   * Handle draw single card action
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawCard(event, target) {
    const cards = this.drawCards(1)
    if (cards.length > 0) {
      await this.sendCardsToChat(cards)
      // Ajouter les cartes directement à la défausse
      cards.forEach(card => this.addToDiscard(card))
      this.saveDeckState()
      this.render()
    }
  }

  /**
   * Handle draw multiple cards action
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawMultiple(event, target) {
    const count = parseInt(target.dataset.count || "1")
    const cards = this.drawCards(count)
    if (cards.length > 0) {
      await this.sendCardsToChat(cards)
      // Ajouter les cartes directement à la défausse
      cards.forEach(card => this.addToDiscard(card))
      this.saveDeckState()
      this.render()
    }
  }

  /**
   * Add a card to the discard pile
   * @param {Object} card - Card to add to discard
   */
  addToDiscard(card) {
    // Vérifier que la carte n'est pas déjà dans la défausse
    const cardExists = this.discard.some(c => c.id === card.id)
    if (!cardExists) {
      this.discard.push(card)
      this.saveDeckState()
      this.render()
    }
  }

  /**
   * Collect all tarot cards from player characters and return them to the deck
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onCollectHands(event, target) {
    const confirmed = await foundry.applications.api.DialogV2.confirm({
      window: { title: game.i18n.localize("HAMALRON.TarotDeck.CollectHandsConfirm") },
      content: `<p>${game.i18n.localize("HAMALRON.TarotDeck.CollectHandsWarning")}</p>`,
      rejectClose: false,
      modal: true,
    })

    if (!confirmed) return

    let totalCollected = 0

    // Récupérer tous les acteurs de type personnage (incluant tous, pas seulement ceux avec propriété joueur)
    const playerCharacters = game.actors.filter(a => a.type === "personnage")

    console.log("Found characters:", playerCharacters.length)

    // Collecter toutes les cartes de tarot de tous les personnages
    for (const actor of playerCharacters) {
      const tarotCards = actor.items.filter(i => i.type === "tarot")
      console.log(`Actor ${actor.name} has ${tarotCards.length} tarot cards`)

      if (tarotCards.length > 0) {
        // Supprimer les cartes de l'acteur
        const cardIds = tarotCards.map(c => c.id)
        console.log(`Deleting ${cardIds.length} cards from ${actor.name}`)
        await actor.deleteEmbeddedDocuments("Item", cardIds)
        console.log(`Deleted cards from ${actor.name}`)
        totalCollected += tarotCards.length
      }
    }

    // Réinitialiser le deck avec toutes les cartes de tarot disponibles
    this.deck = []
    this.discard = []

    const items = game.items.filter(i => i.type === "tarot")

    if (items.length > 0) {
      // Créer un Map pour éviter les doublons (utiliser l'ID unique)
      const uniqueCards = new Map()

      items.forEach(item => {
        const key = `${item.system.symbole}_${item.system.valeur}_${item.system.type}`
        if (!uniqueCards.has(key)) {
          uniqueCards.set(key, {
            id: item.id,
            name: item.name,
            img: item.img,
            symbole: item.system.symbole,
            valeur: item.system.valeur,
            type: item.system.type,
            description: item.system.description,
          })
        }
      })

      this.deck = Array.from(uniqueCards.values())
    }

    // Mélanger le deck
    this.shuffleDeck()

    this.saveDeckState()

    ui.notifications.info(
      game.i18n.format("HAMALRON.TarotDeck.HandsCollected", {
        collected: totalCollected,
        deckSize: this.deck.length
      })
    )

    this.render()
  }

  /**
   * Distribute 8 cards to all connected players (starting hand)
   * Excludes the Mat from distribution, then returns it to the deck and reshuffles
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDistributeCards(event, target) {
    if (this.deck.length < 8) {
      ui.notifications.warn(game.i18n.localize("HAMALRON.TarotDeck.NotEnoughCards"))
      return
    }

    const confirmed = await foundry.applications.api.DialogV2.confirm({
      window: { title: game.i18n.localize("HAMALRON.TarotDeck.DistributeConfirm") },
      content: `<p>${game.i18n.localize("HAMALRON.TarotDeck.DistributeWarning")}</p>`,
      rejectClose: false,
      modal: true,
    })

    if (!confirmed) return

    let distributedCount = 0
    let playersCount = 0
    let matCard = null

    // Récupérer tous les utilisateurs connectés (sauf le GM)
    const connectedPlayers = game.users.filter(u => u.active && !u.isGM)

    for (const user of connectedPlayers) {
      // Trouver le personnage du joueur (premier actor de type personnage dont il est propriétaire)
      const playerCharacter = game.actors.find(a =>
        a.type === "personnage" &&
        a.testUserPermission(user, "OWNER")
      )

      if (playerCharacter) {
        // Tirer 8 cartes pour ce personnage (en ignorant le Mat)
        const cardsToDistribute = []
        let attempts = 0
        const maxAttempts = this.deck.length + 10 // Safety limit

        while (cardsToDistribute.length < 8 && this.deck.length > 0 && attempts < maxAttempts) {
          const card = this.deck.shift()
          attempts++

          // Si c'est le Mat, le mettre de côté
          if (card.valeur === "lemat") {
            matCard = card
            console.log("Le Mat trouvé et mis de côté pour être remis dans le deck après distribution")
            continue
          }

          cardsToDistribute.push(card)
        }

        // Créer les items sur l'acteur
        for (const card of cardsToDistribute) {
          const originalItem = game.items.get(card.id)
          if (originalItem) {
            await playerCharacter.createEmbeddedDocuments("Item", [originalItem.toObject()])
            distributedCount++
          }
        }

        playersCount++
      }
    }

    // Remettre le Mat dans le deck si il a été trouvé
    if (matCard) {
      this.deck.push(matCard)
      console.log("Le Mat a été remis dans le deck")
    }

    // Remélanger le deck restant
    this.shuffleDeck()
    console.log("Le deck restant a été remélangé")

    this.saveDeckState()

    ui.notifications.info(
      game.i18n.format("HAMALRON.TarotDeck.CardsDistributed", {
        cards: distributedCount,
        players: playersCount
      })
    )

    this.render()
  }

  /**
   * Draw 3 trumps (atouts only)
   * Cards are returned to deck and reshuffled after draw
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawThreeTrumps(event, target) {
    const trumpCards = this.deck.filter(card => card.type === "atout")

    if (trumpCards.length < 3) {
      ui.notifications.warn(game.i18n.localize("HAMALRON.TarotDeck.NotEnoughTrumps"))
      return
    }

    // Tirer 3 atouts au hasard
    const drawnCards = []
    const availableTrumps = [...trumpCards]

    for (let i = 0; i < 3; i++) {
      const randomIndex = Math.floor(Math.random() * availableTrumps.length)
      const card = availableTrumps.splice(randomIndex, 1)[0]
      drawnCards.push(card)
    }

    // Envoyer au chat
    await this.sendCardsToChat(drawnCards)

    // Remélanger le deck (les cartes restent dedans)
    this.shuffleDeck()
    this.saveDeckState()
    this.render()

    ui.notifications.info(game.i18n.localize("HAMALRON.TarotDeck.ThreeTrumpsDrawn"))
  }

  /**
   * Draw 8 numbered cards (cards 1-10 from the 4 symbols)
   * Cards are returned to deck and reshuffled after draw
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawEightNumbered(event, target) {
    const numberedCards = this.deck.filter(card => card.type === "numéro")

    if (numberedCards.length < 8) {
      ui.notifications.warn(game.i18n.localize("HAMALRON.TarotDeck.NotEnoughNumbered"))
      return
    }

    // Tirer 8 cartes numérotées au hasard
    const drawnCards = []
    const availableNumbered = [...numberedCards]

    for (let i = 0; i < 8; i++) {
      const randomIndex = Math.floor(Math.random() * availableNumbered.length)
      const card = availableNumbered.splice(randomIndex, 1)[0]
      drawnCards.push(card)
    }

    // Envoyer un résumé au chat
    await this.sendNumberedCardsSummaryToChat(drawnCards)

    // Remélanger le deck (les cartes restent dedans)
    this.shuffleDeck()
    this.saveDeckState()
    this.render()

    ui.notifications.info(game.i18n.localize("HAMALRON.TarotDeck.EightNumberedDrawn"))
  }

  /**
   * Draw 1 trump (atout only)
   * Card is returned to deck and reshuffled after draw
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawOneTrump(event, target) {
    const trumpCards = this.deck.filter(card => card.type === "atout")

    if (trumpCards.length === 0) {
      ui.notifications.warn(game.i18n.localize("HAMALRON.TarotDeck.NoTrumpsAvailable"))
      return
    }

    // Tirer 1 atout au hasard
    const randomIndex = Math.floor(Math.random() * trumpCards.length)
    const card = trumpCards[randomIndex]

    // Envoyer au chat
    await this.sendCardsToChat([card])

    // Remélanger le deck (la carte reste dedans)
    this.shuffleDeck()
    this.saveDeckState()
    this.render()

    ui.notifications.info(game.i18n.localize("HAMALRON.TarotDeck.OneTrumpDrawn"))
  }

  /**
   * Shuffle discard pile back into deck
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onShuffleDiscard(event, target) {
    if (this.discard.length === 0) {
      ui.notifications.warn(game.i18n.localize("HAMALRON.TarotDeck.NoDiscard"))
      return
    }

    // Ajouter toutes les cartes de la défausse au deck
    this.deck.push(...this.discard)
    this.discard = []

    // Mélanger le deck
    this.shuffleDeck()

    this.saveDeckState()

    ui.notifications.info(game.i18n.localize("HAMALRON.TarotDeck.DiscardShuffled"))
    this.render()
  }

  /**
   * Handle draw tension action
   * @param {Event} event
   * @param {HTMLElement} target
   */
  static async #onDrawTension(event, target) {
    // Import system config
    const { DIFFICULTY_CHOICES } = await import('../config/system.mjs')

    // Créer les options de difficulté
    const difficulties = Object.entries(DIFFICULTY_CHOICES)
      .filter(([key]) => key !== 'soustension_oppose')
      .map(([key, value]) => ({
        value: key,
        label: value.label
      }))

    // Créer le contenu HTML du dialogue
    const selectOptions = difficulties.map(d =>
      `<option value="${d.value}">${d.label}</option>`
    ).join('')

    const content = `
      <div class="form-group">
        <label>${game.i18n.localize("HAMALRON.Label.difficulty")}</label>
        <select id="tension-difficulty" class="tension-select">
          ${selectOptions}
        </select>
      </div>
    `

    // Afficher le dialogue
    const result = await foundry.applications.api.DialogV2.wait({
      window: { title: game.i18n.localize("HAMALRON.TarotDeck.SelectDifficulty") },
      content: content,
      buttons: [
        {
          action: "draw",
          label: game.i18n.localize("HAMALRON.TarotDeck.DrawCard"),
          default: true,
          callback: (event, button, dialog) => {
            const select = button.form.elements["tension-difficulty"]
            return select.value
          }
        },
        {
          action: "cancel",
          label: game.i18n.localize("Cancel")
        }
      ],
      rejectClose: false,
      modal: true
    })

    if (!result) return

    // Tirer une carte
    const cards = this.drawCards(1)
    if (cards.length === 0) return

    const card = cards[0]
    const difficultyKey = result
    const difficulty = DIFFICULTY_CHOICES[difficultyKey]

    // Récupérer la valeur numérique de la carte
    const { TAROT_VALEURS } = await import('../config/system.mjs')
    const cardValue = TAROT_VALEURS[card.valeur]?.value || 0
    const tensionBonus = difficulty.soustension || 0
    const totalScore = cardValue + tensionBonus

    // Afficher dans le chat
    await this.sendTensionDrawToChat(card, difficulty, cardValue, tensionBonus, totalScore)

    // Ajouter à la défausse
    this.addToDiscard(card)
    this.saveDeckState()
    this.render()
  }

  /**
   * Send tension draw to chat
   * @param {Object} card - The drawn card
   * @param {Object} difficulty - The selected difficulty
   * @param {number} cardValue - Card numeric value
   * @param {number} tensionBonus - Tension modifier
   * @param {number} totalScore - Total score
   */
  async sendTensionDrawToChat(card, difficulty, cardValue, tensionBonus, totalScore) {
    const speaker = ChatMessage.getSpeaker({ alias: "Maître du Jeu" })

    const content = await foundry.applications.handlebars.renderTemplate(
      "systems/fvtt-hamalron/templates/chat-tarot-tension.hbs",
      {
        card: card,
        symboleLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.symbole.${card.symbole}`),
        valeurLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.valeur.${card.valeur}`),
        typeLabel: game.i18n.localize(`HAMALRON.Tarot.FIELDS.type.${card.type}`),
        difficulty: difficulty,
        cardValue: cardValue,
        tensionBonus: tensionBonus,
        totalScore: totalScore
      }
    )

    await ChatMessage.create({
      speaker: speaker,
      content: content,
      style: CONST.CHAT_MESSAGE_STYLES.OTHER,
    })
  }

  /**
   * Send numbered cards summary to chat
   * @param {Array} cards - Array of numbered cards
   */
  async sendNumberedCardsSummaryToChat(cards) {
    const speaker = ChatMessage.getSpeaker({ alias: "Maître du Jeu" })

    // Créer la liste des cartes
    const cardsList = cards.map(card => {
      const symboleLabel = game.i18n.localize(`HAMALRON.Tarot.FIELDS.symbole.${card.symbole}`)
      const valeurLabel = game.i18n.localize(`HAMALRON.Tarot.FIELDS.valeur.${card.valeur}`)
      return `
        <div class="tarot-card-summary-item">
          <img src="${card.img}" alt="${card.name}" title="${card.name}" />
          <span class="card-name">${valeurLabel} de ${symboleLabel}</span>
        </div>
      `
    }).join('')

    const content = `
      <div class="fvtt-hamalron chat-tarot-summary">
        <h3 class="tarot-summary-title">
          <i class="fas fa-hashtag"></i>
          ${game.i18n.localize("HAMALRON.TarotDeck.EightNumberedCardsDrawn")}
        </h3>
        <div class="tarot-cards-grid">
          ${cardsList}
        </div>
      </div>
    `

    await ChatMessage.create({
      speaker: speaker,
      content: content,
      style: CONST.CHAT_MESSAGE_STYLES.OTHER,
    })
  }

  /**
   * Open the Tarot Deck Manager application
   * @returns {HamalronTarotDeckManager}
   */
  static async openManager() {
    if (!game.user.isGM) {
      ui.notifications.warn("HAMALRON.TarotDeck.GMOnly", { localize: true })
      return
    }

    // Singleton pattern - reuse existing instance or create new one
    if (!HamalronTarotDeckManager._instance) {
      HamalronTarotDeckManager._instance = new HamalronTarotDeckManager()
      await HamalronTarotDeckManager._instance.loadDeckState()
    }

    HamalronTarotDeckManager._instance.render(true, { focus: true })
    return HamalronTarotDeckManager._instance
  }
}