import { Point } from "./engine/datatypes.ts";
import { DrawPile } from "./drawpile.ts";
import { D } from "./engine/public.ts";
import { sprThrallLore } from "./sprites.ts";
import {
  BG_INSET,
  BG_WALL_OR_UNREVEALED,
  FG_BOLD,
  FG_MOULDING,
  FG_TEXT, FG_TOO_EXPENSIVE,
} from "./colors.ts";
import { getPlayerProgress } from "./playerprogress.ts";
import { Architecture, LoadedNewMap } from "./newmap.ts";
import { FLOOR_CELL_SIZE, GridArt } from "./gridart.ts";
import { shadowcast } from "./shadowcast.ts";
import { getCheckModal } from "./checkmodal.ts";
import {withCamera} from "./layout.ts";

export class HuntMode {
  map: LoadedNewMap;
  player: Point;
  faceLeft: boolean;

  drawpile: DrawPile;
  frame: number;
  depth: number;

  constructor(depth: number, map: LoadedNewMap) {
    this.map = map;
    this.player = map.entrance;
    this.faceLeft = false;

    this.drawpile = new DrawPile();
    this.frame = 0;
    this.depth = depth;

    // getCheckModal().show(standardVaultTemplates[5].checks[1], null)
  }

  getDepth() {
    return this.depth;
  }

  // == update logic ==
  #collectResources() {
    let cell = this.map.get(this.player);

    let pickup = cell.pickup;
    if (pickup != null) {
      cell.pickup = null;
    }
  }

  #computeCostToClick(mapPosition: Point): number | null {
    let present = this.map.get(mapPosition);

    if (present.architecture != Architecture.Floor) {
      return null;
    }

    let dist = Math.max(
      Math.abs(mapPosition.x - this.player.x),
      Math.abs(mapPosition.y - this.player.y),
    );

    if (dist != 1) {
      return null;
    }

    let pickup = present.pickup;
    if (pickup == null) {
      return 10;
    }
    return pickup.computeCostToClick();
  }

  movePlayerTo(newPosition: Point) {
    let oldX = this.player.x;
    let newX = newPosition.x;
    this.player = newPosition;
    if (newX < oldX) {
      this.faceLeft = true;
    }
    if (oldX < newX) {
      this.faceLeft = false;
    }
    this.#collectResources();
  }

  // draw
  update() {
    withCamera("Gameplay", () => { this.#update() });
  }
  draw() {
    withCamera("Gameplay", () => { this.#draw() });
  }

  #update() {
    this.frame += 1;
    this.drawpile.clear();

    let globalOffset = new Point(
      this.player.x * FLOOR_CELL_SIZE.w,
      this.player.y * FLOOR_CELL_SIZE.h,
    ).offset(new Point(-192, -192));

    this.#updateFov();

    for (let y = 0; y < this.map.size.h; y += 1) {
      for (let x = 0; x < this.map.size.w; x += 1) {
        let offsetInCells = new Point(x - this.player.x, y - this.player.y);
        this.#drawMapCell(offsetInCells, new Point(x, y));
      }
    }
    this.#drawPlayer(globalOffset);

    this.drawpile.executeOnClick();
  }

  #updateFov() {
    for (let y = 0; y < this.map.size.h; y += 1) {
      for (let x = 0; x < this.map.size.w; x += 1) {
        this.map.get(new Point(x, y)).revealed = false;
      }
    }

    this.map.get(new Point(this.player.x, this.player.y)).revealed = true;
    shadowcast(
      [this.player.x, this.player.y],
      ([x, y]: [number, number]): boolean => {
        let cell = this.map.get(new Point(x, y));
        let pickup = cell.pickup;
        return (
          cell.architecture == Architecture.Wall ||
          (pickup != null && pickup.isObstructive())
        );
      },
      ([x, y]: [number, number]) => {
        let dx = x - this.player.x;
        let dy = y - this.player.y;
        if (dx * dx + dy * dy >= 13) {
          return;
        }
        this.map.get(new Point(x, y)).revealed = true;
      },
    );
  }

  #draw() {
    this.drawpile.draw();
  }

  #drawMapCell(offsetInCells: Point, mapPosition: Point) {
    const OFFSET_UNDER_FLOOR = -512 + mapPosition.y;
    const OFFSET_FLOOR = -256 + mapPosition.y;
    const OFFSET_AIR = 0 + mapPosition.y;
    const OFFSET_TOP = 256 + mapPosition.y;
    const OFFSET_TOP_OF_TOP = 512 + mapPosition.y;

    const gridArt = new GridArt(offsetInCells);

    let cellData = this.map.get(mapPosition);

    this.drawpile.add(OFFSET_UNDER_FLOOR, () => {
      gridArt.drawCeiling(BG_WALL_OR_UNREVEALED);
    });
    if (cellData.architecture == Architecture.Wall || !cellData.revealed) {
      this.drawpile.add(OFFSET_TOP, () => {
        gridArt.drawCeiling(BG_WALL_OR_UNREVEALED);
      });
      return;
    }

    if (!cellData.revealed) {
      return;
    }

    let pickup = cellData.pickup;

    // draw inset zone
    let cost = this.#computeCostToClick(mapPosition);
    let tooExpensive = cost != null && (cost > getPlayerProgress().getBlood());
    this.drawpile.addClickable(
      OFFSET_FLOOR,
      (hover: boolean) => {
        let highlighted = hover;
        if (cost == null) {
          highlighted = false;
        }
        if (!(pickup?.advertisesClickable() ?? true)) {
          highlighted = false;
        }

        let color = BG_INSET;
        if (highlighted) {
          color = FG_TEXT;
          if (tooExpensive) {
            color = FG_TOO_EXPENSIVE;
          }
        }

        gridArt.drawFloor(color);
        pickup?.drawFloor(gridArt);
      },
      gridArt.floorRect,
      true,
      () => {
        if (cost == null || tooExpensive) { return; }
        if (pickup?.onClick(cellData)) {
          return;
        }

        if (cost != null) {
          getPlayerProgress().spendBlood(cost);
          this.movePlayerTo(mapPosition);
          getCheckModal().show(null, null);
        }
      },
    );

    if (pickup != null) {
      this.drawpile.add(OFFSET_AIR, () => {
        pickup.drawInAir(gridArt);
      });
    }

    const isRevealedBlock = (dx: number, dy: number) => {
      let other = this.map.get(mapPosition.offset(new Point(dx, dy)));
      return other.revealed && other.architecture == Architecture.Wall;
    };
    if (isRevealedBlock(0, -1) && isRevealedBlock(-1, 0)) {
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingTopLeft(FG_MOULDING);
      });
    }
    if (isRevealedBlock(0, -1)) {
      this.drawpile.add(OFFSET_AIR, () => {
        gridArt.drawWallTop(FG_TEXT);
      });
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingTop(FG_MOULDING);
      });
    }
    if (isRevealedBlock(0, -1) && isRevealedBlock(1, 0)) {
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingTopRight(FG_MOULDING);
      });
    }
    if (isRevealedBlock(-1, 0)) {
      this.drawpile.add(OFFSET_AIR, () => {
        gridArt.drawWallLeft(FG_TEXT);
      });
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingLeft(FG_MOULDING);
      });
    }
    if (isRevealedBlock(0, 1) && isRevealedBlock(-1, 0)) {
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingBottomLeft(FG_MOULDING);
      });
    }
    if (isRevealedBlock(0, 1)) {
      this.drawpile.add(OFFSET_AIR, () => {
        gridArt.drawWallBottom(FG_BOLD);
      });
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingBottom(FG_MOULDING);
      });
    }
    if (isRevealedBlock(0, 1) && isRevealedBlock(1, 0)) {
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingBottomRight(FG_MOULDING);
      });
    }
    if (isRevealedBlock(1, 0)) {
      this.drawpile.add(OFFSET_AIR, () => {
        gridArt.drawWallRight(FG_BOLD);
      });
      this.drawpile.add(OFFSET_TOP_OF_TOP, () => {
        gridArt.drawMouldingRight(FG_MOULDING);
      });
    }
  }

  #drawPlayer(globalOffset: Point) {
    let cellOffset = new Point(
      this.player.x * FLOOR_CELL_SIZE.w,
      this.player.y * FLOOR_CELL_SIZE.h,
    ).offset(globalOffset.negate());
    this.drawpile.add(this.player.y, () => {
      D.drawSprite(sprThrallLore, cellOffset, 1, {
        xScale: this.faceLeft ? -2 : 2,
        yScale: 2,
      });
    });
  }
}

let active: HuntMode | null = null;
export function initHuntMode(huntMode: HuntMode) {
  active = huntMode;
}

export function getHuntMode() {
  if (active == null) {
    throw new Error(`trying to get hunt mode before it has been initialized`);
  }
  return active;
}