prs/prs.desktop/Integrations/Logikal/LogikalClient.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
using Comal.Classes;
using H.Formatters;
using H.Pipes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.Integration.Logikal;
using Newtonsoft.Json;
using PRSDesktop.Integrations.Logikal;
using Exception = System.Exception;
using Process = System.Diagnostics.Process;

namespace PRSDesktop;

public class LogikalClient : IDisposable
{

    private readonly PipeClient<LogikalMessage> _client;
    
    private ConcurrentDictionary<Guid, ManualResetEventSlim> Events = new();
    private ConcurrentDictionary<Guid, LogikalMessage> Responses = new();

    private const int DefaultRequestTimeout = 5 * 60 * 1000; // 5 minutes
    
    public LogikalSettings Settings { get; private set; }

    public bool Ready { get; private set; } = false;

    private LogikalErrorResponse NOTLOGGEDIN = new LogikalErrorResponse()
    {
        Status = LogikalStatus.NotLoggedIn,
        Message = "Not Logged In"
    };
    
    public LogikalClient()
    {

        Settings = new GlobalConfiguration<LogikalSettings>().Load();
        
        var _basedirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) ?? "";

        var _logikalapp = System.IO.Path.Combine(_basedirectory, "PRSLogikal", "PRSLogikal.exe");
        if (!File.Exists(_logikalapp))
            _logikalapp = @"C:\development\prs\prs.logikal\bin\Debug\prslogikal.exe";
        if (!File.Exists(_logikalapp))
        {
            MessageBox.Show("Unable to locate PRS/Logikal interface!");
            return;
        }

        var _info = new ProcessStartInfo(_logikalapp);
        _info.WindowStyle = ProcessWindowStyle.Minimized;
        Process.Start(_info);
        
        _client = new PipeClient<LogikalMessage>("$logikal", formatter: new NewtonsoftJsonFormatter());
        
        _client.Connected += Client_Connected;
        _client.Disconnected += Client_Disconnected;
        _client.MessageReceived += Client_MessageReceived;
        _client.ExceptionOccurred += Client_ExceptionOccurred;

        _client.ConnectAsync();
    }
    
    public void Dispose()
    {
        _client.DisposeAsync().AsTask().Wait();
    }
    
    private void Client_Connected(object? sender, H.Pipes.Args.ConnectionEventArgs<LogikalMessage> e)
    {
        Logger.Send(LogType.Information, "", $"Connected to Pipe: {e.Connection.PipeName}");
        //Disconnected = false;
        // Here we will register a Licence "Hit" for the Logikal interface
    }

    private void Client_Disconnected(object? sender, H.Pipes.Args.ConnectionEventArgs<LogikalMessage> e)
    {
        Logger.Send(LogType.Information, "", $"Disconnected from Pipe: {e.Connection.PipeName}");
        foreach (var ev in Events)
        {
            Responses.TryAdd(ev.Key, LogikalMessage.Error("Disconnected"));
            ev.Value.Set();
        }
        //Disconnected = true;
    }
    
    private void Client_ExceptionOccurred(object? sender, H.Pipes.Args.ExceptionEventArgs e)
    {
        Logger.Send(LogType.Error, "", $"Exception occured: {e.Exception.Message}");
    }

    private static Dictionary<LogikalMethod, Type> _methods = new Dictionary<LogikalMethod, Type>()
        {
            { LogikalMethod.Connect, typeof(LogikalConnectResponse) },
            { LogikalMethod.Login, typeof(LogikalLoginResponse) },
            { LogikalMethod.Logout, typeof(LogikalLogoutResponse) },
            { LogikalMethod.Disconnect, typeof(LogikalDisconnectResponse) },
            { LogikalMethod.ProjectCentres, typeof(LogikalProjectCentresResponse<LogikalProjectCentre, LogikalProject>) },
            { LogikalMethod.Projects, typeof(LogikalProjectsResponse<LogikalProject>) },
            { LogikalMethod.Phases, typeof(LogikalPhasesResponse<LogikalPhase>) },
            { LogikalMethod.ElevationSummary, typeof(LogikalElevationSummaryResponse<LogikalElevationSummary>) },
            { LogikalMethod.ElevationDetail, typeof(LogikalElevationDetailResponse<LogikalElevationDetail,LogikalFinish,LogikalProfile,LogikalGasket,LogikalComponent, LogikalGlass, LogikalLabour>) },
            { LogikalMethod.BOM, typeof(LogikalBOMResponse<LogikalBOM,LogikalFinish,LogikalProfile,LogikalGasket,LogikalComponent, LogikalGlass, LogikalLabour>) },
            { LogikalMethod.Error, typeof(LogikalErrorResponse) },
        };


    private LogikalResponse FromMessage(LogikalMessage message)
    {
        try
        {
            LogikalResponse _result = null;
            if (_methods.TryGetValue(message.Method, out var _type))
            {
                _result = JsonConvert.DeserializeObject(message.Payload, _type) as LogikalResponse;
                if (_result != null)
                    return _result;
                return new LogikalErrorResponse() { Status = LogikalStatus.Error, Message = $"Deserialize Failure: {message.Method}: {message.Payload}" };
            }
            else
                return new LogikalErrorResponse() { Status = LogikalStatus.Error, Message = $"Invalid Message Method: {message.Method}: {message.Payload}" };
        }
        catch (Exception e)
        {
            return new LogikalErrorResponse() { Status = LogikalStatus.Error, Message = $"Exception Deserializing Response: {e.Message}\n{e.StackTrace}" };
        }

    }
    
    public LogikalResponse Send(LogikalRequest request, int timeout = DefaultRequestTimeout)
    {
        var checkfile = Path.Combine(CoreUtils.GetPath(),"simulator.logikal");
        var filename = Path.Combine(CoreUtils.GetPath(), $"{request.Method()}.logikal");
        if (File.Exists(checkfile) && File.Exists(filename))
        {
            var dec = Serialization.Deserialize<LogikalMessage>(File.ReadAllText(filename));
            if (dec != null)
                return FromMessage(dec);
        }

        var message = new LogikalMessage()
        {
            ID = Guid.NewGuid(),
            Method = request.Method(),
            Payload = Serialization.Serialize(request),
        };
        var ev = Queue(message.ID);
        _client.WriteAsync(message);
        var result = GetResult(message.ID, ev, timeout);

        if (File.Exists(checkfile))
        {
            var enc = Serialization.Serialize(result);
            File.WriteAllText(filename, enc);
        }
        return FromMessage(result);
    }

    public ManualResetEventSlim Queue(Guid id)
    {
        var ev = new ManualResetEventSlim();
        Events[id] = ev;
        return ev;
    }

    public LogikalMessage GetResult(Guid id, ManualResetEventSlim ev, int timeout)
    {
        if (Responses.TryRemove(id, out var result))
        {
            Events.TryRemove(id, out ev);
            return result;
        }

        try
        {
            if (!ev.Wait(timeout))
            {
                return LogikalMessage.Error("Timeout");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
            
        Responses.TryRemove(id, out result);
        Events.TryRemove(id, out ev);
        return result ?? LogikalMessage.Error("Unknown");
    }

    private void Client_MessageReceived(object? sender, H.Pipes.Args.ConnectionMessageEventArgs<LogikalMessage?> e)
    {
        if (Events.TryGetValue(e.Message.ID, out var ev))
        {
            Responses[e.Message.ID] = e.Message;
            ev.Set();
        }
    }
    
    ~LogikalClient()
    {
        Dispose();
    }

    public LogikalResponse Connect()
    {
        Settings = new GlobalConfiguration<LogikalSettings>().Load();
        Client.Save(new LogikalUsage(),"");
        
        if (Ready)
            return new LogikalConnectResponse();
        
        var _request = new LogikalConnectRequest()
        {
            Path = Settings.Path
        };
        var _result = Send(_request);
        return _result;

    }

    public LogikalResponse Disconnect()
    {
        Ready = false;
        var _request = new LogikalDisconnectRequest();
        var _result = Send(_request);
        return _result;
    }

    public LogikalResponse Login()
    {
        //Settings = new GlobalConfiguration<LogikalSettings>().Load();
        
        if (Ready)
            return new LogikalLoginResponse();
        
        var _request = new LogikalLoginRequest();
        var _result = Send(_request)
            .Success<LogikalLoginResponse>(r => 
            {
                Ready = true;
            });
        return _result;
    }

    public LogikalResponse Logout()
    {
        Ready = false;
        var _request = new LogikalLogoutRequest();
        var _result = Send(_request);
        return _result;
    }
    
    public LogikalResponse GetProjectCentres()
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalProjectCentresRequest();
        var _result = Send(_request);
        return _result;
    }
    
    public LogikalResponse GetProjects(string jobnumber)
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalProjectsRequest(jobnumber);
        var _result = Send(_request);
        return _result;
    }

    public LogikalResponse GetProject(Guid projectid)
    {
        if (!Ready)
            return NOTLOGGEDIN;
        var _request = new LogikalProjectRequest(projectid);
        var _result = Send(_request);
        return _result;
    }

    public LogikalResponse GetPhases(Guid projectid)
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalPhasesRequest(projectid);
        var _result = Send(_request);
        return _result;
    }
    
    public LogikalResponse GetElevationSummaries(Guid projectid, string phase)
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalElevationSummaryRequest(projectid, phase);
        var _result = Send(_request);
        return _result; 
    }
    
    public LogikalResponse GetBillOfMaterials(Guid projectid, Guid[] elevationids, bool excel, bool sqlite)
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalBOMRequest(
            projectid, 
            elevationids, 
            Settings.FinishSQL,
            Settings.BillOfMaterialsProfileSQL, 
            Settings.GasketSQL, 
            Settings.ComponentSQL, 
            Settings.GlassSQL, 
            Settings.LabourSQL, 
            excel,
            sqlite);

        var _result = Send(_request);
        return _result;
    }

    public LogikalResponse GetElevationDetails(Guid projectid, Guid[] elevationids, bool excel, bool sqlite)
    {
        if (!Ready)
            return NOTLOGGEDIN;

        var _request = new LogikalElevationDetailRequest(
            projectid, 
            elevationids,
            Settings.FinishSQL,
            Settings.DesignProfileSQL, 
            Settings.GasketSQL, 
            Settings.ComponentSQL, 
            Settings.GlassSQL,
            Settings.LabourSQL, 
            excel,
            sqlite, 
            
            Settings.DrawingFormat == Comal.Classes.LogikalDrawingFormat.DXF 
                ? InABox.Integration.Logikal.LogikalDrawingFormat.DXF 
                : InABox.Integration.Logikal.LogikalDrawingFormat.PNG,
            
            Settings.DrawingView == Comal.Classes.LogikalDrawingView.Exterior
                ? InABox.Integration.Logikal.LogikalDrawingView.Exterior
                : InABox.Integration.Logikal.LogikalDrawingView.Interior,
            
            Settings.DrawingType == Comal.Classes.LogikalDrawingType.Explosion
                ? InABox.Integration.Logikal.LogikalDrawingType.Explosion
                : Settings.DrawingType == Comal.Classes.LogikalDrawingType.Section
                    ? InABox.Integration.Logikal.LogikalDrawingType.Section
                    : Settings.DrawingType == Comal.Classes.LogikalDrawingType.Elevation
                        ? InABox.Integration.Logikal.LogikalDrawingType.Elevation
                        : Settings.DrawingType == Comal.Classes.LogikalDrawingType.ElevationWithSectionLines
                            ? InABox.Integration.Logikal.LogikalDrawingType.ElevationWithSectionLines
                            : InABox.Integration.Logikal.LogikalDrawingType.SectionLine
                    
            );

        var _result = Send(_request);
        return _result;
    }


}