// assets/js/game2048.test.mjs
import assert from "node:assert";
import { test } from "node:test";
import {
  createEmptyGrid, addRandomTile, move, isGameOver
} from "./game2048.js";

test("createEmptyGrid: 4x4 모두 0", () => {
  const grid = createEmptyGrid();
  assert.strictEqual(grid.length, 4);
  grid.forEach(row => {
    assert.strictEqual(row.length, 4);
    row.forEach(cell => assert.strictEqual(cell, 0));
  });
});

test("addRandomTile: 빈 칸 하나에만 2 또는 4가 채워진다", () => {
  const grid = createEmptyGrid();
  const next = addRandomTile(grid);
  const nonZero = next.flat().filter(v => v !== 0);
  assert.strictEqual(nonZero.length, 1);
  assert.ok(nonZero[0] === 2 || nonZero[0] === 4);
});

test("addRandomTile: 빈 칸이 없으면 그대로 반환", () => {
  const full = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]];
  const next = addRandomTile(full);
  assert.deepStrictEqual(next, full);
});

test("move left: 같은 값 두 개가 만나면 병합되고 점수가 오른다", () => {
  const grid = [
    [2, 2, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "left");
  assert.deepStrictEqual(result.grid[0], [4, 0, 0, 0]);
  assert.strictEqual(result.moved, true);
  assert.strictEqual(result.scoreGained, 4);
});

test("move left: 세 개 연속은 앞쪽 두 개만 병합된다 (2 2 2 0 -> 4 2 0 0)", () => {
  const grid = [
    [2, 2, 2, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "left");
  assert.deepStrictEqual(result.grid[0], [4, 2, 0, 0]);
});

test("move right: 오른쪽 정렬 및 병합", () => {
  const grid = [
    [0, 0, 2, 2],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "right");
  assert.deepStrictEqual(result.grid[0], [0, 0, 0, 4]);
});

test("move up: 위쪽 정렬 및 병합", () => {
  const grid = [
    [2, 0, 0, 0],
    [2, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "up");
  assert.strictEqual(result.grid[0][0], 4);
  assert.strictEqual(result.grid[1][0], 0);
});

test("move down: 아래쪽 정렬 및 병합", () => {
  const grid = [
    [2, 0, 0, 0],
    [2, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "down");
  assert.strictEqual(result.grid[3][0], 4);
  assert.strictEqual(result.grid[2][0], 0);
});

test("move: 변화가 없으면 moved=false", () => {
  const grid = [
    [2, 4, 8, 16],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  const result = move(grid, "left");
  assert.strictEqual(result.moved, false);
  assert.strictEqual(result.scoreGained, 0);
});

test("isGameOver: 빈 칸이 있으면 false", () => {
  const grid = [
    [2, 4, 8, 16],
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
  ];
  assert.strictEqual(isGameOver(grid), false);
});

test("isGameOver: 꽉 찼지만 인접 병합 가능하면 false", () => {
  const grid = [
    [2, 4, 2, 4],
    [4, 2, 4, 2],
    [2, 4, 2, 4],
    [4, 2, 4, 4]
  ];
  assert.strictEqual(isGameOver(grid), false);
});

test("isGameOver: 꽉 차고 병합 불가능하면 true", () => {
  const grid = [
    [2, 4, 2, 4],
    [4, 2, 4, 2],
    [2, 4, 2, 4],
    [4, 2, 4, 2]
  ];
  assert.strictEqual(isGameOver(grid), true);
});

// assets/js/game2048.js
const SIZE = 4;

export function createEmptyGrid() {
  return Array.from({ length: SIZE }, () => Array(SIZE).fill(0));
}

export function addRandomTile(grid) {
  const empties = [];
  grid.forEach((row, r) => row.forEach((v, c) => { if (v === 0) empties.push([r, c]); }));
  if (empties.length === 0) return grid;

  const next = grid.map(row => [...row]);
  const [r, c] = empties[Math.floor(Math.random() * empties.length)];
  next[r][c] = Math.random() < 0.9 ? 2 : 4;
  return next;
}

function slideAndMergeRow(row) {
  const compact = row.filter(v => v !== 0);
  let scoreGained = 0;
  const merged = [];

  for (let i = 0; i < compact.length; i++) {
    if (compact[i] === compact[i + 1]) {
      const value = compact[i] * 2;
      merged.push(value);
      scoreGained += value;
      i++;
    } else {
      merged.push(compact[i]);
    }
  }

  while (merged.length < SIZE) merged.push(0);
  return { row: merged, scoreGained };
}

export function moveLeft(grid) {
  let scoreGained = 0;
  const newGrid = grid.map(row => {
    const { row: newRow, scoreGained: gained } = slideAndMergeRow(row);
    scoreGained += gained;
    return newRow;
  });
  const moved = JSON.stringify(newGrid) !== JSON.stringify(grid);
  return { grid: newGrid, moved, scoreGained };
}

function rotateClockwise(grid) {
  return grid[0].map((_, c) => grid.map(row => row[c]).reverse());
}

function rotateCounterClockwise(grid) {
  return grid[0].map((_, c) => grid.map(row => row[row.length - 1 - c]));
}

export function move(grid, direction) {
  if (direction === "left") return moveLeft(grid);

  if (direction === "right") {
    const rotated = grid.map(row => [...row].reverse());
    const result = moveLeft(rotated);
    return { ...result, grid: result.grid.map(row => [...row].reverse()) };
  }

  if (direction === "up") {
    const rotated = rotateCounterClockwise(grid);
    const result = moveLeft(rotated);
    return { ...result, grid: rotateClockwise(result.grid) };
  }

  if (direction === "down") {
    const rotated = rotateClockwise(grid);
    const result = moveLeft(rotated);
    return { ...result, grid: rotateCounterClockwise(result.grid) };
  }

  throw new Error(`Unknown direction: ${direction}`);
}

export function isGameOver(grid) {
  const hasEmpty = grid.some(row => row.some(v => v === 0));
  if (hasEmpty) return false;

  for (let r = 0; r < SIZE; r++) {
    for (let c = 0; c < SIZE; c++) {
      const v = grid[r][c];
      if (c < SIZE - 1 && grid[r][c + 1] === v) return false;
      if (r < SIZE - 1 && grid[r + 1][c] === v) return false;
    }
  }
  return true;
}

import { db } from "./firebase-init.js";
import { requireApproved } from "./auth-guard.js";
import { createEmptyGrid, addRandomTile, move, isGameOver } from "./game2048.js";
import {
  doc, getDoc, setDoc, collection, getDocs, serverTimestamp
} from "https://www.gstatic.com/firebasejs/10.12.2/firebase-firestore.js";

let grid = createEmptyGrid();
let score = 0;
let gameOver = false;
let currentUser = null;
let currentUserData = null;

requireApproved((user, userData) => {
  currentUser = user;
  currentUserData = userData;
  startNewGame();
  loadLeaderboard();
});

function startNewGame() {
  grid = addRandomTile(addRandomTile(createEmptyGrid()));
  score = 0;
  gameOver = false;
  document.getElementById("game-over-msg").style.display = "none";
  render();
}

function render() {
  const gridEl = document.getElementById("game-grid");
  gridEl.innerHTML = "";
  grid.flat().forEach(value => {
    const tile = document.createElement("div");
    tile.className = "game-tile";
    tile.dataset.value = String(value);
    tile.textContent = value === 0 ? "" : String(value);
    gridEl.appendChild(tile);
  });
  document.getElementById("game-score").textContent = String(score);
}

function handleMove(direction) {
  if (gameOver) return;
  const result = move(grid, direction);
  if (!result.moved) return;

  grid = addRandomTile(result.grid);
  score += result.scoreGained;
  render();

  if (isGameOver(grid)) {
    gameOver = true;
    document.getElementById("game-over-msg").style.display = "block";
    submitScore(currentUser.uid, currentUserData.nickname, score)
      .then(loadLeaderboard);
  }
}

document.addEventListener("keydown", (e) => {
  const map = {
    ArrowLeft: "left", ArrowRight: "right", ArrowUp: "up", ArrowDown: "down"
  };
  if (map[e.key]) {
    e.preventDefault();
    handleMove(map[e.key]);
  }
});

let touchStartX = 0;
let touchStartY = 0;
document.getElementById("game-grid").addEventListener("touchstart", (e) => {
  touchStartX = e.touches[0].clientX;
  touchStartY = e.touches[0].clientY;
}, { passive: true });

document.getElementById("game-grid").addEventListener("touchend", (e) => {
  const dx = e.changedTouches[0].clientX - touchStartX;
  const dy = e.changedTouches[0].clientY - touchStartY;
  if (Math.abs(dx) < 20 && Math.abs(dy) < 20) return;

  if (Math.abs(dx) > Math.abs(dy)) {
    handleMove(dx > 0 ? "right" : "left");
  } else {
    handleMove(dy > 0 ? "down" : "up");
  }
});

document.getElementById("btn-restart").addEventListener("click", startNewGame);
document.getElementById("btn-restart-top").addEventListener("click", startNewGame);

async function submitScore(uid, nickname, finalScore) {
  const ref = doc(db, "game_scores", uid);
  const snap = await getDoc(ref);
  const currentBest = snap.exists() ? (snap.data().bestScore || 0) : 0;
  if (finalScore <= currentBest) return;

  await setDoc(ref, {
    nickname,
    bestScore: finalScore,
    updatedAt: serverTimestamp()
  });
}

async function loadLeaderboard() {
  const snap = await getDocs(collection(db, "game_scores"));
  const entries = snap.docs
    .map(d => ({ uid: d.id, ...d.data() }))
    .sort((a, b) => (b.bestScore || 0) - (a.bestScore || 0));

  const top10 = entries.slice(0, 10);
  const listEl = document.getElementById("leaderboard-list");
  listEl.innerHTML = top10.length
    ? top10.map((e, i) => `
        <div class="leaderboard-row ${currentUser && e.uid === currentUser.uid ? "is-me" : ""}">
          <span><span class="leaderboard-rank">${i + 1}</span>${e.nickname}</span>
          <span>${e.bestScore}</span>
        </div>`).join("")
    : `<p class="text-muted small">아직 기록이 없습니다.</p>`;

  const myRankEl = document.getElementById("my-rank");
  if (!currentUser) { myRankEl.textContent = ""; return; }
  const myIndex = entries.findIndex(e => e.uid === currentUser.uid);
  myRankEl.textContent = myIndex === -1
    ? "아직 기록이 없습니다"
    : `내 순위: ${myIndex + 1}위 (최고 ${entries[myIndex].bestScore}점)`;
}