const createHybridObject = jest.fn()
jest.mock('react-native-nitro-modules', () => ({
  NitroModules: {
    createHybridObject: (...a: unknown[]) => createHybridObject(...a),
  },
}))
jest.mock('react-native', () => ({ Platform: { OS: 'android' } }))

import { Platform } from 'react-native'

const loadModule = () => {
  let mod: typeof import('../index')
  jest.isolateModules(() => {
    mod = require('../index')
  })
  // @ts-expect-error assigned in isolateModules
  return mod
}

describe('react-native-nitro-chucker', () => {
  const native = {
    isSupported: true,
    show: jest.fn(),
    clearLogs: jest.fn(),
    dismiss: jest.fn(),
    setEnabled: jest.fn(),
    setMaxLogCount: jest.fn(),
    setIgnoredHosts: jest.fn(),
  }
  beforeEach(() => {
    jest.clearAllMocks()
    ;(Platform as { OS: string }).OS = 'android'
    createHybridObject.mockReturnValue(native)
  })

  it('isSupported is true on android when native is linked', () => {
    expect(loadModule().isSupported()).toBe(true)
  })

  it('isSupported is false on web', () => {
    ;(Platform as { OS: string }).OS = 'web'
    expect(loadModule().isSupported()).toBe(false)
    expect(createHybridObject).not.toHaveBeenCalled()
  })

  it('isSupported is false (no throw) when native module is not linked', () => {
    createHybridObject.mockImplementation(() => {
      throw new Error('not linked')
    })
    expect(loadModule().isSupported()).toBe(false)
  })

  it('action calls are silent no-ops when native is stripped on a supported platform', () => {
    ;(Platform as { OS: string }).OS = 'android'
    createHybridObject.mockImplementation(() => {
      throw new Error('not linked')
    })
    const m = loadModule()
    expect(() => {
      m.show()
      m.clearLogs()
      m.dismiss()
      m.setEnabled(true)
      m.setMaxLogCount(200)
      m.setIgnoredHosts(['cdn.example.com'])
    }).not.toThrow()
    expect(m.isSupported()).toBe(false)
  })

  it('delegates show/clearLogs/dismiss to the native hybrid', () => {
    const m = loadModule()
    m.show()
    m.clearLogs()
    m.dismiss()
    expect(native.show).toHaveBeenCalledTimes(1)
    expect(native.clearLogs).toHaveBeenCalledTimes(1)
    expect(native.dismiss).toHaveBeenCalledTimes(1)
  })

  it('setEnabled forwards its argument', () => {
    loadModule().setEnabled(false)
    expect(native.setEnabled).toHaveBeenCalledWith(false)
  })

  it('setMaxLogCount forwards its argument', () => {
    loadModule().setMaxLogCount(50)
    expect(native.setMaxLogCount).toHaveBeenCalledWith(50)
  })

  it('setMaxLogCount forwards 0 (unlimited) rather than dropping it', () => {
    loadModule().setMaxLogCount(0)
    expect(native.setMaxLogCount).toHaveBeenCalledWith(0)
  })

  it('setIgnoredHosts forwards the host list', () => {
    loadModule().setIgnoredHosts(['cdn.example.com', 'video.example.com'])
    expect(native.setIgnoredHosts).toHaveBeenCalledWith([
      'cdn.example.com',
      'video.example.com',
    ])
  })

  it('action calls are silent no-ops on an unsupported platform', () => {
    ;(Platform as { OS: string }).OS = 'web'
    const m = loadModule()
    expect(() => {
      m.show()
      m.clearLogs()
      m.dismiss()
      m.setEnabled(true)
    }).not.toThrow()
    expect(native.show).not.toHaveBeenCalled()
  })

  it('caches the hybrid object across calls', () => {
    const m = loadModule()
    m.show()
    m.show()
    expect(createHybridObject).toHaveBeenCalledTimes(1)
  })
})