import crypto from 'crypto'
import { AIRichBuilder } from '#system/lib/mbuilder.js'
import { wrapWithVendors } from '#system/lib/game_vendors.js'

const towerHtml = `<style>
@import url("https://fonts.googleapis.com/css?family=Comfortaa");
* { box-sizing: border-box; margin: 0; padding: 0; -webkit-tap-highlight-color: transparent; user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; }
body {
  margin: 0;
  background: #D0CBC7;
  color: #334;
  font-family: "Comfortaa", cursive, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
  min-height: 100dvh;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: flex-start;
  padding: 10px 8px;
  touch-action: manipulation;
  cursor: pointer;
  overflow: hidden;
}
.stage {
  width: 100%;
  max-width: 280px;
  margin: 0 auto;
  display: flex;
  justify-content: center;
}
.stage-wrap {
  position: relative;
  width: 280px;
  height: 560px;
  max-width: 100%;
  aspect-ratio: 1 / 2;
  border-radius: 14px;
  overflow: hidden;
  border: 1px solid rgba(51, 51, 68, 0.25);
  box-shadow: 0 10px 30px rgba(51, 51, 68, 0.25);
  background: #D0CBC7;
}
#game {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
}
#game canvas {
  display: block;
  width: 100%;
  height: 100%;
}
#score {
  position: absolute;
  top: 20px;
  width: 100%;
  text-align: center;
  font-size: 54px;
  font-weight: 700;
  color: #334;
  pointer-events: none;
  transition: transform 0.5s ease;
  z-index: 10;
}
.stage-wrap.ended #score {
  transform: translateY(56px) scale(1.5);
}
.chips {
  position: absolute;
  top: 14px;
  right: 12px;
  display: flex;
  gap: 6px;
  align-items: center;
  z-index: 12;
}
.chips span {
  font-size: 11px;
  font-weight: 700;
  color: #334;
  background: rgba(51, 51, 68, 0.08);
  border: 1px solid rgba(51, 51, 68, 0.2);
  border-radius: 12px;
  padding: 4px 9px;
}
.chips button {
  background: rgba(51, 51, 68, 0.08);
  border: 1px solid rgba(51, 51, 68, 0.2);
  border-radius: 12px;
  padding: 3px 7px;
  font-size: 11px;
  cursor: pointer;
}
#instructions {
  position: absolute;
  top: 90px;
  width: 100%;
  text-align: center;
  font-size: 12px;
  color: #334;
  font-weight: 700;
  pointer-events: none;
  transition: opacity 0.4s ease;
  z-index: 10;
  padding: 0 20px;
  opacity: 0;
}
#instructions.hide { opacity: 0 !important; }
.stage-wrap.playing #instructions { opacity: 1; }
.game-over {
  position: absolute;
  inset: 0;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  background: rgba(208, 203, 199, 0.9);
  z-index: 20;
  opacity: 0;
  pointer-events: none;
  transition: opacity 0.4s ease;
  padding: 24px;
  text-align: center;
}
.game-over h2 {
  font-size: 30px;
  font-weight: 700;
  color: #334;
  margin-bottom: 8px;
}
.game-over .final-score {
  font-size: 34px;
  font-weight: 700;
  color: #334;
  margin: 6px 0;
}
.game-over p {
  font-size: 13px;
  color: #445;
  margin: 4px 0;
}
.game-over .retry-hint {
  margin-top: 18px;
  font-size: 14px;
  color: #334;
  font-weight: 700;
  animation: pulse 1.5s infinite;
}
.game-ready {
  position: absolute;
  inset: 0;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  background: transparent;
  z-index: 20;
  transition: opacity 0.4s ease;
}
.game-ready #start-button {
  border: 3px solid #334;
  padding: 12px 32px;
  background: transparent;
  color: #334;
  font-size: 22px;
  font-weight: 700;
  letter-spacing: 1px;
  cursor: pointer;
  transition: transform 0.15s ease;
}
.game-ready #start-button:active { transform: scale(0.95); }
.stage-wrap.ready .game-ready { opacity: 1; pointer-events: auto; }
.stage-wrap.playing .game-ready,
.stage-wrap.ended .game-ready { opacity: 0; pointer-events: none; }
.stage-wrap.ended .game-over { opacity: 1; pointer-events: auto; }
.foot {
  font-size: 11px;
  color: #556;
  margin-top: 8px;
  text-align: center;
  letter-spacing: 0.3px;
}
.foot b { color: #334; }
@keyframes pulse {
  0%, 100% { transform: scale(1); opacity: 1; }
  50% { transform: scale(1.05); opacity: 0.85; }
}
</style>

<div class="stage">
  <div class="stage-wrap ready" id="container">
    <div id="game"></div>
    <div id="score">0</div>
    <div class="chips">
      <span id="hdrBest">🏆 0</span>
      <button id="audioToggle" title="Toggle Sound">🔊</button>
    </div>
    <div id="instructions">Ketuk layar untuk menaruh balok tepat di atasnya</div>
    <div class="game-over">
      <h2>GAME OVER</h2>
      <p>Menara Anda runtuh!</p>
      <div class="final-score" id="finalScore">0</div>
      <p id="bestScoreText">Rekor Terbaik: 0</p>
      <div class="retry-hint">🔄 KETUK UNTUK MAIN LAGI</div>
    </div>
    <div class="game-ready">
      <div id="start-button">MULAI</div>
    </div>
  </div>
</div>

<div class="foot">
  👆 <b>TAP DI MANA SAJA</b> untuk menaruh balok · adaptasi game by TANAY PADAR
</div>
<script>
(function() {
  if (window.AndroidBridge && window.AndroidBridge.updateSize) {
    try { window.AndroidBridge.updateSize(650); } catch(e) {}
  }
  var container = document.getElementById("container");
  var hdrBest = document.getElementById("hdrBest");
  var audioToggle = document.getElementById("audioToggle");
  var finalScore = document.getElementById("finalScore");
  var bestScoreText = document.getElementById("bestScoreText");

  var bestScore = 0;
  try {
    bestScore = parseInt(localStorage.getItem('mithra_tower_best') || '0', 10) || 0;
  } catch(e) {}
  hdrBest.textContent = "🏆 " + bestScore;

  // WebAudio Synth
  var audioCtx = null;
  var muted = false;
  function initAudio() {
    if (!audioCtx) {
      var AC = window.AudioContext || window.webkitAudioContext;
      if (AC) {
        try { audioCtx = new AC(); } catch (e) {}
      }
    }
    if (audioCtx && audioCtx.state === 'suspended') {
      audioCtx.resume().catch(function() {});
    }
  }

  function playTone(freq, dur, type, vol) {
    if (muted) return;
    initAudio();
    if (!audioCtx) return;
    try {
      var osc = audioCtx.createOscillator();
      var gain = audioCtx.createGain();
      osc.type = type || 'sine';
      osc.frequency.setValueAtTime(freq, audioCtx.currentTime);
      gain.gain.setValueAtTime(vol || 0.12, audioCtx.currentTime);
      gain.gain.exponentialRampToValueAtTime(0.0001, audioCtx.currentTime + dur);
      osc.connect(gain);
      gain.connect(audioCtx.destination);
      osc.start();
      osc.stop(audioCtx.currentTime + dur);
    } catch(e) {}
  }

  var PENTATONIC = [261.63, 293.66, 329.63, 392.00, 440.00, 523.25, 587.33, 659.25, 783.99, 880.00];
  function playPlace(index, isBonus) {
    var note = PENTATONIC[index % PENTATONIC.length];
    var octave = Math.floor(index / PENTATONIC.length) * 0.25;
    var freq = note * Math.pow(2, octave);
    playTone(freq, isBonus ? 0.3 : 0.12, isBonus ? 'triangle' : 'sine', isBonus ? 0.16 : 0.1);
    if (isBonus) {
      setTimeout(function() { playTone(freq * 1.5, 0.25, 'triangle', 0.14); }, 70);
    }
  }
  function playHitMiss() {
    playTone(160, 0.25, 'sawtooth', 0.15);
    setTimeout(function() { playTone(110, 0.35, 'sawtooth', 0.12); }, 90);
  }

  audioToggle.addEventListener('click', function(e) {
    e.stopPropagation();
    initAudio();
    muted = !muted;
    audioToggle.textContent = muted ? '🔇' : '🔊';
  });

  var Stage = (function () {
    function Stage() {
      var _this = this;
      this.render = function () {
        this.renderer.render(this.scene, this.camera);
      };
      this.add = function (elem) {
        this.scene.add(elem);
      };
      this.remove = function (elem) {
        this.scene.remove(elem);
      };
      this.container = document.getElementById("game");

      this.renderer = new THREE.WebGLRenderer({
        antialias: true,
        alpha: false,
      });

      var w = 280;
      var h = 560;
      this.renderer.setSize(w, h);
      this.renderer.setClearColor("#D0CBC7", 1);
      this.container.appendChild(this.renderer.domElement);

      this.scene = new THREE.Scene();

      var aspect = w / h; // 0.5
      var d = 20;
      this.camera = new THREE.OrthographicCamera(
        -d * aspect,
        d * aspect,
        d,
        -d,
        -100,
        1000
      );
      this.camera.position.x = 2;
      this.camera.position.y = 2;
      this.camera.position.z = 2;
      this.camera.lookAt(new THREE.Vector3(0, 0, 0));

      this.light = new THREE.DirectionalLight(0xffffff, 0.5);
      this.light.position.set(0, 499, 0);
      this.scene.add(this.light);
      this.softLight = new THREE.AmbientLight(0xffffff, 0.4);
      this.scene.add(this.softLight);

      window.addEventListener("resize", function () {
        return _this.onResize();
      });
      this.onResize();
    }

    Stage.prototype.setCamera = function (y, speed) {
      if (speed === void 0) speed = 0.3;
      TweenLite.to(this.camera.position, speed, {
        y: y + 4,
        ease: Power1.easeInOut,
      });
      TweenLite.to(this.camera.lookAt, speed, { y: y, ease: Power1.easeInOut });
    };

    Stage.prototype.onResize = function () {
      var w = this.container.clientWidth || 280;
      var h = this.container.clientHeight || (w * 2);
      this.renderer.setSize(w, h);
      var aspect = w / h;
      var d = 20;
      this.camera.left = -d * aspect;
      this.camera.right = d * aspect;
      this.camera.top = d;
      this.camera.bottom = -d;
      this.camera.updateProjectionMatrix();
    };
    return Stage;
  })();

  var Block = (function () {
    function Block(block) {
      this.STATES = { ACTIVE: "active", STOPPED: "stopped", MISSED: "missed" };
      this.MOVE_AMOUNT = 12;
      this.dimension = { width: 0, height: 0, depth: 0 };
      this.position = { x: 0, y: 0, z: 0 };
      this.targetBlock = block;
      this.index = (this.targetBlock ? this.targetBlock.index : 0) + 1;
      this.workingPlane = this.index % 2 ? "x" : "z";
      this.workingDimension = this.index % 2 ? "width" : "depth";

      this.dimension.width = this.targetBlock ? this.targetBlock.dimension.width : 10;
      this.dimension.height = this.targetBlock ? this.targetBlock.dimension.height : 2;
      this.dimension.depth = this.targetBlock ? this.targetBlock.dimension.depth : 10;

      this.position.x = this.targetBlock ? this.targetBlock.position.x : 0;
      this.position.y = this.dimension.height * this.index;
      this.position.z = this.targetBlock ? this.targetBlock.position.z : 0;
      this.colorOffset = this.targetBlock ? this.targetBlock.colorOffset : Math.round(Math.random() * 100);

      if (!this.targetBlock) {
        this.color = 0x333344;
      } else {
        var offset = this.index + this.colorOffset;
        var r = Math.sin(0.3 * offset) * 55 + 200;
        var g = Math.sin(0.3 * offset + 2) * 55 + 200;
        var b = Math.sin(0.3 * offset + 4) * 55 + 200;
        this.color = new THREE.Color(r / 255, g / 255, b / 255);
      }

      this.state = this.index > 1 ? this.STATES.ACTIVE : this.STATES.STOPPED;
      this.speed = -0.1 - this.index * 0.005;
      if (this.speed < -4) this.speed = -4;
      this.direction = this.speed;

      var geometry = new THREE.BoxGeometry(
        this.dimension.width,
        this.dimension.height,
        this.dimension.depth
      );
      geometry.applyMatrix(
        new THREE.Matrix4().makeTranslation(
          this.dimension.width / 2,
          this.dimension.height / 2,
          this.dimension.depth / 2
        )
      );
      this.material = new THREE.MeshToonMaterial({
        color: this.color,
        shading: THREE.FlatShading,
      });
      this.mesh = new THREE.Mesh(geometry, this.material);
      this.mesh.position.set(
        this.position.x,
        this.position.y,
        this.position.z
      );
      if (this.state == this.STATES.ACTIVE) {
        this.position[this.workingPlane] = Math.random() > 0.5 ? -this.MOVE_AMOUNT : this.MOVE_AMOUNT;
      }
    }

    Block.prototype.reverseDirection = function () {
      this.direction = this.direction > 0 ? this.speed : Math.abs(this.speed);
    };

    Block.prototype.place = function () {
      this.state = this.STATES.STOPPED;
      var overlap =
        this.targetBlock.dimension[this.workingDimension] -
        Math.abs(
          this.position[this.workingPlane] -
            this.targetBlock.position[this.workingPlane]
        );
      var blocksToReturn = {
        plane: this.workingPlane,
        direction: this.direction,
      };

      if (this.dimension[this.workingDimension] - overlap < 0.3) {
        overlap = this.dimension[this.workingDimension];
        blocksToReturn.bonus = true;
        this.position.x = this.targetBlock.position.x;
        this.position.z = this.targetBlock.position.z;
        this.dimension.width = this.targetBlock.dimension.width;
        this.dimension.depth = this.targetBlock.dimension.depth;
      }

      if (overlap > 0) {
        var choppedDimensions = {
          width: this.dimension.width,
          height: this.dimension.height,
          depth: this.dimension.depth,
        };
        choppedDimensions[this.workingDimension] -= overlap;
        this.dimension[this.workingDimension] = overlap;

        var placedGeometry = new THREE.BoxGeometry(
          this.dimension.width,
          this.dimension.height,
          this.dimension.depth
        );
        placedGeometry.applyMatrix(
          new THREE.Matrix4().makeTranslation(
            this.dimension.width / 2,
            this.dimension.height / 2,
            this.dimension.depth / 2
          )
        );
        var placedMesh = new THREE.Mesh(placedGeometry, this.material);

        var choppedGeometry = new THREE.BoxGeometry(
          choppedDimensions.width,
          choppedDimensions.height,
          choppedDimensions.depth
        );
        choppedGeometry.applyMatrix(
          new THREE.Matrix4().makeTranslation(
            choppedDimensions.width / 2,
            choppedDimensions.height / 2,
            choppedDimensions.depth / 2
          )
        );
        var choppedMesh = new THREE.Mesh(choppedGeometry, this.material);

        var choppedPosition = {
          x: this.position.x,
          y: this.position.y,
          z: this.position.z,
        };
        if (
          this.position[this.workingPlane] <
          this.targetBlock.position[this.workingPlane]
        ) {
          this.position[this.workingPlane] = this.targetBlock.position[
            this.workingPlane
          ];
        } else {
          choppedPosition[this.workingPlane] += overlap;
        }

        placedMesh.position.set(
          this.position.x,
          this.position.y,
          this.position.z
        );
        choppedMesh.position.set(
          choppedPosition.x,
          choppedPosition.y,
          choppedPosition.z
        );
        blocksToReturn.placed = placedMesh;
        if (!blocksToReturn.bonus) blocksToReturn.chopped = choppedMesh;
      } else {
        this.state = this.STATES.MISSED;
      }
      this.dimension[this.workingDimension] = overlap;
      return blocksToReturn;
    };

    Block.prototype.tick = function () {
      if (this.state == this.STATES.ACTIVE) {
        var value = this.position[this.workingPlane];
        if (value > this.MOVE_AMOUNT || value < -this.MOVE_AMOUNT)
          this.reverseDirection();
        this.position[this.workingPlane] += this.direction;
        this.mesh.position[this.workingPlane] = this.position[this.workingPlane];
      }
    };
    return Block;
  })();

  var Game = (function () {
    function Game() {
      var _this = this;
      this.STATES = {
        LOADING: "loading",
        PLAYING: "playing",
        READY: "ready",
        ENDED: "ended",
        RESETTING: "resetting",
      };
      this.blocks = [];
      this.state = this.STATES.LOADING;
      this.stage = new Stage();
      this.mainContainer = document.getElementById("container");
      this.scoreContainer = document.getElementById("score");
      this.startButton = document.getElementById("start-button");
      this.instructions = document.getElementById("instructions");
      this.scoreContainer.innerHTML = "0";

      this.newBlocks = new THREE.Group();
      this.placedBlocks = new THREE.Group();
      this.choppedBlocks = new THREE.Group();

      this.stage.add(this.newBlocks);
      this.stage.add(this.placedBlocks);
      this.stage.add(this.choppedBlocks);

      this.addBlock();
      this.tick();
      this.updateState(this.STATES.READY);

      var lastActionTime = 0;
      function onActionSafe(e) {
        var now = Date.now();
        if (now - lastActionTime < 70) return;
        lastActionTime = now;
        if (e && e.target && e.target.id === 'audioToggle') return;
        if (e && e.cancelable && e.type !== 'click') e.preventDefault();
        _this.onAction();
      }

      window.addEventListener("pointerdown", onActionSafe, { passive: false });
      window.addEventListener("keydown", function (e) {
        if (e.keyCode == 32 || e.code === 'Space' || e.code === 'ArrowUp' || e.key === 'w' || e.key === 'W') {
          e.preventDefault();
          onActionSafe(e);
        }
      });
    }

    Game.prototype.updateState = function (newState) {
      for (var key in this.STATES)
        this.mainContainer.classList.remove(this.STATES[key]);
      this.mainContainer.classList.add(newState);
      this.state = newState;
    };

    Game.prototype.onAction = function () {
      initAudio();
      switch (this.state) {
        case this.STATES.READY:
          this.startGame();
          break;
        case this.STATES.PLAYING:
          this.placeBlock();
          break;
        case this.STATES.ENDED:
          this.restartGame();
          break;
      }
    };

    Game.prototype.startGame = function () {
      if (this.state != this.STATES.PLAYING) {
        this.scoreContainer.innerHTML = "0";
        this.updateState(this.STATES.PLAYING);
        this.addBlock();
      }
    };

    Game.prototype.restartGame = function () {
      var _this = this;
      this.updateState(this.STATES.RESETTING);
      var oldBlocks = this.placedBlocks.children;
      var removeSpeed = 0.2;
      var delayAmount = 0.02;
      var _loop_1 = function (i) {
        TweenLite.to(oldBlocks[i].scale, removeSpeed, {
          x: 0,
          y: 0,
          z: 0,
          delay: (oldBlocks.length - i) * delayAmount,
          ease: Power1.easeIn,
          onComplete: function () {
            return _this.placedBlocks.remove(oldBlocks[i]);
          },
        });
        TweenLite.to(oldBlocks[i].rotation, removeSpeed, {
          y: 0.5,
          delay: (oldBlocks.length - i) * delayAmount,
          ease: Power1.easeIn,
        });
      };
      for (var i = 0; i < oldBlocks.length; i++) {
        _loop_1(i);
      }
      var cameraMoveSpeed = removeSpeed * 2 + oldBlocks.length * delayAmount;
      this.stage.setCamera(2, cameraMoveSpeed);
      var countdown = { value: this.blocks.length - 1 };
      TweenLite.to(countdown, cameraMoveSpeed, {
        value: 0,
        onUpdate: function () {
          var val = String(Math.round(countdown.value));
          _this.scoreContainer.innerHTML = val;
        },
      });
      this.blocks = this.blocks.slice(0, 1);
      setTimeout(function () {
        _this.startGame();
      }, cameraMoveSpeed * 1000);
    };

    Game.prototype.placeBlock = function () {
      var _this = this;
      var currentBlock = this.blocks[this.blocks.length - 1];
      var newBlocks = currentBlock.place();
      this.newBlocks.remove(currentBlock.mesh);

      if (newBlocks.placed) this.placedBlocks.add(newBlocks.placed);
      if (newBlocks.chopped) {
        this.choppedBlocks.add(newBlocks.chopped);
        var positionParams = {
          y: "-=30",
          ease: Power1.easeIn,
          onComplete: function () {
            return _this.choppedBlocks.remove(newBlocks.chopped);
          },
        };
        var rotateRandomness = 10;
        var rotationParams = {
          delay: 0.05,
          x:
            newBlocks.plane == "z"
              ? Math.random() * rotateRandomness - rotateRandomness / 2
              : 0.1,
          z:
            newBlocks.plane == "x"
              ? Math.random() * rotateRandomness - rotateRandomness / 2
              : 0.1,
          y: Math.random() * 0.1,
        };
        if (
          newBlocks.chopped.position[newBlocks.plane] >
          newBlocks.placed.position[newBlocks.plane]
        ) {
          positionParams[newBlocks.plane] =
            "+=" + 40 * Math.abs(newBlocks.direction);
        } else {
          positionParams[newBlocks.plane] =
            "-=" + 40 * Math.abs(newBlocks.direction);
        }
        TweenLite.to(newBlocks.chopped.position, 1, positionParams);
        TweenLite.to(newBlocks.chopped.rotation, 1, rotationParams);
      }

      if (currentBlock.state !== currentBlock.STATES.MISSED) {
        playPlace(this.blocks.length, newBlocks.bonus);
      }

      this.addBlock();
    };

    Game.prototype.addBlock = function () {
      var lastBlock = this.blocks[this.blocks.length - 1];
      if (lastBlock && lastBlock.state == lastBlock.STATES.MISSED) {
        return this.endGame();
      }
      var sc = String(this.blocks.length - 1);
      this.scoreContainer.innerHTML = sc;

      var newKidOnTheBlock = new Block(lastBlock);
      this.newBlocks.add(newKidOnTheBlock.mesh);
      this.blocks.push(newKidOnTheBlock);
      this.stage.setCamera(this.blocks.length * 2);
      if (this.blocks.length >= 5) this.instructions.classList.add("hide");
    };

    Game.prototype.endGame = function () {
      this.updateState(this.STATES.ENDED);
      playHitMiss();
      var currentScore = Math.max(0, this.blocks.length - 2);
      finalScore.textContent = currentScore;
      if (currentScore > bestScore) {
        bestScore = currentScore;
        hdrBest.textContent = "🏆 " + bestScore;
        try { localStorage.setItem('mithra_tower_best', String(bestScore)); } catch(e) {}
      }
      bestScoreText.textContent = "Rekor Terbaik: " + bestScore;
    };

    Game.prototype.tick = function () {
      var _this = this;
      this.blocks[this.blocks.length - 1].tick();
      this.stage.render();
      requestAnimationFrame(function () {
        _this.tick();
      });
    };
    return Game;
  })();

  // Mulai game ketika THREE & TweenLite siap
  function checkReady() {
    if (window.THREE && window.TweenLite) {
      new Game();
    } else {
      setTimeout(checkReady, 50);
    }
  }
  checkReady();
})();
<\/script>`

export default function towerGame(ev) {
    ev.on({
        name: 'towergame',
        cmd: ['towergame', 'towerblocks', 'tower', 'stackgame', 'susunbalok'],
        tags: 'Game',
        desc: 'Mainkan game 3D Tower Blocks (Stacking Balok) interaktif di WhatsApp',
        run: async (xp, m) => {
            const loadingMsg = await xp.sendThinkingStatus(m.chat, '🏗️', { quoted: m }).catch(() => null)

            const payloadData = {
                response_id: crypto.randomUUID(),
                sections: [
                    {
                        view_model: {
                            primitive: {
                                __typename: 'GenAIaeacdsnwHtmlPrimitive',
                                payload: wrapWithVendors(towerHtml, { three: true, tween: true }),
                                trusted_sources: []
                            },
                            __typename: 'GenAISingleLayoutViewModel'
                        }
                    }
                ]
            }

            const msgContent = {
                messageContextInfo: {
                    deviceListMetadata: {},
                    deviceListMetadataVersion: 2,
                    botMetadata: {
                        messageDisclaimerText: '🏗️ TOWER BLOCKS 3D ARCADE',
                        botResponseId: crypto.randomUUID(),
                        verificationMetadata: AIRichBuilder.generateVerificationMetadata()
                    }
                },
                botForwardedMessage: {
                    message: {
                        richResponseMessage: {
                            messageType: 1,
                            submessages: [{ messageType: 2, messageText: '🏗️ TOWER BLOCKS 3D ARCADE' }],
                            unifiedResponse: {
                                data: Buffer.from(JSON.stringify(payloadData)).toString('base64')
                            },
                            contextInfo: {
                                forwardingScore: 1,
                                isForwarded: true,
                                forwardedAiBotMessageInfo: {
                                    botJid: '867051314767696@bot'
                                },
                                forwardOrigin: 4
                            }
                        }
                    }
                }
            }

            if (loadingMsg?.key) {
                const { editBotMessage } = await import('#system/lib/baileys_features.js')
                await editBotMessage(xp, m.chat, loadingMsg.key, msgContent)
            } else {
                await xp.relayMessage(m.chat, msgContent, {}).catch(() => {})
            }
        }
    })
}