import type { WebRequestFilter } from 'electron'
import { app, BrowserWindow, ipcMain, session, shell } from 'electron'
import path from 'node:path'
import deeplink from './deeplink'
import { eventGetKeyChain } from './keychain'
import { AdbTcpSocket } from './adb'

// The built directory structure
//
// ├─┬─┬ dist
// │ │ └── index.html
// │ │
// │ ├─┬ dist-electron
// │ │ ├── main.js
// │ │ └── preload.js
// │
process.env.DIST = path.join(__dirname, '../dist-renderer')
process.env.VITE_PUBLIC = app.isPackaged ? process.env.DIST : path.join(process.env.DIST, '../public')

let win: BrowserWindow | null
// 🚧 Use ['ENV_NAME'] avoid vite:define plugin - Vite@2.x
const VITE_DEV_SERVER_URL = process.env['VITE_DEV_SERVER_URL']

function createWindow() {
  win = new BrowserWindow({
    icon: path.join(process.env.VITE_PUBLIC, 'electron-vite.svg'),
    webPreferences: {
      preload: path.join(__dirname, 'preload.js')
    },
    width: 1270,
    height: 720
  })

  // Test active push message to Renderer-process.
  win.webContents.on('did-finish-load', () => {
    win?.webContents.send('main-process-message', new Date().toLocaleString())
  })

  if (process.defaultApp) {
    if (process.argv.length >= 2) {
      app.setAsDefaultProtocolClient('taobin-electron', process.execPath, [path.resolve(process.argv[1])])
    }
  } else {
    app.setAsDefaultProtocolClient('taobin-electron')
  }

  let grantedDeviceThroughPermHandler: Electron.USBDevice

  win.webContents.session.on('select-usb-device', (event, details, callback) => {
    // Add events to handle devices being added or removed before the callback on
    // `select-usb-device` is called.
    win?.webContents.session.on('usb-device-added', (_event, device) => {
      console.log('usb-device-added FIRED WITH', device)
      // Optionally update details.deviceList
    })

    win?.webContents.session.on('usb-device-removed', (_event, device) => {
      console.log('usb-device-removed FIRED WITH', device)
      // Optionally update details.deviceList
    })

    event.preventDefault()
    if (details.deviceList && details.deviceList.length > 0) {
      const deviceToReturn = details.deviceList.find(device => device.vendorId === 1478)
      if (deviceToReturn) {
        callback(deviceToReturn.deviceId)
      } else {
        callback()
      }
    }
  })

  win.webContents.session.setPermissionCheckHandler((_webContents, permission) => {
    if (permission === 'usb') {
      return true
    }
    return false
  })

  win.webContents.session.setDevicePermissionHandler(details => {
    console.log(details)
    if (details.deviceType === 'usb' && details.device.vendorId == 1478) {
      if (!grantedDeviceThroughPermHandler) {
        grantedDeviceThroughPermHandler = details.device as Electron.USBDevice
        return true
      } else if (grantedDeviceThroughPermHandler.vendorId === 1478) {
        return true
      } else {
        return false
      }
    }
    return false
  })

  if (VITE_DEV_SERVER_URL) {
    win.loadURL(VITE_DEV_SERVER_URL)
  } else {
    // win.loadFile('dist/index.html')
    win.loadFile(path.join(process.env.DIST, 'index.html'))
  }
}

// Quit when all windows are closed, except on macOS. There, it's common
// for applications and their menu bar to stay active until the user quits
// explicitly with Cmd + Q.
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit()
    win = null
  }
})

app.on('activate', () => {
  // On OS X it's common to re-create a window in the app when the
  // dock icon is clicked and there are no other windows open.
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow()
  }
})

// Create MainWindow, load the rest of the app, etc...
app.whenReady().then(() => {
  createWindow()
  // deeplink
  deeplink(app, win, ipcMain, shell)

  // adb
  AdbTcpSocket(win, ipcMain)

  //keychain
  eventGetKeyChain(ipcMain)

  const filter: WebRequestFilter = {
    urls: ['http://localhost:8080/*']
  }

  session.defaultSession.webRequest.onBeforeSendHeaders(filter, (details, callback) => {
    details.requestHeaders['Origin'] = 'http://localhost:8080'
    callback({ requestHeaders: details.requestHeaders })
  })

  session.defaultSession.webRequest.onHeadersReceived(filter, (details, callback) => {
    if (details.responseHeaders) {
      details.responseHeaders['Access-Control-Allow-Origin'] = ['*']
    }
    callback({ responseHeaders: details.responseHeaders })
  })
})

process.on('unhandledRejection', () => {
  console.error('Unhandled Rejection ignoring')
  // Application specific logging, throwing an error, or other logic here
})