import { loadDeviceConfig, loadProtocolConfig, saveDeviceConfig, saveProtocolConfig } from './api.js';
import { createNavigation } from './navigation.js';
import { createDeviceDataController } from './device/deviceData.js';
import { bindDeviceFileActions, bindProtocolFileActions } from './device/deviceFile.js';
import { createSsidController } from './device/ssid.js';
import { createCanController } from './protocol/can.js';
import { createModbusController } from './protocol/modbus.js';
import { createOpcUaController } from './protocol/opcua.js';
import { createProtocolDataController } from './protocol/protocolData.js';
import { isValidRegisterConfig } from './protocol/protocolValidation.js';
import { byId, queryAll } from './utils/dom.js';

async function initializeApp() {
    const navigation = createNavigation();
    const ssidController = createSsidController({
        listElement: byId('ssid-list'),
        templateElement: byId('ssid-template'),
        addButton: byId('add-ssid'),
        countryCodeInput: byId('wifi_country_code'),
    });

    const deviceController = createDeviceDataController({ ssidController });
    const protocolController = createProtocolDataController({
        navigation,
        modbusController: createModbusController(),
        opcUaController: createOpcUaController(),
        canController: createCanController(),
    });

    navigation.initialize();
    ssidController.bindEvents();
    deviceController.initialize();
    protocolController.initialize();

    bindDeviceFileActions({
        onLoadLocal: (data) => deviceController.loadFromData(data),
        getDownloadData: () => deviceController.collectDeviceData(),
    });

    bindProtocolFileActions({
        onLoadLocal: (data) => {
            if (!isValidRegisterConfig(data)) {
                alert('The contents of the selected file are not in a valid protocol setting file format.');
                return;
            }

            protocolController.loadFromRegisterJson(data);
        },
        getDownloadData: () => protocolController.collectProtocolData(),
    });

    queryAll('.save-file').forEach((button) => {
        button.addEventListener('click', async () => {
            const devicePayload = deviceController.collectDeviceData();
            const protocolPayload = protocolController.normalizeRegisterForPost(
                protocolController.collectProtocolData(),
            );

            if (!isValidRegisterConfig(protocolPayload)) {
                alert('Register settings are currently invalid. Cannot be saved.');
                return;
            }

            try {
                const [deviceResponse, protocolResponse] = await Promise.all([
                    saveDeviceConfig(devicePayload),
                    saveProtocolConfig(protocolPayload),
                ]);

                if (deviceResponse.ok && protocolResponse.ok) {
                    alert('saved successfully');
                    return;
                }

                alert('save failure');
                console.error('device response:', deviceResponse.status, 'protocol response:', protocolResponse.status);
            } catch (error) {
                console.error('Error during transfer:', error);
                alert('save failure');
            }
        });
    });

    try {
        const deviceData = await loadDeviceConfig();
        if (deviceData) {
            deviceController.loadFromData(deviceData);
        }
    } catch (error) {
        console.error('Device load failed:', error);
    }

    try {
        const protocolData = await loadProtocolConfig();
        if (protocolData) {
            protocolController.loadFromRegisterJson(protocolData);
        }
    } catch (error) {
        console.error('Protocol load failed:', error);
    }
}

document.addEventListener('DOMContentLoaded', initializeApp);