/// This object coordinate UI events and options with the scanner connector
Prok_HardwareManager_LabelPrinterManager = function () {
    let _selectedPrinterName = "";
    let _selectedPrinterType = null;

    /// Connector Methods

    let _sendCommand = async function (command, variables) {
        let response = await fetch(Prok_HardwareManager_MainManager.GetConnectorUrl("LabelPrinterConnector") + command + "?" + new URLSearchParams(variables));
        let responseJson = await response.json();
        return responseJson;
    };

    let _heartBeat = async function () {
        const response = await _sendCommand("/HeartBeat", {});
        return response;
    }

    let _getListPrintersCommand = async function () {
        const response = await _sendCommand("/ListPrinters", {});
        return response;
    }
    let _selectPrinterCommand = async function (printerType, printerName) {
        const response = await _sendCommand("/SelectPrinter", {
            printerType: printerType,
            printerName: printerName,
        });
        return response;
    }
    let _printLabelCommand = async function (labelCode) {
        const response = await _sendCommand("/PrintLabel", {
            labelCode: labelCode,
        });
        return response;
    }

    /// Tries to connect with the scanner driver and initialize the driver depending on the status
    /// This manager "assumes" HardwareManagerConnector is running, and so, doesn't check for it or try to start it
    let _initializeLabelPrinter = async function () {
        let mainProcessResult = await Prok_HardwareManager_MainManager.CheckMainConnectorProcess();
        if (mainProcessResult.HasErrors) {
            Prok_UIHelpers_Messages.ShowWait("Intentando iniciar el manejador de hardware...");
            await Prok_HardwareManager_MainManager.StartMainConnector();
            mainProcessResult = await Prok_HardwareManager_MainManager.CheckMainConnectorProcess();
            if (mainProcessResult.HasErrors) {
                Prok_UIHelpers_Messages.ShowWarning("Se ha iniciado el manejador de hardware");
                return await _initializeLabelPrinter();
            } else {
                Prok_UIHelpers_Messages.ShowError("No se ha podido iniciar el manejador de hardware, intente iniciarlo manualmente");
            }
        } else {
            Prok_UIHelpers_Messages.ShowWait("Conectando con la impresora de etiquetas...");
            let getServiceResult = await Prok_HardwareManager_MainManager.GetService("LabelPrinterConnector");
            if (getServiceResult.HasErrors) {
                Prok_UIHelpers_Messages.ShowError("No se ha podido iniciar el conector de impresión de etiquetas");
            } else {
                Prok_UIHelpers_Messages.ShowSuccess("Conector de impresión de etiquetas iniciado correctamente");
                _selectedPrinterName = localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterName");
                _selectedPrinterType = localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterType");
            }
            return getServiceResult;
        }
    }

    let _printLabel = async function (labelCode) {
        let hasErrors = false;
        let checkStatusResponse = await Prok_HardwareManager_MainManager.CheckConnectorProcess("LabelPrinterConnector");
        if (checkStatusResponse.HasErrors) {
            let initializeResponse = await Prok_HardwareManager_LabelPrinterManager.InitializeLabelPrinter();
            if (initializeResponse.HasErrors) {
                Prok_UIHelpers_Messages.ShowError("No se ha podido inicializar la impresora");
                Prok_Debugger_ConsoleDebugger.AddLog("_printLabel", initializeResponse);
                hasErrors = true;
            }
        }
        if (!hasErrors) { 
            let selectPrinterResponse = await _selectDefaultPrinter();
            if (selectPrinterResponse.HasErrors) {
                Prok_UIHelpers_Messages.ShowError("No se ha podido seleccionar la impresora");
                Prok_Debugger_ConsoleDebugger.AddLog("_printLabel", selectPrinterResponse);
                hasErrors = true;
                return selectPrinterResponse;
            } else {
                return await _printLabelCommand(labelCode);
            }
        }
    }


    let _printPostmailSticker = async function (docDocumentoId) {
        let results = await fetch("/DataDoc/Hardware/Stickers/GenerarStickerRadicadoCorrespondencia?docDocumentoId=" + docDocumentoId + "&tipoImpresora=" + _getSelectedPrinterType());
        let resultsText = await results.text();
        return await _printLabel(resultsText.replace(/\n/g, `
`));
    }

    let _printDocumentSticker = async function (codigoDocumento) {
        let results = await fetch("/DataDoc/Hardware/Stickers/GenerarStickerDocumento?codigoDocumento=" + codigoDocumento + "&tipoImpresora=" + _getSelectedPrinterType());
        let resultsText = await results.text();
        return await _printLabel(resultsText.replace(/\n/g, `
`));
    }
    let _printBoxSticker = async function (docCajaAlmacenamientoId) {
        let results = await fetch("/DataDoc/Hardware/Stickers/GenerarStickerCaja?docCajaAlmacenamientoId=" + docCajaAlmacenamientoId + "&tipoImpresora=" + _getSelectedPrinterType());
        let resultsText = await results.text();
        return await _printLabel(resultsText.replace(/\n/g, `
`));
    }

    let _printFolderSticker = async function (docTomoDocumentoId) {
        let results = await fetch("/DataDoc/Hardware/Stickers/GenerarStickerTomo?docTomoDocumentoId=" + docTomoDocumentoId + "&tipoImpresora=" + _getSelectedPrinterType());
        let resultsText = await results.text();
        return await _printLabel(resultsText.replace(/\n/g, `
`));
    }


    let _getListPrinters = async function () {
        return await _getListPrintersCommand();
    }

    let _selectDefaultPrinter = async function () {
        if (!localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterName")
            || !localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterType")) {
            Prok_HardwareManager_MainManager.OpenPreferencesWindow();
            return { HasErrors: true, ResponseContent: "No se ha seleccionado una impresora" };
        } else {
            let selectPrinterResponse = await _selectPrinter(localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterType"), localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterName"));
            return selectPrinterResponse;
        }
    }
    let _selectPrinter = async function (printerType, printerName) {
        _selectedPrinterName = printerName;
        _selectedPrinterType = printerType;
        localStorage.setItem("Prok.LabelPrinterManager.SelectedPrinterName", printerName);
        localStorage.setItem("Prok.LabelPrinterManager.SelectedPrinterType", printerType);
        let selectPrinterReponse = await _selectPrinterCommand(printerType, printerName);
        return selectPrinterReponse;
    }
    let _getSelectedPrinterName = function () {
        if (!_selectedPrinterName) {
            _selectedPrinterName = localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterName");
        }
        return _selectedPrinterName;
    }
    let _getSelectedPrinterType = function () {
        if (_selectedPrinterType == null) {
            _selectedPrinterType = localStorage.getItem("Prok.LabelPrinterManager.SelectedPrinterType");
        }
        return _selectedPrinterType;
    }

    return { /// Public methods
        InitializeLabelPrinter: _initializeLabelPrinter,
        GetListPrinters: _getListPrinters,
        SelectPrinter: _selectPrinter,
        GetSelectedPrinterName: _getSelectedPrinterName,
        GetSelectedPrinterType: _getSelectedPrinterType,
        PrintLabel: _printLabel,
        PrintPostmailSticker: _printPostmailSticker,
        PrintDocumentSticker: _printDocumentSticker,
        PrintBoxSticker: _printBoxSticker,
        PrintFolderSticker: _printFolderSticker,
    }
}();