import nrfdlModule, {
    Device,
    Error,
    // @ts-ignore nrfdlModule Is not a module
} from '../../../../index';

require('../../../../jasmine_shared.js');
const fs = require('fs');

describe('[Jlink fw tests]', () => {
    let context = 0;
    const hex_path = './jlink_usb.hex';
    const nrf91_modem_zip_path = './mfw_nrf9160_1.2.2.zip';
    const number_of_jlink_devices = 1;
    const number_of_jlink_devices_program_from_file = 1;
    const number_of_jlink_devices_program_from_buffer = 1;
    const number_of_jlink_devices_get_protection_status = 1;

    let devicesList: Device = [];

    jasmine.DEFAULT_TIMEOUT_INTERVAL = number_of_jlink_devices * 100000;

    beforeAll(async () => {
        context = nrfdlModule.createContext();

        const result = await nrfdlModule.enumerate(context);

        expect(result.length).toBeGreaterThan(0);

        devicesList = result
            .filter((el: Device) => el.traits.jlink)
            .map(async (device: Device) => {
                await nrfdlModule.deviceControlRecover(context, device.id);
                return device;
            });

        devicesList = await Promise.all(devicesList);
    });

    afterAll(() => {
        nrfdlModule.releaseContext(context);
    });

    it('Test jlink program from file', async () => {
        let devices = devicesList.filter((el: Device) => {
            return el.traits.jlink && el.jlink.boardVersion === 'PCA10056';
        });

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices_program_from_file);
        devices = devices.slice(0, number_of_jlink_devices_program_from_file);

        await Promise.all(
            devices.map(
                (dev: Device) =>
                    new Promise<void>((resolve, reject) =>
                        nrfdlModule.firmwareProgram(
                            context,
                            dev.id,
                            nrfdlModule.NRFDL_FW_FILE,
                            nrfdlModule.NRFDL_FW_INTEL_HEX,
                            hex_path,
                            (err?: Error) => {
                                if (err) reject(err);
                                resolve();
                            },
                            () => {}
                        )
                    )
            )
        );
    });

    it('Test jlink program from buffer', async () => {
        let devices = devicesList.filter((el: Device) => {
            return el.traits.jlink && el.jlink.boardVersion === 'PCA10056';
        });

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices_program_from_buffer);
        devices = devices.slice(0, number_of_jlink_devices_program_from_buffer);

        const hexBuffer = fs.readFileSync(hex_path);

        await Promise.all(
            devices.map(
                (dev: Device) =>
                    new Promise<void>((resolve, reject) =>
                        nrfdlModule.firmwareProgram(
                            context,
                            dev.id,
                            nrfdlModule.NRFDL_FW_BUFFER,
                            nrfdlModule.NRFDL_FW_INTEL_HEX,
                            hexBuffer,
                            (err?: Error) => {
                                if (err) reject(err);
                                resolve();
                            },
                            () => {}
                        )
                    )
            )
        );
    });

    it('Test jlink program modem', async () => {
        let devices = devicesList.filter((el: Device) => {
            return el.traits.jlink && el.jlink.boardVersion === 'PCA10090';
        });

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices_program_from_file);
        devices = devices.slice(0, number_of_jlink_devices_program_from_file);

        await Promise.all(
            devices.map(
                (dev: Device) =>
                    new Promise<void>((resolve, reject) =>
                        nrfdlModule.firmwareProgram(
                            context,
                            dev.id,
                            nrfdlModule.NRFDL_FW_FILE,
                            nrfdlModule.NRFDL_FW_NRF91_MODEM,
                            nrf91_modem_zip_path,
                            (err?: Error) => {
                                if (err) reject(err);
                                resolve();
                            },
                            () => {}
                        )
                    )
            )
        );
    }, 60000);

    it('Test jlink reset', async () => {
        let devices = devicesList.filter((el: Device) => {
            return el.traits.jlink;
        });

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices);

        devices = devices.slice(0, number_of_jlink_devices);

        await Promise.all(devices.map((dev: Device) => nrfdlModule.deviceControlReset(context, dev.id)));
    });

    it('Test jlink erase', async () => {
        const result = await nrfdlModule.enumerate(context);

        expect(result.length).toBeGreaterThan(0);

        let devices = result
            .filter((el: Device) => {
                return el.traits.jlink;
            })
            .map(async (device: Device) => {
                await nrfdlModule.deviceControlRecover(context, device.id);
                return device;
            });

        devices = await Promise.all(devices);

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices);

        devices = devices.slice(0, number_of_jlink_devices);
        await Promise.all(devices.map((dev: Device) => nrfdlModule.firmwareErase(context, dev.id)));
    });

    it('Test jlink get protection status', async () => {
        let devices = devicesList.filter((el: Device) => {
            return el.traits.jlink && el.jlink.boardVersion === 'PCA10056';
        });

        expect(devices.length).toBeGreaterThanOrEqual(number_of_jlink_devices_get_protection_status);

        devices = devices.slice(0, number_of_jlink_devices_get_protection_status);
        await Promise.all(devices.map((dev: Device) => nrfdlModule.deviceControlGetProtectionStatus(context, dev.id)));
    });
});