tbf/GenesisCordonelInterface/API/InterfaceOutsideToGCI.cs

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Threading;
using System.Threading.Tasks;

namespace GenesisCordonelInterface.API
{
    /// <summary>
    /// Outside-facing facade for Genesis Cordonel Interface.
    /// Exposes only selected operations intended for external callers.
    /// </summary>
    public class InterfaceOutsideToGCI
    {
        private readonly InterfaceGCIToLaatzen _innerMeterAPI;

        public event Action<List<InterfaceGCIToLaatzen.MeterBatchDebugStatus>> MeterBatchStatusChanged;

        public InterfaceOutsideToGCI()
        {
            _innerMeterAPI = new InterfaceGCIToLaatzen();
        }

        #region ================================== PORT DETECTION ==================================

        public InterfaceGCIToLaatzen.PortDetectionResult DetectStreamingPort(int slot)
        {
            var result = _innerMeterAPI.DetectStreamingPort(slot);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        public async Task<InterfaceGCIToLaatzen.PortDetectionResult> DetectStreamingPortAsync(
            int slot,
            CancellationToken token = default(CancellationToken))
        {
            var result = await _innerMeterAPI.DetectStreamingPortAsync(slot, token);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        public InterfaceGCIToLaatzen.PortDetectionResult DetectRequestPort(int slot)
        {
            var result = _innerMeterAPI.DetectRequestPort(slot);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        public async Task<InterfaceGCIToLaatzen.PortDetectionResult> DetectRequestPortAsync(
            int slot,
            CancellationToken token = default(CancellationToken))
        {
            var result = await _innerMeterAPI.DetectRequestPortAsync(slot, token);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        #endregion

        #region ================================== INIT ==================================

        public async Task<GciPublicModels.GciInitSlotResult> InitSlotAsync(GciPublicModels.GciInitSlotRequest request, CancellationToken token = default)
        {
            if (request == null)
                throw new ArgumentNullException(nameof(request));

            var result = await _innerMeterAPI.InitOneMeterFromExternAsync(
                request.SlotId,
                GciPublicModels.MapConfigSource(request.ConfigSource),
                GciPublicModels.MapPasswordSource(request.PasswordSource),
                GciPublicModels.MapPort(request.RequestPort),
                GciPublicModels.MapPort(request.StreamingPort),
                token);

            RaiseMeterBatchStatusChanged();

            return result;
        }

        public async Task<GciPublicModels.GciSlotInfo> GetSlotAsync(
                int slotId,
                CancellationToken token = default)
        {
            if (slotId <= 0)
                throw new ArgumentException("Invalid slot id.");

            var result = await _innerMeterAPI.GetOneMeterInfo(slotId, token);

            return result;
        }

        public async Task<GciPublicModels.GciCleanSlotsResult> CleanSlotsAsync(
                CancellationToken token = default)
        {
            var result = await _innerMeterAPI.CleanSlotsAsync(token);

            RaiseMeterBatchStatusChanged();

            return result;
        }
        #endregion

        #region ================================== CONNECTION ==================================

        public async Task<GciPublicModels.GciConnectResult> ConnectOneSlotAsync(
                int slot,
                CancellationToken token = default)
        {
            GciPublicModels.GciConnectResult result = await _innerMeterAPI.ConnectOneSlotAsync(slot, token);

            RaiseMeterBatchStatusChanged();

            return result;
        }

        public async Task<GciPublicModels.GciDisconnectResult> DisconnectAsync(
                int slot,
                CancellationToken token = default)
        {
            if (slot <= 0)
                throw new ArgumentException("Invalid slot id.");

            var result = await _innerMeterAPI.DisconnectAsync(slot, token);

            RaiseMeterBatchStatusChanged();

            return result;
        }
        #endregion

        #region ================================== PCB ==================================
        public async Task<GciPublicModels.GciGetPcbIdResult> GetPcbIdAsync(
                int slot,
                CancellationToken token = default)
        {
            if (slot <= 0)
                throw new ArgumentException("Invalid slot id.");

            var result = await _innerMeterAPI.GetPcbIdAsync(slot, token);

            return result;
        }
        #endregion

        #region ================================== READ ==================================
        // ----------------------------------------------------

        public InterfaceGCIToLaatzen.RegisterReadResult ReadRegister(
            int slot,
            string registerName)
        {
            return _innerMeterAPI.ReadRegister(slot, registerName);
        }

        public Task<InterfaceGCIToLaatzen.RegisterReadResult> ReadRegisterAsync(
            int slot,
            string registerName,
            CancellationToken token = default(CancellationToken))
        {
            return _innerMeterAPI.ReadRegisterAsync(slot, registerName, token);
        }

        // ----------------------------------------------------
        #endregion

        #region ================================== WRITE ==================================
        // ----------------------------------------------------

        public async Task<InterfaceGCIToLaatzen.RegisterWriteResult> WriteRegisterAsync(
            int slot,
            string registerName,
            object value,
            bool storeToDevice = false,
            bool refreshSystemState = false)
        {
            var result = await _innerMeterAPI.WriteRegisterAsync(
                slot,
                registerName,
                value,
                storeToDevice,
                refreshSystemState);

            RaiseMeterBatchStatusChanged();
            return result;
        }

        public InterfaceGCIToLaatzen.RegisterWriteResult WriteRegister(
            int slot,
            string registerName,
            object value,
            bool storeToDevice = false,
            bool refreshSystemState = false)
        {
            var result = _innerMeterAPI.WriteRegister(
                slot,
                registerName,
                value,
                storeToDevice,
                refreshSystemState);

            RaiseMeterBatchStatusChanged();
            return result;
        }

        public async Task<bool> SetMeterPasswordAsync(int slot, string password)
        {
            var result = await _innerMeterAPI.SetMeterPasswordAsync(slot, password);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        public bool SetMeterPassword(int slot, string password)
        {
            var result = _innerMeterAPI.SetMeterPassword(slot, password);
            RaiseMeterBatchStatusChanged();
            return result;
        }

        // ----------------------------------------------------
        #endregion

        #region ================================== DEBUG STATUS ==================================
        // ----------------------------------------------------

        public List<InterfaceGCIToLaatzen.WorkerDebugStatus> GetWorkerDebugStatuses()
        {
            return _innerMeterAPI.GetWorkerDebugStatuses();
        }

        public List<InterfaceGCIToLaatzen.MeterBatchDebugStatus> GetMeterBatchDebugStatuses()
        {
            return _innerMeterAPI.GetMeterBatchDebugStatuses();
        }

        public void RaiseMeterBatchStatusChanged()
        {
            var statuses = GetMeterBatchDebugStatuses();

            var handler = MeterBatchStatusChanged;
            if (handler != null)
                handler(statuses);
        }

        // ----------------------------------------------------
        #endregion

        #region ================================== SLOT SELECTION ==================================
        // ----------------------------------------------------

        public void SetSlotSelected(int slot, bool selected)
        {
            _innerMeterAPI.SetSlotSelected(slot, selected);
            RaiseMeterBatchStatusChanged();
        }

        public bool IsSlotSelected(int slot)
        {
            return _innerMeterAPI.IsSlotSelected(slot);
        }

        public List<int> GetSelectedSlots()
        {
            return _innerMeterAPI.GetSelectedSlots();
        }

        // ----------------------------------------------------
        #endregion

        #region ================================== SLOT PORT CONFIG ==================================
        // ----------------------------------------------------

        /*public void SetSlotRequestPort(int slot, string portName)
        {
            lock (_portLock)
            {
                if (string.IsNullOrWhiteSpace(portName))
                {
                    _requestPorts.Remove(slot);
                }
                else
                {
                    _requestPorts[slot] = new GciPortConfig
                    {
                        PortName = portName,
                        Type = "Serial"
                    };
                }
            }

            RaiseMeterBatchStatusChanged();
        }

        public void SetSlotStreamingPort(int slot, string portName)
        {
            lock (_portLock)
            {
                if (string.IsNullOrWhiteSpace(portName))
                {
                    _streamingPorts.Remove(slot);
                }
                else
                {
                    _streamingPorts[slot] = new GciPortConfig
                    {
                        PortName = portName,
                        Type = "Serial"
                    };
                }
            }

            RaiseMeterBatchStatusChanged();
        }

        public GciPortConfig? GetSlotRequestPort(int slot)
        {
            lock (_portLock)
            {
                GciPortConfig port;
                if (_requestPorts.TryGetValue(slot, out port))
                    return port;

                return null;
            }
        }

        public GciPortConfig? GetSlotStreamingPort(int slot)
        {
            lock (_portLock)
            {
                GciPortConfig port;
                if (_streamingPorts.TryGetValue(slot, out port))
                    return port;

                return null;
            }
        }*/

        // ----------------------------------------------------
        #endregion

        #region ================================== METER BATCH SETUP ==================================
        // ----------------------------------------------------

        public void ReloadSlotSetup()
        {
            _innerMeterAPI.ReloadSlotSetup();
            RaiseMeterBatchStatusChanged();
        }

        public void SaveSlotSetup(List<InterfaceGCIToLaatzen.MeterBatchDebugStatus> data)
        {
            _innerMeterAPI.SaveSlotSetup(data);
            RaiseMeterBatchStatusChanged();
        }

        // ----------------------------------------------------
        #endregion
    }
}