/**
 * Vitest test setup file
 */

import '@testing-library/jest-dom'
import { vi } from 'vitest'

// Mock Tauri API for testing
vi.mock('@tauri-apps/api/core', () => ({
  invoke: vi.fn()
}))

// Mock requestAnimationFrame for Three.js tests
if (typeof globalThis.requestAnimationFrame === 'undefined') {
  globalThis.requestAnimationFrame = (callback: FrameRequestCallback): number => {
    return setTimeout(() => callback(Date.now()), 16) as unknown as number
  }
}

if (typeof globalThis.cancelAnimationFrame === 'undefined') {
  globalThis.cancelAnimationFrame = (id: number): void => {
    clearTimeout(id)
  }
}

// Mock WebGL context for Three.js
class MockWebGLRenderingContext {
  canvas = { width: 800, height: 600 }
  drawingBufferWidth = 800
  drawingBufferHeight = 600

  getExtension() { return null }
  getParameter(param: number) {
    if (param === 0x1F02) return 'WebGL 1.0' // VERSION
    if (param === 0x8B8C) return 16 // MAX_VERTEX_UNIFORM_VECTORS
    if (param === 0x8DFD) return 16 // MAX_FRAGMENT_UNIFORM_VECTORS
    if (param === 0x8869) return 16 // MAX_VERTEX_ATTRIBS
    if (param === 0x8872) return 8 // MAX_TEXTURE_IMAGE_UNITS
    if (param === 0x0D33) return 4096 // MAX_TEXTURE_SIZE
    if (param === 0x0B71) return 24 // DEPTH_BITS
    return 0
  }
  getShaderPrecisionFormat() {
    return { rangeMin: 127, rangeMax: 127, precision: 23 }
  }
  createShader() { return {} }
  shaderSource() {}
  compileShader() {}
  getShaderParameter() { return true }
  createProgram() { return {} }
  attachShader() {}
  linkProgram() {}
  getProgramParameter() { return true }
  useProgram() {}
  createBuffer() { return {} }
  bindBuffer() {}
  bufferData() {}
  createTexture() { return {} }
  bindTexture() {}
  texImage2D() {}
  texParameteri() {}
  createFramebuffer() { return {} }
  bindFramebuffer() {}
  framebufferTexture2D() {}
  createRenderbuffer() { return {} }
  bindRenderbuffer() {}
  renderbufferStorage() {}
  framebufferRenderbuffer() {}
  viewport() {}
  clear() {}
  enable() {}
  disable() {}
  blendFunc() {}
  depthFunc() {}
  cullFace() {}
  frontFace() {}
  clearColor() {}
  clearDepth() {}
  vertexAttribPointer() {}
  enableVertexAttribArray() {}
  drawArrays() {}
  drawElements() {}
  uniform1i() {}
  uniform1f() {}
  uniform2f() {}
  uniform3f() {}
  uniform4f() {}
  uniformMatrix4fv() {}
  getAttribLocation() { return 0 }
  getUniformLocation() { return {} }
  deleteShader() {}
  deleteProgram() {}
  deleteBuffer() {}
  deleteTexture() {}
  deleteFramebuffer() {}
  deleteRenderbuffer() {}
  pixelStorei() {}
  activeTexture() {}
  generateMipmap() {}
  scissor() {}
  checkFramebufferStatus() { return 0x8CD5 } // FRAMEBUFFER_COMPLETE
}

// Mock canvas getContext for WebGL
Object.defineProperty(HTMLCanvasElement.prototype, 'getContext', {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  value: function(this: HTMLCanvasElement, contextId: string): any {
    if (contextId === 'webgl' || contextId === 'webgl2' || contextId === 'experimental-webgl') {
      return new MockWebGLRenderingContext()
    }
    // For 2d context, create a simple mock
    if (contextId === '2d') {
      return {
        canvas: this,
        fillRect: () => {},
        clearRect: () => {},
        getImageData: () => ({ data: new Uint8ClampedArray(0) }),
        putImageData: () => {},
        createImageData: () => ({ data: new Uint8ClampedArray(0) }),
        setTransform: () => {},
        drawImage: () => {},
        save: () => {},
        restore: () => {},
        beginPath: () => {},
        moveTo: () => {},
        lineTo: () => {},
        closePath: () => {},
        stroke: () => {},
        fill: () => {},
        measureText: () => ({ width: 0 }),
        transform: () => {},
        scale: () => {},
        translate: () => {},
        rotate: () => {},
        arc: () => {},
        rect: () => {},
        clip: () => {},
        fillText: () => {},
        strokeText: () => {},
      }
    }
    return null
  },
  writable: true,
  configurable: true,
})

// Mock ResizeObserver
globalThis.ResizeObserver = class ResizeObserver {
  observe() {}
  unobserve() {}
  disconnect() {}
}

// Mock matchMedia
Object.defineProperty(window, 'matchMedia', {
  writable: true,
  value: vi.fn().mockImplementation((query: string) => ({
    matches: false,
    media: query,
    onchange: null,
    addListener: vi.fn(),
    removeListener: vi.fn(),
    addEventListener: vi.fn(),
    removeEventListener: vi.fn(),
    dispatchEvent: vi.fn(),
  })),
})

// Suppress console errors for expected test failures
const originalError = console.error
console.error = (...args: unknown[]) => {
  const message = typeof args[0] === 'string' ? args[0] : ''
  // Suppress expected React Three Fiber warnings in tests
  if (
    message.includes('ReactDOM.render is no longer supported') ||
    message.includes('Warning: An update to') ||
    message.includes('THREE.WebGLRenderer')
  ) {
    return
  }
  originalError.apply(console, args)
}