IntegrySmartIndustry/ISG - Gramm (L6)/Core/Service/EidosPrinterCollectorService.cs

using Integry_Smart_Gateway.Core.ExternalCom.Contracts;
using Integry_Smart_Gateway.Core.ExternalCom.Model;
using Integry_Smart_Gateway.Core.ExternalCom.Protocols.Socket;
using Integry_Smart_Gateway.Core.Logger;
using Integry_Smart_Gateway.Core.Machine.Contracts;
using Integry_Smart_Gateway.Core.MachineConnections.Contracts;
using Integry_Smart_Gateway.Core.Utility;
using ISG___Gramm__L6_.Core.Model;
using ISG___Gramm__L6_.Core.Service.Contracts;

namespace ISG___Gramm__L6_.Core.Service;

public class EidosPrinterCollectorService(
	ILoggerService loggerService,
	IMachineLoggerService machineLoggerService,
	IMachineConnectionsService machineConnectionsService,
	string uri,
	int port,
	string codCmac)
	: SocketConnector(codCmac, uri, port, loggerService, machineLoggerService), IEidosPrinterCollectorService
{
    public const string GET_PRINTER_STATE_COMMAND = "^?\r\n";
    public const string RESET_BUFFER_COMMAND = "^@\r\n";
    public const string SELECT_LABEL_COMMAND = $"^A*__LABEL_NAME__\r\n";
    public const string SET_VAR_COMMAND = $"^|i__LABEL____VAL__\r\n";
    public const string PROCESS_VAR_COMMAND = "^V\r\n";
    public const string CONFIRM_LABEL_COMMAND = "^!\r\n";

    private readonly ILoggerService _loggerService = loggerService;
    private readonly IMachineLoggerService _machineLoggerService = machineLoggerService;
    private readonly string _codCmac = codCmac;


    public Task<bool> Connect(bool autoReconnect = true)
    {
        return base.Connect();
    }

    public async Task<IList<IMachineComModel>> CollectData()
    {
        var externalMachineComModels = new List<IMachineComModel>();
        try
        {
            var printerModel = new EidosPrinterModel();
            var stringPrinterState = await GetPrinterState();
            //stringPrinterState = "$0,0,1,\u00b92,0,00,00345282,0,0,0,0,1,e200\r\n";
            if (string.IsNullOrEmpty(stringPrinterState))
            {
                printerModel.ConnectionStatus = false;
            }
            else
            {
                var markingCycle = int.Parse(stringPrinterState.Substring(1, 1));
                var printerFault = int.Parse(stringPrinterState.Substring(5, 1));
                var errorCode = stringPrinterState.Substring(7, 2);
                var prevCycleStatus = stringPrinterState.Substring(10, 1);
                var lastErrorCode = stringPrinterState.Substring(12, 2);
                var progressiveNumber = stringPrinterState.Substring(15, 8);
                var logicalInputStatus = stringPrinterState.Substring(24, 1);   
                var logicalInputPrintStatus = stringPrinterState.Substring(26, 1);
                var ribbonStatus= stringPrinterState.Substring(30, 1);
                var printingMode= stringPrinterState.Substring(32, 1);
                var printerType= stringPrinterState.Substring(34, 1);
                var printerHeadType= stringPrinterState.Substring(35, 1);
                
                switch (markingCycle)
                {
                    case 0:
                        printerModel.Stato = MachineStatusEnum.ATTESA;
                        break;
                    case 1:
                        printerModel.Stato = MachineStatusEnum.ATTESA;
                        break;
                    case 2:
                        printerModel.Stato = MachineStatusEnum.ATTESA;
                        break;
                    default:
                        printerModel.Stato = MachineStatusEnum.STOP;
                        break;
                }

                if (printerFault > 0)
                {
                    printerModel.Stato = MachineStatusEnum.ALLARME;
                    var errorCodeInt = parseErrorCode(errorCode);
                    printerModel.ErrorCode = errorCodeInt;
                }

                printerModel.ContatoreParziale = Int32.Parse(progressiveNumber);
                printerModel.RibbonStatus = int.Parse(ribbonStatus);
                string printerModelName;
                switch (printerType)
                {
                    case "w":
                        printerModelName = "Swingcx";
                        break;
                    case "p":
                        printerModelName = "Printess";
                        break;
                    case "d":
                        printerModelName = "Coditherm";
                        break;
                    case "k":
                        printerModelName = "Swing5i";
                        break;
                    case "e":
                        printerModelName = "Wingie";
                        break;
                    case "?":
                    default:
                        printerModelName = "Modello sconosciuto";
                        break;
                }
                printerModel.PrinterModel = printerModelName;

                string printerHeadSize;
                switch (printerHeadType)
                {
                    case "2":
                        printerHeadSize = "53 mm";
                        break;
                    case "3":
                        printerHeadSize = "107 mm";
                        break;
                    case "4":
                        printerHeadSize = "160 mm";
                        break;
                    case "5":
                        printerHeadSize = "128 mm";
                        break;
                    case "6":
                        printerHeadSize = "32 mm";
                        break;
                    case "7":
                        printerHeadSize = "106mm";
                        break;
                    case "8":
                        printerHeadSize = "213 mm";
                        break;
                    case ",":
                    default:
                        printerHeadSize = "Non gestita";
                        break;
                }
                printerModel.PrinterHeadType = printerHeadSize;
            }

            
            

            externalMachineComModels.Add(printerModel);
        }
        catch (Exception ex)
        {
            this._loggerService.LogVerboseError(ex, nameof(EidosPrinterModel));
        }

        return externalMachineComModels;
    }

    private int parseErrorCode(string errorCode)
    {
        int error;
        if (int.TryParse(errorCode,out error))
        {
            return error;
        }

        var hexString = base.ConvertToHexString(errorCode);

        var binaryString = base.ConvertHexToBinaryString(hexString);
        binaryString = "1" + binaryString.Substring(1);
        hexString = base.BinaryStringToHexString(binaryString);
        var finalString = base.HexStringToASCIIString(hexString);
        if(int.TryParse(errorCode, out error))
        {
            return 100 + error;
        }

        _loggerService.LogError($"Impossibile convertire il codice di errore: {errorCode} ricevuto dalla macchine ");
        return default;
    }


    protected override Task PostConnect()
    {
        return Task.CompletedTask;
    }

    protected async override Task OnConnected()
    {
        var model = new EidosPrinterModel();
        await machineConnectionsService.RegisterMachineConnection(model.GetCodCmac(), true);
    }

    protected override async Task OnDisconnected()
    {
        var model = new EidosPrinterModel();
        await machineConnectionsService.RegisterMachineConnection(model.GetCodCmac(), false);
    }


    public async Task<string> GetPrinterState()
    {
        await base.Send(GET_PRINTER_STATE_COMMAND);


        IList<string> statusDataList = await base.Receive("\r\n");
        if (statusDataList == null || !statusDataList.Any())
        {
            return string.Empty;
        }

        return statusDataList.Where((x) => x.StartsWith("$")).LastOrDefault(string.Empty);
    }

    public async Task<bool> sendNewProduction(String layerName, List<KeyValuePair<string, string>> paramList)
    {
        //layerName = "invlato.lm1";
        await base.Send(RESET_BUFFER_COMMAND);
        await base.Send(SELECT_LABEL_COMMAND.Replace("__LABELNAME__",layerName));
        foreach (var param in  paramList)
        {
            await base.Send(SET_VAR_COMMAND.Replace("__LABEL__",param.Key).Replace("__VAL__",param.Value));
        }
        
        await base.Send(PROCESS_VAR_COMMAND);
        await base.Send(CONFIRM_LABEL_COMMAND);

        return true;
    }
}