/* globals require, __dirname, process */
/*eslint no-console: ["error", { allow: ["log"] }]*/

const { app, BrowserWindow, BrowserView, ipcMain, dialog, shell } = require('electron')
const electronLocalshortcut = require('electron-localshortcut')
//const electron = require('electron')
const os = require('os')
const fs = require('fs')
const path = require('path')
const { URL } = require('url')
const Store = require('./store.js')
const { prettyPrint } = require('html')

// Use this constant to start the application in kiosk-mode or in development mode
const DEVELOPMENT = true
// true: Dev-Tools are open
// false (KIOSK-Mode): No application switcher, no menu, no taskbar (or dock on a mac), shortcuts are working

global.multiUserMode = true
global.errorCount = 0
global.stopTestsOnError = false
global.jsonData = { value: null }
// UO: Experimental feature using Native Windows
global.useBrowserView = false
global.useMinimalPad = true
global.menu = null
global.observeTraffic = false

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let win
let browsers = new Map() // url: BrowserWindow

const store = new Store({
    // We'll call our data file 'user-preferences'
    configName: 'user-preferences',
    defaults: {
        url: `file://${__dirname}/index.html`,
        devTools: DEVELOPMENT,
        multiUserBrowser: true
    }
})

function createWindow() {

    if (global.observeTraffic) {
        const {session} = require('electron')
        session.defaultSession.webRequest.onCompleted((details) => {
            console.log("onCompleted", details.url)
        }) 
    }
    let { screen } = require('electron')
    
    let bounds = store.get('storedBounds')
        ? store.get('storedBounds')
        : screen.getPrimaryDisplay().bounds

    //    let displays = screen.getAllDisplays()
    //    let externalDisplay = null

    //    externalDisplay = displays[displays.length-1]
    //    const {width, height} =displays[displays.length-1].workAreaSize

    //    externalDisplay = displays[0]
    //    const {width, height} =displays[0].workAreaSize

    win = new BrowserWindow({
        x: bounds.x,
        y: bounds.y,
        width: bounds.width,
        height: bounds.height,
        fullscreenable: true,
        fullscreen: !DEVELOPMENT,
        title: 'IWM Browser',
        show: false,
        kiosk: !DEVELOPMENT,
        acceptFirstMouse: true,
        webPreferences: {
            webSecurity: false,
            allowRunningInsecureContent: true,
            nodeIntegration: true,
            webviewTag: true,
            nativeWindowOpen: true,
            devTools: true,
            preload: path.join(__dirname, './preload.js')
        },
        icon: path.join(__dirname, 'assets/icons/png/64x64.png')
    })

    module.exports.win = win

    let url = store.get('url')
    if (process.argv.length > 2) {
        let path = process.argv[2]
        url = `file://${__dirname}/../${path}`
        console.log('Using process.argv[2]', url)
    }
    console.log('Using', url)
    win.maximize()

    // BAD: All other methods don't work (like ensureFileSync, fileExists...)
    try {
        let settings = require('./settings.json')
        console.log('Using settings', `file://${__dirname}/${settings.url}`)
        win.loadURL(`file://${__dirname}/${settings.url}`)
    } catch (ex) {
        win.loadURL(url)
    }

    const { webContents } = win
    //
    //     if (process.platform === 'win32' && win.isKiosk()) {
    //         webContents.on('did-finish-load', function() {
    //             webContents.executeJavaScript('document.body.style.cursor = "none";')
    //         })
    //     }

    // Add the app menu
    let menu = require('./menu.js')
    global.menu = menu

    // Add global shortcuts
    // Esc quits the app
    electronLocalshortcut.register('Esc', () => {
        app.quit()
    })

    // Command (Mac) or Control (Win) + K toggles the Kiosk mode
    electronLocalshortcut.register('CommandOrControl+K', () => {
        if (win) {
            win.setKiosk(!win.isKiosk())
        }
    })

    // Show if its ready.
    win.once('ready-to-show', () => {
        webContents.send('preparePads')
        win.show()
    })

    // Clear cache
    webContents.session.clearCache(() => console.log('Cache cleared'))

    // Open dev tools when in development mode
    if (store.get('devTools')) {
        webContents.openDevTools({ mode: 'right' })
    } else {
        webContents.closeDevTools()
    }

    webContents.on('devtools-opened', () => {
        store.set('devTools', true)
    })

    webContents.on('devtools-closed', () => {
        store.set('devTools', false)
    })

    webContents.on('did-navigate', (event, url) => {
        menu.setHistoryStatus()
    })

    /* UO: At this point we have no access to the event or link position*/

    webContents.on('new-window', (event, url, frameName, disposition, options, additionalFeatures) => {
        console.log('new-window', global.multiUserMode)
        if (global.multiUserMode) {
            event.preventDefault()
            webContents.send('newPad', url, options.x, options.y)
        }
    })

    // WORKAROUND: On windows, if the app was set to fullscreen, the menubar is not hidden
    if (win.isKiosk()) {
        win.setMenuBarVisibility(false)
    }

    win.on('focus', event => {
        menu.focus()
    })

    win.on('blur', event => {
        menu.blur()
    })

    win.on('enter-full-screen', () => {
        win.setMenuBarVisibility(false)
    })

    win.on('leave-full-screen', () => {
        win.setMenuBarVisibility(true)
    })

    win.on('enter-html-full-screen', () => {
        win.setMenuBarVisibility(false)
    })

    win.on('leave-html-full-screen', () => {
        win.setMenuBarVisibility(true)
    })
    win.on('close', () => {
        store.set('storedBounds', win.getBounds())
    })

    // Emitted when the window is closed.
    win.on('closed', () => {
        app.quit()
    })
}

// When work makes progress, show the progress bar
function onProgress(progress) {
    // Use values 0 to 1, or -1 to hide the progress bar
    try {
        win.setProgressBar(progress || -1) // Progress bar works on all platforms
    } catch (e) {
        if (DEVELOPMENT) console.log(e.message)
    }
}

function trySend(target, ...args) {
    try {
        target.send(...args)
    } catch (e) {
        if (DEVELOPMENT) console.log(e.message)
    }
}

function openBrowserView(url, x, y) {
    const useMinBrowser = false // Change this to switch between Min and a custom browser

    const minURL = 'file:///Users/uo/devel/min/index.html'
    const browserURL = `file://${__dirname}/browser.html`
    let width = 640
    let height = 1200
    let [winWidth, winHeight] = win.getSize()
    if (x + width > winWidth) {
        x = winWidth - width
    }
    if (y + height > winHeight) {
        y = winHeight - height
    }
    console.log('open browser view')
    let browser = new BrowserWindow({
        x,
        y,
        width,
        height,
        minWidth: 320,
        minHeight: 350,
        titleBarStyle: useMinBrowser ? 'hidden-inset' : 'hidden',
        frame: process.platform !== 'win32'
    })
    let browserContents = browser.webContents
    browser.setAlwaysOnTop(true)
    if (useMinBrowser) {
        browserContents.on('did-finish-load', event => {
            console.log('did-finish-load', browserContents.getURL())

            browserContents.executeJavaScript(
                'Object.values(window.webviews.elementMap).map(obj => obj.src)',
                result => {
                    console.log(
                        'window.webviews',
                        result,
                        url,
                        result.indexOf(url)
                    )
                    if (result.indexOf(url) == -1) {
                        console.log('Adding tab')
                        browserContents.send('addTab', { url })
                    }
                }
            )
        })
        browser.loadURL(minURL)
    } else {
        console.log('Loading', browserURL)
        browser.loadURL(browserURL)
        let view = new BrowserView({
            webPreferences: {
                nodeIntegration: false,
                devTools: true
            }
        })
        //browserContents.openDevTools({mode: 'right'})

        browser.setBrowserView(view)
        view.setBounds({ x: 0, y: 24, width: width, height: height - 24 })
        view.setAutoResize({ width: true, height: true })

        let viewContents = view.webContents
        let progress = 0

        viewContents.on('page-title-set', event => {
            console.log('page-title-set', event)
        })
        viewContents.on('page-favicon-updated', (event, favicons) => {
            //console.log("page-favicon-updated", event, favicons)
            trySend(browserContents, 'favicons', favicons)
        })

        viewContents.on('did-start-loading', event => {
            onProgress(0)
            trySend(browserContents, 'progress', 0)
            trySend(browserContents, 'did-start-loading')
            //let senderURL = event.sender.getURL() || url
            //console.log('did-start-loading', senderURL)
        })
        viewContents.on(
            'did-get-response-details',
            (
                event,
                status,
                newURL,
                originalURL,
                httpResponseCode,
                requestMethod,
                referrer,
                headers,
                resourceType
            ) => {
                trySend(browserContents, 'did-get-response-details', {
                    status,
                    newURL,
                    originalURL,
                    httpResponseCode,
                    requestMethod,
                    referrer,
                    headers,
                    resourceType
                })
                progress += 0.01
                onProgress(progress)
                trySend(browserContents, 'progress', progress)
                //console.log('did-get-response-details', newURL)
            }
        )
        viewContents.on(
            'did-get-redirect-request',
            (
                event,
                oldURL,
                newURL,
                isMainFrame,
                httpResponseCode,
                requestMethod,
                referrer,
                headers
            ) => {
                trySend(browserContents, 'did-get-redirect-request', {
                    oldURL,
                    newURL,
                    isMainFrame,
                    httpResponseCode,
                    requestMethod,
                    referrer,
                    headers
                })
                //console.log('did-get-redirect-request', newURL)
            }
        )
        viewContents.on('did-stop-loading', event => {
            //console.log('did-stop-loading', event.sender.getURL())
            trySend(browserContents, 'did-stop-loading')
        })
        viewContents.on('did-finish-load', event => {
            //console.log('did-finish-load', event.sender.getURL())
            progress = 1
            onProgress(progress)
            trySend(browserContents, 'progress', progress)
        })
        viewContents.on('dom-ready', event => {
            if (progress < 0.5) {
                progress = 0.5
                onProgress(progress)
                trySend(browserContents, 'progress', progress)
            }
            viewContents.executeJavaScript('document.title', result => {
                trySend(browserContents, 'title', result)
            })

            //console.log('dom-ready', event.sender.getURL())
        })

        viewContents.on('new-window', function (event, url) {
            event.preventDefault()
            console.log('new-window')
            openBrowserView(url, x, y)
        })

        viewContents.loadURL(url)
    }
    browsers.set(url, browser)
    browser.on('closed', e => {
        for (let [url, browser] of browsers.entries()) {
            if (browser == e.sender) {
                browsers.delete(url)
                console.log('removed browser view', url)
            }
        }
    })
}

// UO: Experimental call. Opens a Min Browser window or a limited window with a browser view
ipcMain.on('loadBrowserView', (e, opts = {}) => {
    let { url, x, y } = opts
    openBrowserView(url, x, y)
})

ipcMain.on('multiUserMode', (e, opts = {}) => {
    global.multiUserMode = opts
})

ipcMain.on('padContainerLoaded', e => {
    win.webContents.send('padContainerAvailable')
})

ipcMain.on('createScreenshot', (e, opts = {}) => {
    opts = Object.assign(
        {},
        {
            name: `iwmbrowser-${new Date()
                .toISOString()
                .replace(/:/g, '-')}.png`,
            path: os.tmpdir()
        },
        opts
    )

    win.webContents.capturePage(image => {
        if (image) {
            let file = path.join(opts.path, opts.name)
            fs.writeFile(file, image.toPNG(), err => {
                if (err) {
                    //throw err
                } else {
                    console.log(`Screenshot saved: ${file}`)
                }
            })
        }
    })
})

ipcMain.on('directoryListing', (e, opts = {}) => {
    let { directory, files, folders } = opts
    console.log("directoryListing", opts)
    try {
        let listing = fs.readdirSync(directory)
        let result = { directory, files: [], folders: [] }
        for (let name of listing) {
            if (name.startsWith('.'))
                continue
            let fullPath = path.join(directory, name)
            let stat = fs.lstatSync(fullPath)
            if (files && stat.isFile()) {
                if (typeof files == 'string' && !files.endsWith(files))
                    continue
                result.files.push(name)
            }
            if (folders && stat.isDirectory())
                result.folders.push(name)
        }
        e.sender.send('directoryListing', result)
    } catch (err) {
        let args = { directory, errorMessage: err.message}
        e.sender.send('directoryListingError', args)
    }
})

ipcMain.on('createTextfile', (e, opts = {}) => {
    opts = Object.assign(
        {},
        {
            name: `iwmbrowser-${new Date()
                .toISOString()
                .replace(/:/g, '-')}.txt`,
            path: os.tmpdir(),
            text: ''
        },
        opts
    )
    let file = path.join(opts.path, opts.name)
    fs.writeFile(file, opts.text, err => {
        if (err) {
            //throw err
        } else {
            console.log(`Textfile saved: ${file}`)
        }
    })
})

ipcMain.on('error', e => {
    console.log('Received error notification')
    global.errorCount += 1
})

ipcMain.on('openExternal', (e, url=null) => {
    console.log('Received openExternal', url)
    if (url) {
        shell.openExternal(url)
    }
})

ipcMain.on('save', (e, opts = {}) => {
    let { url, html, saveAs, action } = opts
    // url must absolute URL
    let urlObj = new URL(url)
    let pathname = urlObj.pathname
    if (saveAs) {
        pathname = dialog.showSaveDialog(win, { title: 'Save as:', defaultPath: pathname })
        if (typeof pathname == 'undefined')
            return
    }
    try {
        console.log("Saving", pathname, action)
        html = prettyPrint(html, { indent_size: 4 });
        fs.writeFileSync(pathname, html, 'utf-8')
        if (saveAs) {
            let normalized = pathname.replace(/\\/g, '/')
            e.sender.send('savedAs', {url: `file://${normalized}`, action})
        }
    }
    catch (e) {
        console.warn('Failed to save the file', pathname)
        e.sender.send('saveFailed', pathname)
    }

})

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', createWindow)

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

app.on(
    'select-client-certificate',
    (event, webContents, url, list, callback) => {
        console.log('select-client-certificate', url, list)
        event.preventDefault()
        ipc.once('client-certificate-selected', (event, item) => {
            console.log('selected:', item)
            callback(item)
        })
        mainWindow.webContents.send('select-client-certificate', list)
    }
)

app.on(
    'certificate-error',
    (event, webContents, url, error, certificate, callback) => {
        console.log('certificate-error', url)
        event.preventDefault()
        const result = true // TODO: do real validation here
        callback(result)
    }
)

app.on('activate', () => {
    // On macOS 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 (win === null) {
        createWindow()
    }
})

module.exports = {
    store: store
}