// ==================== ЦИКЛ ИГРЫ 3D — GrechkaCraft v3 ====================
// Всё как в 2D-игре, но движение по трём осям: X (вперёд-назад по миру),
// Y (вверх-вниз), Z (вбок). WASD работают относительно взгляда камеры.
import { state } from '../core/state.js';
import { BLOCKS } from '../data/blocks.js';
import { playSound } from '../audio/sound-engine.js';
import { getBlock } from '../world/world-storage3d.js';
import { updateWaterFlag3 } from '../physics/water-detect3d.js';
import { resolveY, resolveX, resolveZ, onLadder } from '../physics/collision3d.js';
import { calculateDamage } from '../entities/player.js';
import { tickFurnaces } from '../ui/furnace.js';
import { renderFurnaceUI } from '../ui/furnace.js';
import { updateWeather, updateRain } from '../world/weather.js';
import { ensureGenAroundCamera, surfaceGyAt, getCachedBiome, WORLD_DEPTH } from '../world/generation3d.js';
import { Zombie, Creeper, Skeleton, Pig, Chicken, Scorpion, PolarBear, Slime, Eagle } from '../entities/mobs3d.js';
import { isNight, mobAI } from '../entities/mob-ai3d.js';
import { sendPlayerPosition } from '../multiplayer/socket-helpers.js';
import { renderFrame3D } from '../render/render3d.js';
import { explodeTNT3D } from '../world/tnt3d.js';

let last = performance.now();
let prevJump = false;

document.addEventListener('visibilitychange', () => {
  if (!document.hidden) last = performance.now();
});

// Направление взгляда камеры (задаётся рендером) — WASD относительно него
export const camDir = { yaw: 0, pitch: 0 };

export function loop(now) {
  const rawDt = Math.min(0.05, (now - last) / 1000);
  last = now;
  const PHYSICS_STEP = 0.016;
  const steps = Math.max(1, Math.ceil(rawDt / PHYSICS_STEP));
  const dt = rawDt / steps;

  const player = state.player;
  const inp = state.inp;
  const mobs = state.mobs;
  const projectiles = state.projectiles;
  const boat = state.boat;

  const jumpPressed = inp.j && !prevJump;
  prevJump = inp.j;

  // ---------- день/ночь ----------
  if (!state.dayNightCycle) {
    // время стоит
  } else if (player.sleeping && isNight()) {
    state.worldTime += dt * 8 / state.DAY_LEN;
    player.hp = Math.min(100, player.hp + dt * 20);
    if (!isNight()) player.sleeping = false;
  } else {
    state.worldTime += dt / state.DAY_LEN;
  }
  if (state.worldTime >= 1) state.worldTime -= 1;

  // ---------- генерация мира ----------
  ensureGenAroundCamera();

  // ---------- кислород/утопление ----------
  if (player.headInWater) {
    player.o2 = Math.max(0, player.o2 - 6 * dt);
    if (player.o2 === 0) player.hp -= calculateDamage(4 * dt);
  } else {
    player.o2 = Math.min(100, player.o2 + 10 * dt);
  }

  player.hunger = Math.max(0, player.hunger - dt * 0.2);

  // ---------- температура по биому (теперь биом 2D) ----------
  if (player.temperature === undefined) player.temperature = 15;
  const BIOME_TEMP = { snow: -20, plains: 15, swamp: 20, desert: 45, mountains: 5 };
  const COLD_THRESHOLD = -5;
  const HEAT_THRESHOLD = 35;
  const pGX = Math.floor((player.x + player.w / 2) / state.TILE);
  const pGZ = Math.floor((player.z + player.d / 2) / state.TILE);
  const pGY = Math.floor((player.y + player.h / 2) / state.TILE);
  const biome = getCachedBiome(pGX, pGZ);
  const sGY = surfaceGyAt(pGX, pGZ);
  const isUnderground = (pGY - sGY) > 2;
  let targetTemp = BIOME_TEMP[biome] || 15;
  if (isUnderground) targetTemp = 15;
  if (isNight() && !isUnderground) targetTemp -= 10;
  if ((state.weatherType === 'rain' || state.weatherType === 'storm') && !isUnderground) targetTemp -= 5;
  player.temperature += (targetTemp - player.temperature) * dt * 0.3;

  // костры/факелы греют, вода в пустыне холодит — ищем в кубе вокруг
  let nearHeat = false, nearCool = false;
  for (let dx = -2; dx <= 2 && !nearHeat; dx++) {
    for (let dy = -2; dy <= 2 && !nearHeat; dy++) {
      for (let dz = -2; dz <= 2 && !nearHeat; dz++) {
        const b = getBlock(pGX + dx, pGY + dy, pGZ + dz);
        if (b && (b.t === 'campfire' || b.t === 'torch' || b.t === 'furnace')) nearHeat = true;
      }
    }
  }
  if (!nearHeat && biome === 'desert') {
    for (let dx = -2; dx <= 2 && !nearCool; dx++) {
      for (let dz = -2; dz <= 2 && !nearCool; dz++) {
        const b = getBlock(pGX + dx, pGY, pGZ + dz);
        if (b && b.t === 'water') nearCool = true;
      }
    }
  }
  if (nearHeat) {
    player.temperature += (30 - player.temperature) * dt * 2;
    if (player.hp < 100) player.hp = Math.min(100, player.hp + 8 * dt);
  }
  if (nearCool) {
    player.temperature += (15 - player.temperature) * dt * 1.5;
    if (player.hp < 100 && player.temperature > HEAT_THRESHOLD) player.hp = Math.min(100, player.hp + 8 * dt);
  }
  if (isUnderground && !nearHeat && player.hp < 100 &&
      player.temperature >= COLD_THRESHOLD && player.temperature <= HEAT_THRESHOLD) {
    player.hp = Math.min(100, player.hp + 2 * dt);
  }
  const aboveBlk = getBlock(pGX, pGY + 1, pGZ);
  if (aboveBlk && BLOCKS[aboveBlk.t] && BLOCKS[aboveBlk.t].solid && aboveBlk.t !== 'glass' && !isUnderground && !nearCool) {
    player.temperature -= 5 * dt;
  }
  if (player.temperature < COLD_THRESHOLD) {
    player.hp -= 1 * dt;
    player.hunger -= 0.5 * dt;
  }
  if (player.slowTimer > 0) player.slowTimer -= dt;

  // ---------- кактус: урон в кубе ----------
  for (let dx = -1; dx <= 1; dx++) {
    for (let dy = -1; dy <= 1; dy++) {
      for (let dz = -1; dz <= 1; dz++) {
        const cb = getBlock(pGX + dx, pGY + dy, pGZ + dz);
        if (cb && BLOCKS[cb.t] && BLOCKS[cb.t].hurt && player.invuln <= 0) {
          player.hp -= 2;
          player.invuln = 0.5;
        }
      }
    }
  }

  // ---------- лёд: скольжение ----------
  const underBlk = getBlock(pGX, pGY - 1, pGZ);
  if (underBlk && BLOCKS[underBlk.t] && BLOCKS[underBlk.t].slip && player.grounded) {
    player.vx *= 0.98;
    player.vz *= 0.98;
  }

  // ---------- ДВИЖЕНИЕ: WASD относительно камеры ----------
  if (player.sleeping) {
    player.vx = player.vy = player.vz = 0;
  } else {
    // локальные оси ввода
    let fwd = 0, side = 0;
    if (inp.up) fwd -= 1;
    if (inp.r || inp.right) side += 1;
    if (inp.l || inp.left) side -= 1;
    if (inp.d || inp.back) fwd += 1;

    // в мировых осях через угол камеры
    const cy = Math.cos(camDir.yaw), sy = Math.sin(camDir.yaw);
    let dx = side * cy - fwd * sy;
    let dz = side * sy + fwd * cy;
    const len = Math.hypot(dx, dz);
    if (len > 0.0001) {
      dx /= len; dz /= len;
      player.vx = dx * state.MOVE;
      player.vz = dz * state.MOVE;
      player.facing = Math.atan2(dz, dx);
    } else {
      player.vx *= 0.82;
      player.vz *= 0.82;
    }
  }

  // шаги
  if (player.grounded && !player.inWater && Math.hypot(player.vx, player.vz) > 50) {
    if (now / 1000 - player.lastStepTime > 0.35) {
      playSound('step');
      player.lastStepTime = now / 1000;
    }
  }

  // ---------- прыжок / плавание / лодка ----------
  if (player.inBoat) {
    player.vy = 0;
    player.x = boat.x + 2;
    player.y = boat.y - 4;
    player.z = boat.z + 2;
    player.grounded = true;
    player.inWater = false;
    if (jumpPressed) {
      state.inv.boat = (state.inv.boat || 0) + 1;
      player.inBoat = false;
      boat.active = false;
      player.y += state.TILE;
      player.vy = -state.JUMP * 0.5;
      playSound('splash');
    }
  } else if (player.inWater) {
    player.vx *= 0.90;
    player.vz *= 0.90;
    player.vy *= 0.92;
    if (!jumpPressed && !inp.j) {
      player.vy += state.GRAV_WATER * dt;
    } else if (jumpPressed) {
      player.vy = Math.min(player.vy, -520);
    } else if (inp.j) {
      player.vy = Math.min(player.vy, -260);
    }
  } else {
    if (jumpPressed && player.grounded && !player.sleeping) {
      player.vy = -state.JUMP;
      player.grounded = false;
      player.fallStartY = player.y;
    }
  }

  if (!player.inWater && !player.inBoat) {
    player.vy += state.GRAV * dt;
  }

  // ---------- лодка: плывёт, тонет вне воды ----------
  if (boat.active) {
    boat.x += boat.vx * dt;
    boat.y += boat.vy * dt;
    boat.z += (boat.vz || 0) * dt;
    const boatGX = Math.floor(boat.x / state.TILE);
    const boatGY = Math.floor(boat.y / state.TILE);
    const boatGZ = Math.floor(boat.z / state.TILE);
    const below = getBlock(boatGX, boatGY + 1, boatGZ);
    if (!below || (below.t !== 'water' && below.t !== 'swamp_water')) {
      state.inv.boat = (state.inv.boat || 0) + 1;
      player.inBoat = false;
      boat.active = false;
      player.y += state.TILE;
      player.vy = -200;
      playSound('splash');
    }
  }

  if (player.inBoat && !boat.active) {
    state.inv.boat = (state.inv.boat || 0) + 1;
    player.inBoat = false;
    player.y += state.TILE;
    player.vy = -200;
    playSound('splash');
  }

  // ---------- границы мира по Z ----------
  const maxZ = WORLD_DEPTH * state.TILE;
  if (player.z < -maxZ) { player.z = -maxZ; player.vz = 0; }
  if (player.z > maxZ) { player.z = maxZ; player.vz = 0; }

  // ---------- ФИЗИКА: X → Z → Y ----------
  const sub = dt;
  for (let step = 0; step < steps; step++) {
    player.x += player.vx * sub;
    player.z += player.vz * sub;
    player.y += player.vy * sub;
    resolveX(player, sub);
    resolveZ(player, sub);
    resolveY(player, sub);
  }

  // лестница: вертикальное перемещение
  if (onLadder(player)) {
    if (inp.j) player.vy = -200;
    else if (inp.s || inp.down) player.vy = 100;
    else player.vy = 0;
  }

  // урон от падения: дистанция от последнего касания земли
  if (player.grounded) {
    if (player.fallStartY !== undefined) {
      const fallDist = player.fallStartY - player.y;
      if (fallDist > state.TILE * 6) {
        player.hp -= calculateDamage((fallDist / state.TILE - 6) * 2.5);
      }
    }
    player.fallStartY = player.y;
  } else if (player.vy > 0 && player.fallStartY === undefined) {
    player.fallStartY = player.y;
  }

  // вода
  updateWaterFlag3(player, dt);

  sendPlayerPosition();
  updateWeather(dt);
  updateRain(dt);
  player.invuln = Math.max(0, player.invuln - dt);

  // ---------- мобы ----------
  state.spawnT += dt;
  if (state.spawnT > 6) {
    state.spawnT = 0;
    spawnMobs3D();
  }
  for (const m of mobs) {
    mobAI(m, dt);   // физика 3D внутри mob-ai3d
  }
  // снаряды
  for (let i = projectiles.length - 1; i >= 0; i--) {
    const pr = projectiles[i];
    pr.x += pr.vx * dt;
    pr.y += pr.vy * dt;
    pr.life -= dt;
    // столкновение с блоком (по Z игрока/снаряда)
    const gx = Math.floor(pr.x / state.TILE);
    const gy = Math.floor(pr.y / state.TILE);
    const gz = Math.floor((pr.z || player.z) / state.TILE);
    const b = getBlock(gx, gy, gz);
    if (b && BLOCKS[b.t] && BLOCKS[b.t].solid) {
      projectiles.splice(i, 1);
      continue;
    }
    if (pr.life <= 0) projectiles.splice(i, 1);
  }

  // ---------- TNT ----------
  for (const b of state.blocks) {
    if (b.dead || b.t !== 'tnt' || !b.active) continue;
    b.fuse -= dt;
    if (b.fuse <= 0) {
      explodeTNT3D(b, state);
    }
  }

  // ---------- печь ----------
  tickFurnaces(dt);
  if (state.currentFurnaceKey && Math.random() < 0.1) renderFurnaceUI();

  // ---------- смерть/возрождение ----------
  if (player.hp <= 0 && state.deathEl && state.deathEl.style.display !== 'flex') {
    player.hp = 0;
    state.deathEl.style.display = 'flex';
  } else if (player.hp > 0 && state.deathEl && state.deathEl.style.display === 'flex') {
    state.deathEl.style.display = 'none';
  }

  // ---------- HUD ----------
  if (Math.random() < 0.25) {
    state.hpEl.textContent = Math.max(0, Math.ceil(player.hp));
    state.foodEl.textContent = Math.ceil(player.hunger);
    const o2El = document.getElementById('o2');
    if (o2El) o2El.textContent = Math.ceil(player.o2);
    const tempEl = document.getElementById('temp');
    if (tempEl) {
      const t = Math.round(player.temperature);
      tempEl.textContent = t + '°C';
      if (player.temperature < COLD_THRESHOLD) tempEl.style.color = '#74b9ff';
      else if (player.temperature > HEAT_THRESHOLD) tempEl.style.color = '#e17055';
      else tempEl.style.color = '#55efc4';
    }
    state.sxEl.textContent = pGX;
    state.syEl.textContent = pGY;
    state.todEl.textContent = isNight() ? 'Ночь' : 'День';
    state.worldIdEl.textContent = state.worldId;
    if (state.isMultiplayer) {
      const st = document.getElementById('multiplayerStatus');
      if (st) st.style.display = 'flex';
      state.playerCountEl.textContent = state.otherPlayers.size + 1;
    } else {
      const st = document.getElementById('multiplayerStatus');
      if (st) st.style.display = 'none';
    }
  }

  // сон — DOM-оверлей
  const sleepOv = document.getElementById('sleepOverlay');
  if (sleepOv) sleepOv.style.display = player.sleeping ? 'flex' : 'none';

  // ---------- РЕНДЕР ----------
  renderFrame3D(now);

  requestAnimationFrame(loop);
}

// ---------- спавн мобов в 3D ----------
function spawnMobs3D() {
  const p = state.player;
  const pcx = p.x / state.TILE;
  const pcy = p.y / state.TILE;
  const pcz = (p.z || 0) / state.TILE;
  const kinds = [Zombie, Pig, Chicken, Creeper, Skeleton, Scorpion, PolarBear, Slime, Eagle];
  for (let i = 0; i < 2; i++) {
    const ang = Math.random() * Math.PI * 2;
    const dist = 14 + Math.random() * 12;
    const mx = Math.floor(pcx + Math.cos(ang) * dist);
    const mz = Math.floor(pcz + Math.sin(ang) * dist);
    if (Math.abs(mz) > WORLD_DEPTH) continue;
    const sy = surfaceGyAt(mx, mz) - 1;
    if (sy < 1) continue;
    const K = kinds[Math.floor(Math.random() * kinds.length)];
    const m = new K(mx * state.TILE, sy * state.TILE, mz * state.TILE);
    m.z = mz * state.TILE;
    m.d = m.d || m.w;
    m.vz = 0;
    state.mobs.push(m);
  }
}