import { expect } from 'chai'
import * as cp from 'child_process'
import { BrowserWindow, BrowserWindowConstructorOptions, ipcMain } from 'electron'
import * as path from 'path'

import { emittedOnce } from './events-helpers'
import { closeWindow } from './window-helpers'
import { ifdescribe, delay } from './spec-helpers'

// visibilityState specs pass on linux with a real window manager but on CI
// the environment does not let these specs pass
ifdescribe(process.platform !== 'linux')('document.visibilityState', () => {
  let w: BrowserWindow

  afterEach(() => {
    return closeWindow(w)
  })

  const load = () => w.loadFile(path.resolve(__dirname, 'fixtures', 'chromium', 'visibilitystate.html'))

  const itWithOptions = (name: string, options: BrowserWindowConstructorOptions, fn: Mocha.Func) => {
    return it(name, async function (...args) {
      // document.visibilityState tests are very flaky, this is probably because
      // Electron implements it via async IPC messages.
      this.retries(3)

      w = new BrowserWindow({
        ...options,
        paintWhenInitiallyHidden: false,
        webPreferences: {
          ...(options.webPreferences || {}),
          nodeIntegration: true
        }
      })
      await Promise.resolve(fn.apply(this, args))
    })
  }

  const getVisibilityState = async (): Promise<string> => {
    const response = emittedOnce(ipcMain, 'visibility-state')
    w.webContents.send('get-visibility-state')
    return (await response)[1]
  }

  itWithOptions('should be visible when the window is initially shown by default', {}, async () => {
    await load()
    const state = await getVisibilityState()
    expect(state).to.equal('visible')
  })

  itWithOptions('should be visible when the window is initially shown', {
    show: true
  }, async () => {
    await load()
    const state = await getVisibilityState()
    expect(state).to.equal('visible')
  })

  itWithOptions('should be hidden when the window is initially hidden', {
    show: false
  }, async () => {
    await load()
    const state = await getVisibilityState()
    expect(state).to.equal('hidden')
  })

  itWithOptions('should be visible when the window is initially hidden but shown before the page is loaded', {
    show: false
  }, async () => {
    w.show()
    await load()
    const state = await getVisibilityState()
    expect(state).to.equal('visible')
  })

  itWithOptions('should be hidden when the window is initially shown but hidden before the page is loaded', {
    show: true
  }, async () => {
    // TODO(MarshallOfSound): Figure out if we can work around this 1 tick issue for users
    if (process.platform === 'darwin') {
      // Wait for a tick, the window being "shown" takes 1 tick on macOS
      await delay(0)
    }
    w.hide()
    await load()
    const state = await getVisibilityState()
    expect(state).to.equal('hidden')
  })

  itWithOptions('should be toggle between visible and hidden as the window is hidden and shown', {}, async () => {
    await load()
    expect(await getVisibilityState()).to.equal('visible')
    await emittedOnce(ipcMain, 'visibility-change', () => w.hide())
    expect(await getVisibilityState()).to.equal('hidden')
    await emittedOnce(ipcMain, 'visibility-change', () => w.show())
    expect(await getVisibilityState()).to.equal('visible')
  })

  itWithOptions('should become hidden when a window is minimized', {}, async () => {
    await load()
    expect(await getVisibilityState()).to.equal('visible')
    await emittedOnce(ipcMain, 'visibility-change', () => w.minimize())
    expect(await getVisibilityState()).to.equal('hidden')
  })

  itWithOptions('should become visible when a window is restored', {}, async () => {
    await load()
    expect(await getVisibilityState()).to.equal('visible')
    await emittedOnce(ipcMain, 'visibility-change', () => w.minimize())
    await emittedOnce(ipcMain, 'visibility-change', () => w.restore())
    expect(await getVisibilityState()).to.equal('visible')
  })

  describe('on platforms that support occlusion detection', () => {
    let child: cp.ChildProcess

    before(function () {
      if (process.platform !== 'darwin') this.skip()
    })

    const makeOtherWindow = (opts: { x: number; y: number; width: number; height: number; }) => {
      child = cp.spawn(process.execPath, [path.resolve(__dirname, 'fixtures', 'chromium', 'other-window.js'), `${opts.x}`, `${opts.y}`, `${opts.width}`, `${opts.height}`])
      return new Promise(resolve => {
        child.stdout!.on('data', (chunk) => {
          if (chunk.toString().includes('__ready__')) resolve()
        })
      })
    }

    afterEach(() => {
      if (child && !child.killed) {
        child.kill('SIGTERM')
      }
    })

    itWithOptions('should be visible when two windows are on screen', {
      x: 0,
      y: 0,
      width: 200,
      height: 200
    }, async () => {
      await makeOtherWindow({
        x: 200,
        y: 0,
        width: 200,
        height: 200
      })
      await load()
      const state = await getVisibilityState()
      expect(state).to.equal('visible')
    })

    itWithOptions('should be visible when two windows are on screen that overlap partially', {
      x: 50,
      y: 50,
      width: 150,
      height: 150
    }, async () => {
      await makeOtherWindow({
        x: 100,
        y: 0,
        width: 200,
        height: 200
      })
      await load()
      const state = await getVisibilityState()
      expect(state).to.equal('visible')
    })

    itWithOptions('should be hidden when a second window completely conceals the current window', {
      x: 50,
      y: 50,
      width: 50,
      height: 50
    }, async function () {
      this.timeout(240000)
      await load()
      await emittedOnce(ipcMain, 'visibility-change', async () => {
        await makeOtherWindow({
          x: 0,
          y: 0,
          width: 300,
          height: 300
        })
      })
      const state = await getVisibilityState()
      expect(state).to.equal('hidden')
    })
  })
})
