tbf/GenesisCordonelInterface/API/InterfaceOutsideToGCI.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
using static Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.GenesisMeter;

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;

        private readonly Dictionary<int, PortConfig> _requestPorts = new Dictionary<int, PortConfig>();
        private readonly Dictionary<int, PortConfig> _streamingPorts = new Dictionary<int, PortConfig>();
        private readonly object _portLock = new object();

        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 InterfaceGCIToLaatzen.InitResult InitOneMeterFromExtern(
            int slot,
            ConfigSource useConfigSource,
            PasswordSource usePasswordSource,
            PortConfig? requestPort,
            PortConfig? streamingPort)
        {
            var result = _innerMeterAPI.InitOneMeterFromExtern(
                slot,
                useConfigSource,
                usePasswordSource,
                requestPort,
                streamingPort);

            RaiseMeterBatchStatusChanged();
            return result;
        }

        public async Task<InterfaceGCIToLaatzen.InitResult> InitOneMeterFromExternAsync(
            int slot,
            ConfigSource useConfigSource,
            PasswordSource usePasswordSource,
            PortConfig? requestPort,
            PortConfig? streamingPort,
            CancellationToken token = default(CancellationToken))
        {
            var result = await _innerMeterAPI.InitOneMeterFromExternAsync(
                slot,
                useConfigSource,
                usePasswordSource,
                requestPort,
                streamingPort,
                token);

            RaiseMeterBatchStatusChanged();
            return result;
        }

        public InterfaceGCIToLaatzen.InitResult InitSlotWithConfiguredPorts(
            int slot,
            ConfigSource useConfigSource,
            PasswordSource usePasswordSource)
        {
            return InitOneMeterFromExtern(
                slot,
                useConfigSource,
                usePasswordSource,
                GetSlotRequestPort(slot),
                GetSlotStreamingPort(slot));
        }

        public Task<InterfaceGCIToLaatzen.InitResult> InitSlotWithConfiguredPortsAsync(
            int slot,
            ConfigSource useConfigSource,
            PasswordSource usePasswordSource,
            CancellationToken token = default(CancellationToken))
        {
            return InitOneMeterFromExternAsync(
                slot,
                useConfigSource,
                usePasswordSource,
                GetSlotRequestPort(slot),
                GetSlotStreamingPort(slot),
                token);
        }

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

        #region CONNECTION
        // ----------------------------------------------------

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

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

        public void Disconnect(int slot)
        {
            _innerMeterAPI.Disconnect(slot);
            RaiseMeterBatchStatusChanged();
        }

        public async Task DisconnectAsync(
            int slot,
            CancellationToken token = default(CancellationToken))
        {
            await _innerMeterAPI.DisconnectAsync(slot, token);
            RaiseMeterBatchStatusChanged();
        }

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

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

        public string GetPcbId(int slot)
        {
            return _innerMeterAPI.GetPcbId(slot);
        }

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

        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 PortConfig
                    {
                        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 PortConfig
                    {
                        PortName = portName,
                        Type = "Serial"
                    };
                }
            }

            RaiseMeterBatchStatusChanged();
        }

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

                return null;
            }
        }

        public PortConfig? GetSlotStreamingPort(int slot)
        {
            lock (_portLock)
            {
                PortConfig 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
    }
}