/**
 * The world, drawn from inside the player's head.
 *
 * One pass of rays across the screen builds the walls and a depth buffer;
 * everything else — bodies, the game's own props, tracers — is a billboard
 * tested against that buffer, so a body behind a corner is not drawn at all.
 * Fog is measured along each ray, not painted as a disc: cross one and
 * everything past it fogs.
 *
 * The ray loop allocates nothing and draws nothing: it writes a shade level,
 * a face and a slice into the column arrays, and `slices.js` collapses those
 * into runs so a flat wall costs one `fillRect` and not one a column.
 * Colours come out of a table built once, the depth and column buffers are
 * kept between frames, and the sprite list is sorted in a buffer the scene
 * owns.
 *
 * Nothing here knows what the game is. What a body is and how it hides is
 * generic; what stands on the floor besides bodies, and what fogs a ray, the
 * game says through `view` — see `drawScene`.
 */

import { swell } from "./presence.js";
import { makeColumns, SKY, wallRuns } from "./slices.js";
import {
  castRay,
  columnOffset,
  hitResult,
  project,
  projection,
  projectResult,
  sliceHeight,
  smokeAlong,
  spriteColumnVisible,
  wallLight,
} from "./raycast.js";

export const EYE = 40; // half a tile up: the horizon sits on the middle of the wall
export const WALL = 80; // walls are one tile tall
const BODY = 58; // a person, in world units
const MAX_SIGHT = 1800;
const LEVELS = 48;

// Wall colours, quantised into levels and built once, so the ray loop never
// builds a string. How dark a slice is comes from `wallLight`, which already
// knows about distance and which face was struck.
const SHADES = (() => {
  const out = [];
  for (let i = 0; i < LEVELS; i++) {
    const k = (i + 0.5) / LEVELS;
    out.push(`rgb(${Math.round(150 * k)},${Math.round(158 * k)},${Math.round(178 * k)})`);
  }
  return out;
})();
const FOG = "rgb(198,203,212)";

const NO_FOG = () => {};
const NO_PROPS = () => {};
const PLAIN = () => "#999";
const NO_BADGE = () => null;

export function makeScene() {
  return {
    depth: new Float32Array(0),
    cols: makeColumns(0),
    runs: [],
    hit: hitResult(),
    proj: projectResult(),
    order: [],
    smokes: [],
    sky: null,
    skyKey: "",
  };
}

const levelOf = (light) => Math.min(LEVELS - 1, Math.max(0, (light * LEVELS) | 0));

/**
 * The walls, a rectangle a run rather than a rectangle a column. The runs
 * are stretches where the shade level, the face, the fog and the geometry
 * all agree — see `slices.js` — so this is the same picture the per-column
 * loop drew, in a fraction of the calls.
 */
function drawWalls(ctx, scene, step) {
  const runs = scene.runs;
  const used = wallRuns(scene.cols, runs);
  for (let r = 0; r < used; r++) {
    const run = runs[r];
    const x = run.from * step;
    const wide = (run.to - run.from + 1) * step + 1;
    ctx.fillStyle = SHADES[run.level];
    ctx.fillRect(x, run.top, wide, run.high);
    if (run.haze > 0.01) {
      ctx.globalAlpha = run.haze;
      ctx.fillStyle = FOG;
      ctx.fillRect(x, run.top, wide, run.high);
      ctx.globalAlpha = 1;
    }
  }
}

/**
 * Draw one frame.
 *
 * `world` carries the map (`solid`, `tile`), `eye` is where the camera
 * stands and looks, `snap` is the last snapshot the server sent — it must
 * carry `me`, `players` and `shots` — and `view` is the frame: its pixel
 * size, `look(player)` for the smoothed position to draw somebody at, and
 * the game's own holes in the picture, each optional:
 *
 * - `fog(snap, out)` pushes the discs `{x, y, r}` a ray fogs through.
 * - `props(snap, out)` pushes what stands on the floor besides bodies, each
 *   `{x, y, draw}`; `draw(ctx, thing, floorY, proj, clip)` is handed the
 *   projected thing (`column`, `perp`, `size`) and a `clip(thing, left,
 *   right, fn)` that runs `fn` only where the thing beats the wall.
 * - `trim(player)` is the colour of the stripe across a body.
 * - `badge(player)` is a colour to mark a body with, or null.
 */
export function drawScene(ctx, scene, world, eye, snap, view) {
  const W = view.width;
  const H = view.height;
  // One ray every other column of the buffer, and the wall slice two columns
  // wide: flat shading does not reward a ray a pixel, and the sprites are
  // still drawn at the buffer's own resolution. Below that width a picture
  // this coarse stops being one.
  const step = W >= 640 ? 2 : 1;
  const columns = Math.ceil(W / step);
  if (scene.depth.length !== columns) {
    scene.depth = new Float32Array(columns);
    scene.cols = makeColumns(columns);
  }
  const proj = projection(W);
  const horizon = H / 2;

  drawSky(ctx, scene, W, H, horizon);

  const smokes = scene.smokes;
  smokes.length = 0;
  (view.fog || NO_FOG)(snap, smokes);

  const depth = scene.depth;
  const cols = scene.cols;
  const fog = cols.haze;
  const hit = scene.hit;
  for (let i = 0; i < columns; i++) {
    const offset = columnOffset(i * step + step / 2, W);
    const angle = eye.angle + offset;
    castRay(world.solid, eye.x, eye.y, angle, world.tile, MAX_SIGHT, hit);
    const perp = Math.max(1, hit.dist * Math.cos(offset));
    depth[i] = perp;
    let haze = 0;
    if (smokes.length) {
      const dx = Math.cos(angle);
      const dy = Math.sin(angle);
      for (let s = 0; s < smokes.length; s++) {
        const z = smokes[s];
        haze += smokeAlong(eye.x, eye.y, dx, dy, z.x, z.y, z.r, hit.dist);
        if (haze >= 1) break;
      }
      haze = Math.min(1, haze);
    }
    fog[i] = haze;
    if (!hit.wall) {
      cols.level[i] = SKY;
      continue;
    }
    const h = Math.min(H * 6, sliceHeight(perp, proj, WALL));
    cols.level[i] = levelOf(wallLight(perp, hit.side, world.tile));
    cols.side[i] = hit.side;
    cols.top[i] = horizon - h / 2;
    cols.high[i] = h;
  }
  drawWalls(ctx, scene, step);

  drawThings(ctx, scene, eye, snap, view, proj, horizon, step, columns);
}

/** The two bands: a dark ceiling above the horizon, a warmer floor below. */
function drawSky(ctx, scene, W, H, horizon) {
  const key = `${W}x${H}`;
  if (scene.skyKey !== key || !scene.sky) {
    const sky = ctx.createLinearGradient(0, 0, 0, H);
    sky.addColorStop(0, "#0a0c11");
    sky.addColorStop(0.49, "#23262f");
    sky.addColorStop(0.5, "#3a3026");
    sky.addColorStop(1, "#15120e");
    scene.sky = sky;
    scene.skyKey = key;
  }
  ctx.fillStyle = scene.sky;
  ctx.fillRect(0, 0, W, H);
  ctx.fillStyle = "rgba(255,255,255,0.09)";
  ctx.fillRect(0, horizon - 1, W, 2);
}

/**
 * Everything that is not a wall, far to near, each one clipped to the screen
 * columns where it beats the wall behind it. The game's props go in first,
 * then bodies, then marks: a tie in depth keeps that order.
 */
function drawThings(ctx, scene, eye, snap, view, proj, horizon, step, columns) {
  const W = view.width;
  const things = scene.order;
  things.length = 0;

  (view.props || NO_PROPS)(snap, things);
  const trim = view.trim || PLAIN;
  const badge = view.badge || NO_BADGE;
  for (const player of snap.players) {
    if (player.id === snap.me.id) continue;
    const at = view.look(player);
    // How far into sight this body is: 0 the moment it appears, 1 solid.
    // See presence.js — a body that pops into existence reads as a bug.
    const shown = view.shown ? view.shown(player) : 1;
    things.push({ kind: "body", player, shown, x: at.x, y: at.y, angle: at.angle });
  }
  // Where somebody was last seen, dimming away. It stands where they were,
  // so a wall between you and that spot hides it like anything else.
  if (view.marks) for (const mark of view.marks) things.push({ kind: "mark", mark, x: mark.x, y: mark.y });

  const p = scene.proj;
  for (const thing of things) {
    project(eye.x, eye.y, eye.angle, thing.x, thing.y, W, proj, BODY, p);
    thing.perp = p.perp;
    thing.column = p.column;
    thing.size = p.size;
    thing.behind = p.behind;
  }
  things.sort((a, b) => b.perp - a.perp);

  const clip = (thing, left, right, fn) => withRuns(ctx, scene, left, right, thing.perp, step, columns, fn);
  for (const thing of things) {
    if (thing.behind) continue;
    const floorY = horizon + (EYE * proj) / thing.perp;
    const haze = hazeAt(scene, thing.column, step, columns);
    const arriving = thing.kind === "body" ? thing.shown : thing.kind === "mark" ? thing.mark.fade : 1;
    ctx.globalAlpha = Math.max(0, 1 - haze) * arriving;
    if (ctx.globalAlpha < 0.05) continue;
    if (thing.kind === "body") drawBody(ctx, thing, floorY, clip, trim, badge);
    else if (thing.kind === "mark") drawMark(ctx, thing, floorY, clip);
    else thing.draw(ctx, thing, floorY, proj, clip);
    ctx.globalAlpha = 1;
  }
  ctx.globalAlpha = 1;

  drawTracers(ctx, scene, eye, snap, W, proj, horizon);
}

const hazeAt = (scene, column, step, columns) => {
  const i = Math.max(0, Math.min(columns - 1, Math.round(column / step)));
  return scene.cols.haze[i] ?? 0;
};

/**
 * The visible runs of a sprite: the stretches of screen column where it is
 * nearer than the wall. Two rectangles at most in practice, and the caller
 * clips its drawing to each.
 */
function withRuns(ctx, scene, left, right, perp, step, columns, draw) {
  let runStart = -1;
  const from = Math.max(0, Math.floor(left / step));
  const to = Math.min(columns - 1, Math.ceil(right / step));
  for (let i = from; i <= to + 1; i++) {
    const shown = i <= to && spriteColumnVisible(perp, scene.depth[i]);
    if (shown && runStart < 0) runStart = i;
    if (!shown && runStart >= 0) {
      ctx.save();
      ctx.beginPath();
      ctx.rect(runStart * step - 0.5, 0, (i - runStart) * step + 1, 1e5);
      ctx.clip();
      draw();
      ctx.restore();
      runStart = -1;
    }
  }
}

function drawBody(ctx, thing, floorY, clip, trim, badge) {
  const p = thing.player;
  // A body arriving grows from its feet as it fades in, so it reads as
  // somebody coming round the corner rather than one appearing there.
  const h = thing.size * swell(thing.shown ?? 1);
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  const mate = p.mate;

  // The dead lie down. No tag, no chevron, no trim colour: if something is
  // upright with a marker over it, it is alive and it can shoot you.
  if (!p.alive) {
    const lie = h * 0.16;
    clip(thing, cx - w * 1.1, cx + w * 1.1, () => {
      ctx.fillStyle = "#4a4e57";
      ctx.beginPath();
      ctx.ellipse(cx, floorY - lie * 0.4, w * 1.05, lie, 0, 0, 7);
      ctx.fill();
      ctx.strokeStyle = "#23262d";
      ctx.lineWidth = Math.max(1, h * 0.02);
      ctx.stroke();
    });
    return;
  }

  const skin = mate ? "#3f9fd6" : "#d8483f";
  const stripe = trim(p);
  const mark = badge(p);
  const edge = Math.max(1.2, h * 0.05);

  clip(thing, cx - w * 1.2, cx + w * 1.5, () => {
    // Body and head, each with a hard dark edge: the silhouette is what
    // carries across a dim room, where the colour does not.
    ctx.fillStyle = skin;
    ctx.fillRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.strokeStyle = "#0b0d11";
    ctx.lineWidth = edge;
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = stripe;
    ctx.fillRect(cx - w / 2, top + h * 0.34, w, h * 0.1);
    ctx.beginPath();
    ctx.arc(cx, top + h * 0.17, h * 0.15, 0, 7);
    ctx.fillStyle = skin;
    ctx.fill();
    ctx.strokeStyle = "#0b0d11";
    ctx.stroke();

    if (mark) {
      ctx.fillStyle = mark;
      ctx.fillRect(cx + w * 0.5, top + h * 0.4, w * 0.3, h * 0.3);
    }
    if (p.hp < 100) {
      ctx.fillStyle = "#000a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w, h * 0.06);
      ctx.fillStyle = mate ? "#6fcf6f" : "#e8b04a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w * (p.hp / 100), h * 0.06);
    }

    if (mate) tag(ctx, p, cx, top, h);
    else chevron(ctx, cx, top, h);
  });
}

/**
 * A mark where somebody was last seen: an empty outline and a scuff on the
 * floor, dimming away over a second. Deliberately not a body — nothing is
 * filled, there is no head and no chevron — because it is a memory of a
 * sighting and must never be mistaken for one.
 */
function drawMark(ctx, thing, floorY, clip) {
  const h = thing.size * 0.9;
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  clip(thing, cx - w * 1.2, cx + w * 1.2, () => {
    ctx.strokeStyle = thing.mark.mate ? "rgba(120,180,230,0.85)" : "rgba(235,150,120,0.9)";
    ctx.lineWidth = Math.max(1, h * 0.035);
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = "rgba(10,12,16,0.45)";
    ctx.fillRect(cx - w * 0.7, floorY - h * 0.04, w * 1.4, h * 0.05);
  });
}

/** An enemy wears a chevron: a shape, not a hue, for anyone whose eyes read
 * red and blue the same way. */
function chevron(ctx, cx, top, h) {
  const size = Math.max(4, h * 0.16);
  const y = top - h * 0.16;
  ctx.beginPath();
  ctx.moveTo(cx - size, y - size);
  ctx.lineTo(cx + size, y - size);
  ctx.lineTo(cx, y);
  ctx.closePath();
  ctx.fillStyle = "#ff6f5e";
  ctx.fill();
  ctx.lineWidth = Math.max(1, h * 0.02);
  ctx.strokeStyle = "#140a08";
  ctx.stroke();
}

/** A team mate wears their name and a pip of their health — never an enemy. */
function tag(ctx, p, cx, top, h) {
  const size = Math.max(9, Math.min(18, h * 0.16));
  const y = top - h * 0.34;
  ctx.font = `${size}px system-ui, sans-serif`;
  ctx.textAlign = "center";
  const width = ctx.measureText(p.name).width + size * 1.4;
  ctx.fillStyle = "rgba(10,12,16,0.65)";
  ctx.fillRect(cx - width / 2, y, width, size * 1.4);
  ctx.fillStyle = p.hp > 60 ? "#6fcf6f" : p.hp > 25 ? "#e0a040" : "#e05a4a";
  ctx.fillRect(cx - width / 2 + size * 0.25, y + size * 0.35, size * 0.45, size * 0.7);
  ctx.fillStyle = "#cfe8ff";
  ctx.fillText(p.name, cx + size * 0.4, y + size * 1.05);
  ctx.textAlign = "left";
}

/** A round thing on the floor, for a game to draw its pickups with. */
export function drawBlob(ctx, thing, floorY, colour, scale, clip) {
  const r = thing.size * scale;
  const cx = thing.column;
  clip(thing, cx - r, cx + r, () => {
    ctx.fillStyle = colour;
    ctx.beginPath();
    ctx.arc(cx, floorY - r, r, 0, 7);
    ctx.fill();
  });
}

/** Shots the server let us see, as a line through the world. */
function drawTracers(ctx, scene, eye, snap, W, proj, horizon) {
  if (!snap.shots.length) return;
  const p = scene.proj;
  ctx.lineWidth = 2;
  for (const shot of snap.shots) {
    project(eye.x, eye.y, eye.angle, shot.x1, shot.y1, W, proj, BODY, p);
    if (p.behind) continue;
    const x1 = p.column;
    const y1 = horizon + (EYE * proj) / p.perp - p.size * 0.6;
    project(eye.x, eye.y, eye.angle, shot.x2, shot.y2, W, proj, BODY, p);
    if (p.behind) continue;
    ctx.strokeStyle = shot.hit ? "rgba(255,140,120,0.5)" : "rgba(255,240,190,0.35)";
    ctx.beginPath();
    ctx.moveTo(x1, y1);
    ctx.lineTo(p.column, horizon + (EYE * proj) / p.perp - p.size * 0.6);
    ctx.stroke();
  }
}