const MAGIC = [0x42, 0x4e, 0x17, 0xee];

enum DrawEntryType {
  Image = 1,
  Animation = 2,
  HScroll = 3,
  VScroll = 4,
  Line = 5,
}

enum ScrollWrap {
  Restarting = 0,
  Continuous = 1,
}

enum HScrollDirection {
  Left = 0,
  Right = 1,
}

enum VScrollDirection {
  Up = 0,
  Down = 1,
}

interface DrawHeader {
  posX: number;
  posY: number;
}

interface DrawImage {
  type: DrawEntryType.Image;
  header: DrawHeader;
  width: number;
  height: number;
  data: Uint8Array;
}

interface DrawAnimation {
  type: DrawEntryType.Animation;
  header: DrawHeader;
  width: number;
  height: number;
  frameCount: number;
  updateInterval: number;
  data: Uint8Array;
}

interface DrawHScroll {
  type: DrawEntryType.HScroll;
  header: DrawHeader;
  width: number;
  height: number;
  contentWidth: number;
  scrollSpeed: number;
  wrap: ScrollWrap;
  direction: HScrollDirection;
  data: Uint8Array;
}

interface DrawVScroll {
  type: DrawEntryType.VScroll;
  header: DrawHeader;
  width: number;
  height: number;
  contentHeight: number;
  scrollSpeed: number;
  wrap: ScrollWrap;
  direction: VScrollDirection;
  data: Uint8Array;
}

interface DrawLine {
  type: DrawEntryType.Line;
  header: DrawHeader;
  endX: number;
  endY: number;
}

type DrawEntry = DrawImage | DrawAnimation | DrawHScroll | DrawVScroll | DrawLine;

function bitmapSizeBytes(width: number, height: number): number {
  return Math.floor((width * height + 7) / 8);
}

function setPixelInBitmap(
  x: number,
  y: number,
  memory: Uint8Array,
  width: number,
  height: number,
  value: boolean
): void {
  const index = y * width + x;
  const byteIndex = Math.floor(index / 8);
  const bitIndex = index % 8;
  if (value) {
    memory[byteIndex] |= 1 << bitIndex;
  } else {
    memory[byteIndex] &= ~(1 << bitIndex);
  }
}

function isPixelSetInBitmap(
  x: number,
  y: number,
  memory: Uint8Array,
  width: number,
  height: number
): boolean {
  const index = y * width + x;
  const byteIndex = Math.floor(index / 8);
  const bitIndex = index % 8;
  return (memory[byteIndex] & (1 << bitIndex)) !== 0;
}

class BinaryFramebufferEncoder {
  private entries: DrawEntry[] = [];

  addImage(
    posX: number,
    posY: number,
    width: number,
    height: number,
    pixelData: boolean[][]
  ): void {
    const data = new Uint8Array(bitmapSizeBytes(width, height));
    for (let y = 0; y < height; y++) {
      for (let x = 0; x < width; x++) {
        setPixelInBitmap(x, y, data, width, height, pixelData[y][x]);
      }
    }
    this.entries.push({
      type: DrawEntryType.Image,
      header: { posX, posY },
      width,
      height,
      data,
    });
  }

  addAnimation(
    posX: number,
    posY: number,
    width: number,
    height: number,
    frameCount: number,
    updateInterval: number,
    frames: boolean[][][]
  ): void {
    const frameSize = bitmapSizeBytes(width, height);
    const data = new Uint8Array(frameSize * frameCount);
    for (let f = 0; f < frameCount; f++) {
      const frameData = data.subarray(f * frameSize, (f + 1) * frameSize);
      for (let y = 0; y < height; y++) {
        for (let x = 0; x < width; x++) {
          setPixelInBitmap(x, y, frameData, width, height, frames[f][y][x]);
        }
      }
    }
    this.entries.push({
      type: DrawEntryType.Animation,
      header: { posX, posY },
      width,
      height,
      frameCount,
      updateInterval,
      data,
    });
  }

  addHScroll(
    posX: number,
    posY: number,
    width: number,
    height: number,
    contentWidth: number,
    scrollSpeed: number,
    wrap: ScrollWrap,
    direction: HScrollDirection,
    pixelData: boolean[][]
  ): void {
    const data = new Uint8Array(bitmapSizeBytes(contentWidth, height));
    for (let y = 0; y < height; y++) {
      for (let x = 0; x < contentWidth; x++) {
        setPixelInBitmap(x, y, data, contentWidth, height, pixelData[y][x]);
      }
    }
    this.entries.push({
      type: DrawEntryType.HScroll,
      header: { posX, posY },
      width,
      height,
      contentWidth,
      scrollSpeed,
      wrap,
      direction,
      data,
    });
  }

  addVScroll(
    posX: number,
    posY: number,
    width: number,
    height: number,
    contentHeight: number,
    scrollSpeed: number,
    wrap: ScrollWrap,
    direction: VScrollDirection,
    pixelData: boolean[][]
  ): void {
    const data = new Uint8Array(bitmapSizeBytes(width, contentHeight));
    for (let y = 0; y < contentHeight; y++) {
      for (let x = 0; x < width; x++) {
        setPixelInBitmap(x, y, data, width, contentHeight, pixelData[y][x]);
      }
    }
    this.entries.push({
      type: DrawEntryType.VScroll,
      header: { posX, posY },
      width,
      height,
      contentHeight,
      scrollSpeed,
      wrap,
      direction,
      data,
    });
  }

  addLine(posX: number, posY: number, endX: number, endY: number): void {
    this.entries.push({
      type: DrawEntryType.Line,
      header: { posX, posY },
      endX,
      endY,
    });
  }

  encode(): Uint8Array {
    let totalSize = 5;
    for (const entry of this.entries) {
      totalSize += 3;
      switch (entry.type) {
        case DrawEntryType.Image:
          totalSize += 2 + entry.data.length;
          break;
        case DrawEntryType.Animation:
          totalSize += 4 + entry.data.length;
          break;
        case DrawEntryType.HScroll:
        case DrawEntryType.VScroll:
          totalSize += 5 + entry.data.length;
          break;
        case DrawEntryType.Line:
          totalSize += 2;
          break;
      }
    }

    const buffer = new Uint8Array(totalSize);
    let pos = 0;

    buffer.set(MAGIC, pos);
    pos += 4;
    buffer[pos++] = this.entries.length;

    for (const entry of this.entries) {
      buffer[pos++] = entry.type;
      buffer[pos++] = entry.header.posX;
      buffer[pos++] = entry.header.posY;

      switch (entry.type) {
        case DrawEntryType.Image:
          buffer[pos++] = entry.width;
          buffer[pos++] = entry.height;
          buffer.set(entry.data, pos);
          pos += entry.data.length;
          break;

        case DrawEntryType.Animation:
          buffer[pos++] = entry.width;
          buffer[pos++] = entry.height;
          buffer[pos++] = entry.frameCount;
          buffer[pos++] = entry.updateInterval;
          buffer.set(entry.data, pos);
          pos += entry.data.length;
          break;

        case DrawEntryType.HScroll:
          buffer[pos++] = entry.width;
          buffer[pos++] = entry.height;
          buffer[pos++] = entry.contentWidth & 0xff;
          buffer[pos++] = (entry.contentWidth >> 8) & 0xff;
          buffer[pos++] =
            (entry.scrollSpeed & 0x3f) |
            (entry.direction === HScrollDirection.Right ? 0x40 : 0) |
            (entry.wrap === ScrollWrap.Continuous ? 0x80 : 0);
          buffer.set(entry.data, pos);
          pos += entry.data.length;
          break;

        case DrawEntryType.VScroll:
          buffer[pos++] = entry.width;
          buffer[pos++] = entry.height;
          buffer[pos++] = entry.contentHeight & 0xff;
          buffer[pos++] = (entry.contentHeight >> 8) & 0xff;
          buffer[pos++] =
            (entry.scrollSpeed & 0x3f) |
            (entry.direction === VScrollDirection.Down ? 0x40 : 0) |
            (entry.wrap === ScrollWrap.Continuous ? 0x80 : 0);
          buffer.set(entry.data, pos);
          pos += entry.data.length;
          break;

        case DrawEntryType.Line:
          buffer[pos++] = entry.endX;
          buffer[pos++] = entry.endY;
          break;
      }
    }

    return buffer;
  }
}

// Image processing utilities
async function loadBMP(data: Uint8Array): Promise<boolean[][]> {
  const view = new DataView(data.buffer, data.byteOffset);

  if (data[0] !== 0x42 || data[1] !== 0x4d) {
    throw new Error('Not a BMP file');
  }

  const offset = view.getUint32(10, true);
  const width = view.getInt32(18, true);
  const height = Math.abs(view.getInt32(22, true));
  const bpp = view.getUint16(28, true);

  const pixels: boolean[][] = Array(height).fill(null).map(() => Array(width).fill(false));

  if (bpp === 1) {
    const rowSize = Math.floor((width + 31) / 32) * 4;
    for (let y = 0; y < height; y++) {
      const rowStart = offset + (height - 1 - y) * rowSize;
      for (let x = 0; x < width; x++) {
        const byteIdx = Math.floor(x / 8);
        const bitIdx = 7 - (x % 8);
        pixels[y][x] = (data[rowStart + byteIdx] & (1 << bitIdx)) === 0;
      }
    }
  } else {
    const rowSize = Math.floor((width * bpp / 8 + 3) / 4) * 4;
    for (let y = 0; y < height; y++) {
      const rowStart = offset + (height - 1 - y) * rowSize;
      for (let x = 0; x < width; x++) {
        const pixelStart = rowStart + x * (bpp / 8);
        const b = data[pixelStart];
        const g = data[pixelStart + 1];
        const r = data[pixelStart + 2];
        const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
        pixels[y][x] = luminance < 128;
      }
    }
  }

  return pixels;
}

async function loadGIF(data: Uint8Array): Promise<boolean[][][]> {
  if (data[0] !== 0x47 || data[1] !== 0x49 || data[2] !== 0x46) {
    throw new Error('Not a GIF file');
  }

  // Simple GIF parser - supports basic single frame
  const view = new DataView(data.buffer, data.byteOffset);
  const width = view.getUint16(6, true);
  const height = view.getUint16(8, true);

  // For now, just return a single frame placeholder
  const frame: boolean[][] = Array(height).fill(null).map(() => Array(width).fill(false));
  return [frame];
}

async function loadJSON(text: string): Promise<boolean[][][]> {
  const json = JSON.parse(text);
  if (!Array.isArray(json)) {
    throw new Error('JSON must be an array of frames');
  }

  const frames: boolean[][][] = [];
  for (const frame of json) {
    if (!Array.isArray(frame)) {
      throw new Error('Each frame must be an array of rows');
    }
    const pixels: boolean[][] = "0".repeat(60).split("").map(row => "0".repeat(120).split("").map(pixel_in_x => false) as boolean[]);
    for (const change of frame) {
      const [x, y] = change;
      if (y < pixels.length) {
        if (x < pixels[y].length) {
          pixels[y][x] = true;
        }
      }
    }
    if (frames.length > 50) continue
    const usage = pixels.reduce((prev, row, y, fullarray) => prev + row.reduce((prev, pixel, x) => pixel ? prev + 1 : prev, 0), 0) / (120 * 60);
    console.log(`frame ${frames.length} (usage: ${(usage * 100).toFixed(2)}%)`);
    frames.push(pixels);
  }

  return frames;
}

async function loadImage(path: string): Promise<boolean[][][] | boolean[][]> {
  const data = new Uint8Array(await Bun.file(path).arrayBuffer());

  if (path.toLowerCase().endsWith('.bmp')) {
    return [await loadBMP(data)];
  } else if (path.toLowerCase().endsWith('.gif')) {
    return await loadGIF(data);
  } else if (path.toLowerCase().endsWith('.json')) {
    const text = await Bun.file(path).text();
    return await loadJSON(text);
  }

  throw new Error(`Unsupported format: ${path} `);
}

type LoadImageFunction = (params: string) => Promise<boolean[][]>;

async function createAnimationBinary(
  images: string[],
  output: string,
  startX: number,
  startY: number,
  updateInterval: number,
  mode: 'frame' | 'differential',
  loadImage: LoadImageFunction,
): Promise<void> {
  const encoder = new BinaryFramebufferEncoder();

  if (mode === 'differential') {
    if (images.length !== 2) {
      throw new Error('Differential mode requires exactly 2 images');
    }

    const frames: boolean[][][] = [];
    for (const img of images) {
      const loaded = await loadImage(img);
      const frame = Array.isArray(loaded[0]) ? loaded[0] : loaded;
      frames.push(frame as boolean[][]);
    }

    const width = frames[0][0].length;
    const height = frames[0].length;
    encoder.addAnimation(startX, startY, width, height, 2, updateInterval, frames);
  } else {
    const allFrames: boolean[][][] = [];

    for (const img of images) {
      const loaded = await loadImage(img);
      if (Array.isArray(loaded[0][0])) {
        allFrames.push(...(loaded as boolean[][][]));
      } else {
        allFrames.push(loaded as boolean[][]);
      }
    }

    if (allFrames.length === 1) {
      const width = allFrames[0][0].length;
      const height = allFrames[0].length;
      encoder.addImage(startX, startY, width, height, allFrames[0]);
    } else {
      const width = allFrames[0][0].length;
      const height = allFrames[0].length;
      encoder.addAnimation(startX, startY, width, height, allFrames.length, updateInterval, allFrames);
    }
  }

  const binary = encoder.encode();
  await Bun.write(output, binary);
  console.log(`Created ${output} (${binary.length} bytes)`);
}

function printHelp() {
  console.log(`
  Usage: bun run encoder.ts[options] < images...>

    Convert BMP / GIF images to binary animation format

  Arguments:
  images                Image file(s)(BMP, GIF, or JSON).GIF frames are extracted
  automatically.JSON format: array of frames, each frame is
                       array of rows with [x, y, on / off] pixels.Single frame
                       creates static object, multiple frames create animation.

    Options:
  -o, --output < file > Output binary file path(default: animation.bin)
    - x, --start - x < n > X coordinate for start position(default: 0)
      - y, --start - y < n > Y coordinate for start position(default: 0)
        - i, --interval < n > Update interval(0 = every tick, 1 = every second tick, etc.)(default: 3)
        - m, --mode < mode > Animation mode: "frame" = each image / frame is a frame,
          "differential" = alternate between 2 images(requires exactly 2 images)
            (default: frame)
            - h, --help           Show this help message
              `);
}

function parseArgs(args: string[]): {
  images: string[];
  output: string;
  startX: number;
  startY: number;
  updateInterval: number;
  mode: 'frame' | 'differential';
} | null {
  const result = {
    images: [] as string[],
    output: 'animation.bin',
    startX: 0,
    startY: 0,
    updateInterval: 3,
    mode: 'frame' as 'frame' | 'differential',
  };

  for (let i = 0; i < args.length; i++) {
    const arg = args[i];

    if (arg === '-h' || arg === '--help') {
      return null;
    } else if (arg === '-o' || arg === '--output') {
      result.output = args[++i];
    } else if (arg === '-x' || arg === '--start-x') {
      result.startX = parseInt(args[++i]);
    } else if (arg === '-y' || arg === '--start-y') {
      result.startY = parseInt(args[++i]);
    } else if (arg === '-i' || arg === '--interval') {
      result.updateInterval = parseInt(args[++i]);
    } else if (arg === '-m' || arg === '--mode') {
      const mode = args[++i];
      if (mode !== 'frame' && mode !== 'differential') {
        throw new Error('Mode must be "frame" or "differential"');
      }
      result.mode = mode;
    } else if (!arg.startsWith('-')) {
      result.images.push(arg);
    }
  }

  if (result.images.length === 0) {
    throw new Error('No images specified');
  }

  return result;
}

async function main() {
  const args = process.argv.slice(2);

  if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
    printHelp();
    return;
  }

  try {
    const params = parseArgs(args);
    if (!params) {
      printHelp();
      return;
    }

    await createAnimationBinary(
      params.images,
      params.output,
      params.startX,
      params.startY,
      params.updateInterval,
      params.mode,
      loadImage,
    );
  } catch (error) {
    console.error('Error:', error instanceof Error ? error.message : error);
    process.exit(1);
  }
}

// Export for library use
export {
  BinaryFramebufferEncoder,
  DrawEntryType,
  ScrollWrap,
  HScrollDirection,
  VScrollDirection,
  bitmapSizeBytes,
  setPixelInBitmap,
  isPixelSetInBitmap,
  createAnimationBinary,
  LoadImageFunction,
};

// Run if executed directly
if (import.meta.main) {
  main();
}