/**
 * @medieval-kit/wooden-bench
 *
 * The bench that sits beside the trestle table. In the middle ages a chair was
 * a status object; what people actually sat on was a bench, so a hall scene
 * needs one even more than it needs the table.
 *
 * Two thick end boards and a seat, and NOTHING BETWEEN THEM. This bench carried
 * a lengthwise stretcher, copied across from the trestle table, and the
 * reference has none: each board runs uninterrupted from the floor to the seat,
 * and the clear open span underneath is a large part of what separates a bench
 * from a table at a glance. Removing it drops a part from the model, which is a
 * breaking change and worth one, because what it buys is the silhouette.
 *
 * The seat IS fixed to the legs, which is the other thing that separates the
 * two: a table top can be lifted off, a bench seat cannot. The legs are tenoned
 * into it and pegged through, and the peg is the joint anyone can actually see.
 * The tenon is cut off flush with the seat in the reference and reads there as
 * a faint rectangle of end grain, which is a texture rather than a shape, so it
 * stays housed inside the slab where an earlier pass put it after two separate
 * complaints about a block of oak standing proud of the surface you sit on.
 */
import {
  boxGeometry,
  chamferedBoxGeometry,
  createKitModel,
  createTinter,
  jitter,
  mergeColoured,
  taperedBoxGeometry,
} from '../core/index.ts'

export interface WoodenBenchConfig {
  /** Bench length (metres). */
  readonly length: number
  /** Seat height (metres). */
  readonly height: number
  /** Seat width (metres). */
  readonly width: number
  /** Outward splay of the legs. 0 = upright. */
  readonly splay: number
  /** How far the legs stand in from the ends, as a fraction of the length. */
  readonly inset: number
  readonly seed: number
}

export const woodenBenchDefaults: WoodenBenchConfig = {
  length: 1.62,
  height: 0.45,
  width: 0.3,
  splay: 0.24,
  inset: 0.13,
  seed: 31,
}

export type WoodenBenchParts = 'seat' | 'legs'

export function createModel(overrides: Partial<WoodenBenchConfig> = {}) {
  return createKitModel<WoodenBenchConfig, 'oak', WoodenBenchParts>({
    id: 'wooden-bench',
    defaults: woodenBenchDefaults,
    slots: ['oak'],
    build: ({ config, random }) => {
      const tint = createTinter(random)
      const half = config.height / 2
      // 0.135 of the height, not 0.09.
      //
      // At 0.09 the seat came out 40 mm on a bench 1.62 m long -- one
      // fortieth of its own span, where the reference reads about one
      // twentieth. Medieval furniture is riven, not machined: the board is
      // whatever the log gave, and that is thick. A thin slab over a long
      // span also looks like it would flex, which is the specific way these
      // pieces were reading as flimsy.
      const seatThickness = config.height * 0.135
      const seatTop = half
      const seatBottom = seatTop - seatThickness
      const timber = config.width * 0.09

      // --- Seat ----------------------------------------------------------
      // A single thick board. Using two boards is not as natural on a bench
      // as it is on the table: the seat must not have a gap down the middle.
      const seatPieces = [chamferedBoxGeometry(
        [config.length, config.width * 0.95],
        [config.length * 0.995, config.width],
        seatThickness,
        timber * 0.4,
        [0, seatBottom + seatThickness / 2, 0],
        tint('oak', 0.05),
      )]

      // --- Legs ----------------------------------------------------------
      const legX = config.length * (0.5 - config.inset)
      const legHeight = seatBottom - (-half)
      const legWidth = config.width * 0.66
      const spread = legWidth * config.splay

      const legPieces = []
      for (const side of [-1, 1]) {
        // Leg board with an arch cut out of its foot.
        //
        // The board widens on the way down. The splay is in the measure, not
        // in the angle — widening the bottom face instead of rotating is both
        // cheaper and lets the foot sit FLAT on the ground, whereas a rotated
        // leg stands on its edge.
        //
        // The arch is not decoration. A plank leg standing on its whole edge
        // rocks on any floor that is not flat, and no medieval floor was; the
        // cut leaves two feet, and two feet on each board give the bench four
        // points to find the ground with. It is also the single most
        // recognisable thing about the silhouette, and the reference has it.
        //
        // It is cut by building the board in three pieces rather than
        // subtracting: the geometry here is all non-indexed triangle soup with
        // no boolean operations, so a notch is made by not filling it.
        const archHeight = legHeight * 0.3
        const archFrac = archHeight / legHeight
        const footWidth = legWidth + spread * 2
        const widthAtArch = legWidth + spread * 2 * (1 - archFrac)

        // Upper board: from the top of the arch to the underside of the seat.
        legPieces.push(taperedBoxGeometry(
          [widthAtArch, timber * 1.35],
          [legWidth, timber * 1.35],
          legHeight - archHeight,
          [side * legX, -half + archHeight + (legHeight - archHeight) / 2, 0],
          tint('oak', -0.02),
        ))

        // The two feet. They run PAST the top of the arch into the board above,
        // so the joint is an overlap rather than two faces meeting.
        const footThickness = footWidth * 0.3
        const footRise = archHeight + legHeight * 0.07

        /**
         * Each foot narrows on the way UP by exactly the board's own taper.
         *
         * This is the protrusion, and it was reported twice before I found it:
         * the first time I planed the through-tenons and answered the wrong
         * question. The feet were built at `footWidth`, the board's width at
         * the GROUND -- but a foot starts at the top of the arch, a third of
         * the way up, where the board has not widened that far yet. So every
         * foot stood proud of the board it hangs from, on both sides, as a
         * hard shoulder at shin height: 14 mm by default and 32 mm at full
         * splay. Setting the splay to zero made it vanish, which is what
         * finally named the cause.
         *
         * The leg's outer edge is a straight line from `footWidth / 2` at the
         * floor to `legWidth / 2` under the seat, and the foot's outer face
         * has to lie ON that line rather than run vertically up from its foot.
         * A tapered box narrows about its own centre, so taking twice the
         * taper off the top width moves the outer face in by exactly the taper
         * -- and moves the inner face out by the same, which narrows the arch
         * as it rises, which is also what a splayed leg does.
         */
        const footTaper = spread * (footRise / legHeight)
        const footTop = Math.max(footThickness * 0.3, footThickness - footTaper * 2)
        for (const foot of [-1, 1]) {
          legPieces.push(taperedBoxGeometry(
            [footThickness, timber * 1.35],
            [footTop, timber * 1.35],
            footRise,
            [
              side * legX + foot * (footWidth - footThickness) / 2,
              -half + footRise / 2,
              0,
            ],
            tint('oak', -0.04),
          ))
        }

        /**
         * Tenon: HOUSED in the seat, stopping short of its top face.
         *
         * It was a through-tenon and it was reported twice. First at 42 mm
         * proud, a block of oak the size of a thumb standing out of the
         * surface you sit on; I planed it to 3 mm and called it done, and 3 mm
         * is still a raised patch with a lit edge on it, still visible in the
         * render, and still the thing being complained about. The brief is
         * that nothing on the seat shows, and 3 mm is not nothing — it is
         * small.
         *
         * So it ends INSIDE the slab, an eighth of the seat's thickness below
         * the top. That is a real joint and not a compromise: a stub tenon
         * into the underside of a board is how a bench is made when the top is
         * thick enough to take it, which at 0.135 of the height it is. What is
         * lost is the panel of end grain on top; what is gained is a seat.
         *
         * Ending it LEVEL with the top face was never an option, which is what
         * sent me to 3 mm proud in the first place: two upward faces in one
         * plane is the z-fight the checker exists to find. Buried has neither
         * problem — a face inside a solid cannot fight anything and cannot be
         * seen.
         */
        const buried = seatThickness * 0.12
        const housed = seatThickness * 0.16
        legPieces.push(chamferedBoxGeometry(
          [legWidth * 0.34, timber * 0.85],
          [legWidth * 0.32, timber * 0.8],
          seatThickness - buried + housed,
          timber * 0.16,
          [
            side * legX,
            seatBottom + (seatThickness - buried - housed) / 2,
            jitter(random, timber * 0.1),
          ],
          tint('oak', 0.09),
        ))

        /**
         * Wedge peg: driven through the leg board just under the seat, showing
         * on both broad faces.
         *
         * The reference has it and this model did not, and it is the one joint
         * detail a viewer can actually see. The tenon into the seat cannot be
         * seen at all -- in the reference its end grain is cut off flush with
         * the seat and reads as a faint rectangle, which is a texture and not a
         * shape, so there is nothing for geometry to do there. The peg is the
         * opposite: a small solid standing out of a flat board, which is
         * exactly what lowpoly geometry is good at.
         *
         * It goes right through and out the far side, because a peg that stops
         * inside the board is a peg that is doing nothing.
         */
        const pegOut = timber * 0.62
        const boardThickness = timber * 1.35
        legPieces.push(chamferedBoxGeometry(
          [legWidth * 0.16, boardThickness + pegOut * 2],
          [legWidth * 0.13, boardThickness + pegOut * 2],
          timber * 0.72,
          timber * 0.12,
          [side * legX, seatBottom - timber * 1.15, 0],
          tint('oak', 0.07),
        ))
      }

      return {
        seat: { slot: 'oak' as const, geometry: mergeColoured(seatPieces) },
        legs: { slot: 'oak' as const, geometry: mergeColoured(legPieces) },
      }
    },
  }, overrides)
}