// gun-fight.js — class-based scene, loaded via <script src>
class GunFightScene extends Phaser.Scene {

  preload() {
    var g = this.make.graphics({add: false});
    g.fillStyle(0xffffff); g.fillRect(0,0,8,4);
    g.generateTexture("bul", 8, 4);
    g.fillStyle(0xffffff); g.fillRect(0,0,28,50);
    g.generateTexture("cow", 28, 50);
    g.destroy();
  }

  create() {
    this.p1 = this.add.sprite(100,420,"cow").setTint(0x3388ff);
    this.physics.add.existing(this.p1);
    this.p2 = this.add.sprite(580,420,"cow").setTint(0xff4444);
    this.physics.add.existing(this.p2);

    this.b1 = this.physics.add.group({maxSize:3});
    this.b2 = this.physics.add.group({maxSize:3});

    // callbackScope: this — CRITICAL for class-based scenes
    this.physics.add.overlap(this.b1, this.p2,
      this.onHitP2, null, this);
    this.physics.add.overlap(this.b2, this.p1,
      this.onHitP1, null, this);
  }

  onHitP2(bullet, player) {
    if (!bullet.active || this.gameOver) return;
    bullet.setActive(false).setVisible(false);
    this.s1++; this.syncScore();
  }

  onHitP1(bullet, player) {
    if (!bullet.active || this.gameOver) return;
    bullet.setActive(false).setVisible(false);
    this.s2++; this.syncScore();
  }

  syncScore() {
    if (this.s1 >= 5 || this.s2 >= 5) {
      this.gameOver = true;
    } else {
      // Instant reset — no timers, no clear()
      this.resetPositions();
    }
  }
}

new Phaser.Game({
  type: Phaser.AUTO, width: 680, height: 480,
  scale: { mode: Phaser.Scale.FIT,
           autoCenter: Phaser.Scale.CENTER_BOTH },
  physics: { default: "arcade" },
  scene: GunFightScene
});

// Fire rate throttling — prevents bullet spamming
// Each player tracks their last fire timestamp

// In create():
this.p1LastFired = 0;
this.p2LastFired = 0;
this.fireRate = 350; // ms between shots

// In update():
function tryFire(player, bullets, lastFiredKey, dir) {
  if (time > this[lastFiredKey] + this.fireRate) {
    let b = bullets.get(10, 10, 'bul');
    if (b) {
      b.setActive(true).setVisible(true);
      b.body.enable = true;
      b.setPosition(player.x + dir * 14, player.y);
      b.body.velocity.x = dir * 500;
      this[lastFiredKey] = time;
    }
  }
}

// Usage:
// tryFire(this.p1, this.b1, 'p1LastFired', 1);  // P1 fires right
// tryFire(this.p2, this.b2, 'p2LastFired', -1); // P2 fires left

// Parse URL parameters to determine game mode
// ?mode=ai  → Vs AI (P2 controlled by AI)
// ?mode=bot → Bot Watch (both AI-controlled)
// No param  → PvP (two players, one keyboard)

function getMode() {
  let params = new URLSearchParams(window.location.search);
  let mode = params.get('mode');
  if (mode === 'ai') return 'ai';
  if (mode === 'bot') return 'bot';
  return 'pvp';
}

// In create():
this.mode = getMode();

// Usage in update():
if (this.mode === 'ai') {
  this.updateAI(this.p2, this.b2, -1); // AI controls P2
} else if (this.mode === 'bot') {
  this.updateAI(this.p1, this.b1, 1);  // AI controls P1
  this.updateAI(this.p2, this.b2, -1); // AI controls P2
}

// Parameterized state machine — reused for both P1 and P2
// runStateMachine(sprite, group, state, timer, lastPeekIdx,
//   peekSpots, peekTargetX, bulletsToFire, peekReady,
//   hideX, peekXs, dir) → {state, timer, ...}

// P2 (red, right side) — AI mode + bot mode
var {aiState, aiTimer, lastPeekIdx, peekTargetX,
     bulletsToFire, aiPeekReady} =
  runStateMachine(this.p2, this.b2, ...,
    920, [420, 600, 780], -1);

// P1 (blue, left side) — bot mode only
var {p1aiState, p1aiTimer, ...} =
  runStateMachine(this.p1, this.b1, ...,
    100, [180, 280, 380], 1);

// Hide → Peek transition
case 'hide':
  moveTowardXY(sprite, hideX, 600 + rand*60);
  timer += 100;
  if (timer > 600 + rand*800) {
    // Pick next peek spot — never repeat
    do { idx = floor(rand*3); } while (idx === lastPeekIdx);
    state = 'peek';
    bulletsToFire = 1 + floor(rand*3);
  }

// Static group for 3 cover crates — generates 'crate' texture
this.crates = this.physics.add.staticGroup();
[200, 510, 880].forEach(function(x, i) {
  var y = [180, 645, 400][i];
  var c = this.crates.create(x, y, 'crate');
  c.setTint(0x5c4a3a); c.refreshBody();
}, this);

// Bullets absorbed by crates — overlap, not collider
this.physics.add.overlap(this.b1, this.crates,
  this.onBulletCrate, null, this);
this.physics.add.overlap(this.b2, this.crates,
  this.onBulletCrate, null, this);

// Player movement blocked — full collider
this.physics.add.collider(this.p1, this.crates);
this.physics.add.collider(this.p2, this.crates);

// Bullet-crate hit: destroy bullet, flash crate brown
onBulletCrate(bullet, crate) {
  bullet.setActive(false).setVisible(false);
  if (bullet.body) bullet.body.enable = false;
  crate.setTint(0x8b7355);  // lighter = hit feedback
  this.time.delayedCall(60, () => {
    if (crate.active) crate.setTint(0x5c4a3a);
  });
}

// Mode detection from URL parameters
var params = new URLSearchParams(window.location.search);
var mode = params.get('mode');
if (mode === 'ai') this.mode = 'ai';
else if (mode === 'bot') this.mode = 'bot';
else this.mode = 'pvp';

// ?mode=ai — P2 runs state machine, P1 is human
if (this.mode === 'ai') {
  this.aiState = 'hide';
  this.aiTimer = 0;
  this.time.addEvent({ delay: 100, loop: true,
    callback: this.aiTick, callbackScope: this });
}

// ?mode=bot — both players run mirrored state machines
if (this.mode === 'bot') {
  this.aiState = 'hide';
  this.aiTimer = 0;
  this.p1aiState = 'hide';
  this.p1aiTimer = 0;
  this.p1lastPeekIdx = -1;
  this.p1peekSpots = [250, 380, 600];
  this.p1bulletsToFire = 0;
  this.p1peekTargetX = 380;
  this.p1aiPeekReady = 0;
  this.time.addEvent({ delay: 100, loop: true,
    callback: this.aiTick, callbackScope: this });
}

function damageCrate(crate) {
  let hp = crate.getData('hp') - 1;
  crate.setData('hp', hp);
  if (hp > 0) {
    crate.setTint(hp === 2 ? 0xcc8844 : 0xcc3333);
  } else {
    crate.body.enable = false;
    crate.setAlpha(0.3).setTint(0x666666);
    for (let i = 0; i < 12; i++) {
      let p = this.add.rectangle(
        crate.x, crate.y, 6, 6, 0x8b7355);
      this.tweens.add({
        targets: p, alpha: 0,
        y: p.y - 100 - Math.random()*100,
        duration: 1500,
        onComplete: () => p.destroy()
      });
    }
    this.cameras.main.shake(150, 0.006);
  }
}

// HP-based tint + physics disable on destruction
function applyCrateVisual(crate) {
  let hp = crate.getData('hp');
  if (hp === 3) {
    crate.setTint(0x8B6914);   // brown = full
  } else if (hp === 2) {
    crate.setTint(0xDAA520);   // gold = cracked
  } else if (hp === 1) {
    crate.setTint(0xCC3333);   // red = destroyed soon
  } else {
    crate.body.enable = false;  // physics off
    crate.setAlpha(0.2);       // ghost remnant
  }
}

function spawnDebris(scene, x, y) {
  for (let i = 0; i < 12; i++) {
    let p = scene.add.rectangle(
      x + (Math.random() - 0.5) * 40,
      y + (Math.random() - 0.5) * 40,
      6 + Math.random() * 4,       // random width
      4 + Math.random() * 6,       // random height
      0x8B7355                     // wood color
    );
    scene.tweens.add({
      targets: p,
      x: p.x + (Math.random() - 0.5) * 160,   // spread
      y: p.y - 120 - Math.random() * 80,       // upward arc
      angle: Math.random() * 360,               // tumble
      alpha: 0,
      duration: 1200 + Math.random() * 600,
      ease: 'Quad.easeOut',
      onComplete: () => p.destroy()
    });
  }
}

var SoundManager = {
  ctx: null,
  ensureResumed() {
    if (!this.ctx) {
      this.ctx = new (window.AudioContext
        || window.webkitAudioContext)();
    }
    if (this.ctx.state === 'suspended')
      this.ctx.resume();
  },
  playGunshot() {
    this.ensureResumed();
    var osc = this.ctx.createOscillator();
    var gain = this.ctx.createGain();
    osc.type = 'sawtooth';
    osc.frequency.value = 800;
    gain.gain.setValueAtTime(0.3,
      this.ctx.currentTime);
    gain.gain.exponentialRampToValueAtTime(0.001,
      this.ctx.currentTime + 0.02);
    osc.connect(gain)
      .connect(this.ctx.destination);
    osc.start();
    osc.stop(this.ctx.currentTime + 0.02);
  }
};

// Per-player health bars drawn with Phaser.Graphics
// Each player has 5 HP, bar width = HP * 20 (100px max)

function createHealthBars(scene) {
  // Background bars (dark outline)
  scene.p1BarBg = scene.add.rectangle(20, 20, 104, 14, 0x333333);
  scene.p2BarBg = scene.add.rectangle(900, 20, 104, 14, 0x333333);
  scene.p1BarBg.setOrigin(0, 0);
  scene.p2BarBg.setOrigin(0, 0);

  // Fill bars (colored)
  scene.p1Bar = scene.add.rectangle(22, 22, 100, 10, 0x33aa33);
  scene.p2Bar = scene.add.rectangle(902, 22, 100, 10, 0xaa3333);
  scene.p1Bar.setOrigin(0, 0);
  scene.p2Bar.setOrigin(0, 0);
}

// HP to bar width mapping: hp * 20 pixels
function updateHealthBar(scene, bar, hp) {
  bar.setSize(Math.max(0, hp * 20), 10);
  // Color shifts: green > yellow > red as HP drops
  if (hp > 3) bar.setFillStyle(0x33cc33);
  else if (hp > 1) bar.setFillStyle(0xcccc33);
  else bar.setFillStyle(0xcc3333);
}

// Called every frame after HP change
updateHealthBar(this, this.p1Bar, this.p1hp);
updateHealthBar(this, this.p2Bar, this.p2hp);

// Full hit feedback chain triggered on bullet impact
function onBulletHitPlayer(scene, target, attacker) {
  if (target.getData('invulnerable')) return;

  // 1. White flash overlay on entire screen
  let flash = scene.add.rectangle(0, 0, 1020, 720, 0xffffff, 0.3);
  flash.setOrigin(0, 0).setDepth(100);
  scene.time.delayedCall(60, () => flash.destroy());

  // 2. Camera shake — 120ms at 0.008 intensity
  scene.cameras.main.shake(120, 0.008);

  // 3. Hit particles burst — 8 red rectangles fly outward
  for (let i = 0; i < 8; i++) {
    let p = scene.add.rectangle(
      target.x, target.y, 4, 4, 0xff4444);
    scene.tweens.add({
      targets: p,
      x: p.x + (Math.random() - 0.5) * 120,
      y: p.y - 40 - Math.random() * 60,
      alpha: 0, angle: Math.random() * 360,
      duration: 400 + Math.random() * 200,
      onComplete: () => p.destroy()
    });
  }

  // 4. Score yoyo — scale up 1.5x then back
  let txt = (attacker === scene.p1)
    ? scene.score1 : scene.score2;
  scene.tweens.add({
    targets: txt,
    scaleX: 1.5, scaleY: 1.5, duration: 100,
    yoyo: true, ease: 'Quad.easeOut'
  });
}

// MainMenuScene — title screen with mode selection
class MainMenuScene extends Phaser.Scene {
  create() {
    this.add.text(510, 100, 'GUN FIGHT', {
      fontSize: '64px', color: '#ff6b35',
      fontFamily: 'monospace', fontStyle: 'bold'
    }).setOrigin(0.5);
    // Starfield particles, cowboy silhouettes
    // Mode buttons: PvP, Vs AI, Bot Watch
    // ENTER or click to start
    this.input.keyboard.on('keydown-ENTER',
      () => this.startGame('pvp'));
  }
  startGame(mode) {
    this.scene.start('GunFightScene', { mode });
  }
}

// GunFightScene receives mode via scene data
class GunFightScene extends Phaser.Scene {
  init(data) {
    this.mode = data.mode || 'pvp';
  }
}

// Power-up type variants with visual + effect
const POWERUP_TYPES = [
  { type: 'health', color: 0x44ff44, label: '+HP' },
  { type: 'rapid',  color: 0xffaa00, label: 'RF'  },
  { type: 'shield', color: 0x44aaff, label: 'SH'  }
];

// Spawn timer — every 8-12 seconds at random open pos
this.time.addEvent({
  delay: 8000 + Math.random() * 4000,
  loop: true,
  callback: () => {
    let pos = this.findOpenPosition();
    let t = POWERUP_TYPES[Phaser.Math.Between(0, 2)];
    let pu = this.add.circle(pos.x, pos.y, 12, t.color);
    this.physics.add.existing(pu);
    pu.powerType = t.type;
    this.time.delayedCall(6000, () => {
      if (pu.active) pu.destroy();
    });
  }
});

// Overlap — player collects power-up
this.physics.add.overlap(this.p1, this.powerUps,
  (player, pu) => {
    pu.destroy();
    switch (pu.powerType) {
      case 'health':
        player.hp = Math.min(player.hp + 3, 5);
        break;
      case 'rapid':
        player.fireRate = 150;
        player.rapidTimer = 5000;
        break;
      case 'shield':
        player.shield = true;
        player.shieldTimer = 5000;
        break;
    }
  }, null, this);

// In update(): countdown rapid fire & shield timers
if (player.rapidTimer > 0) {
  player.rapidTimer -= delta;
  if (player.rapidTimer <= 0)
    player.fireRate = 350; // restore default
}
if (player.shieldTimer > 0) {
  player.shieldTimer -= delta;
  if (player.shieldTimer <= 0) player.shield = false;
}

// Parallax background — drawn once in create()
// Each layer scrolls at a different speed
function drawParallax(scene) {
  var g = scene.add.graphics();

  // Layer 1: Sky gradient (static — no scroll)
  g.fillGradientStyle(
    0x1a0a2e, 0x1a0a2e, 0x4a2080, 0x4a2080, 1);
  g.fillRect(0, 0, 1020, 720);

  // Layer 2: Mountains (scroll factor 0.2x)
  g.fillStyle(0x2a1545, 0.8);
  for (var x = -100; x < 1120; x += 200) {
    g.fillTriangle(
      x - 80, 500, x + 80, 500, x, 320);
  }

  // Layer 3: Cacti silhouettes (scroll factor 0.5x)
  g.fillStyle(0x1a3020, 0.9);
  [150, 380, 620, 850].forEach(cx => {
    g.fillRect(cx - 3, 600, 6, -60);   // trunk
    g.fillRect(cx - 15, 555, 12, 6);   // left arm
    g.fillRect(cx + 3, 565, 12, 6);    // right arm
  });

  // Layer 4: Ground (scroll factor 1.0x)
  g.fillStyle(0x3a2510, 1);
  g.fillRect(0, 650, 1020, 70);
  g.fillStyle(0x5a3a1a, 0.6);
  g.fillRect(0, 650, 1020, 3);
}

// In update(): scroll offset from camera midpoint
var cx = (this.p1.x + this.p2.x) / 2;
var scrollX = Phaser.Math.Clamp(cx - 510, 0, 200);
this.bgLayers.forEach((layer, i) => {
  layer.x = -scrollX * [0, 0.2, 0.5, 1.0][i];
});