nc_program_manager/Cnc/Mitsubishi/MitsubishiMachine.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NLog;
using NcProgramManager.Cnc;
using NcProgramManager.Cnc.Models;

namespace NcProgramManager.Cnc.Mitsubishi
{
    public sealed class MitsubishiMachine : ICncMachine
    {
        private static readonly Logger _log = LogManager.GetCurrentClassLogger();

        private readonly MitsubishiConnectionConfig _config;
        private readonly IMitsubishiFtpClient _ftp;
        private readonly INcProgramValidator _validator;
        private readonly List<CncError> _errors = new List<CncError>();
        private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1);
        private ConnectionState _state = ConnectionState.Disconnected;

        public MitsubishiMachine(MitsubishiConnectionConfig config)
        {
            _config = config ?? throw new ArgumentNullException("config");
            _ftp = new MitsubishiFtpClient(config);
            _validator = new NcProgramValidator(CncManufacturer.Mitsubishi);
        }

        internal MitsubishiMachine(MitsubishiConnectionConfig config, IMitsubishiFtpClient ftpClient,
            INcProgramValidator validator = null)
        {
            _config = config ?? throw new ArgumentNullException("config");
            _ftp = ftpClient ?? throw new ArgumentNullException("ftpClient");
            _validator = validator ?? new NcProgramValidator(CncManufacturer.Mitsubishi);
        }

        public string Name { get { return _config.Name; } }
        public ConnectionState State { get { return _state; } }
        public event EventHandler<ConnectionState> StateChanged;

        public Task<CncResult<bool>> ConnectAsync(CancellationToken ct = default(CancellationToken))
        {
            return RunGuardedAsync(() =>
            {
                SetState(ConnectionState.Connecting);
                if (!_ftp.Ping())
                {
                    SetState(ConnectionState.Faulted);
                    _errors.Add(new CncError(0, "Connect",
                        string.Format("FTP server unreachable at {0}:{1}", _config.IpAddress, _config.Port)));
                    return false;
                }
                SetState(ConnectionState.Connected);
                return true;
            }, ct);
        }

        public Task DisconnectAsync()
        {
            return RunGuardedAsync<bool>(() =>
            {
                SetState(ConnectionState.Disconnected);
                return true;
            }, CancellationToken.None);
        }

        public Task<CncResult<string>> ReadProgramAsync(string path, CancellationToken ct = default(CancellationToken))
        {
            return RunGuardedAsync(() =>
            {
                EnsureConnected();
                string ncPath = ResolvePath(path);
                try { return _ftp.DownloadFile(ncPath); }
                catch (Exception ex)
                {
                    _errors.Add(new CncError(0, "ReadProgram", ex.Message));
                    return null;
                }
            }, ct);
        }

        public Task<CncResult<bool>> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default(CancellationToken))
        {
            return RunGuardedAsync(() =>
            {
                EnsureConnected();
                if (program == null || string.IsNullOrEmpty(program.Content))
                {
                    _errors.Add(new CncError(0, "WriteProgram", "Content is empty"));
                    return false;
                }
                var vr = _validator.Validate(program.Name ?? path, program.Content);
                if (!vr.Success)
                {
                    string msg = string.Join("; ", vr.Errors
                        .Where(e => e.Severity == ValidationSeverity.Error)
                        .Select(e => e.Message));
                    _errors.Add(new CncError(0, "Validator", msg));
                    return false;
                }
                // ISS-020: resolve the write path the same way ReadProgramAsync does.
                // `path` is the program identifier (e.g. "1" -> /PRG/1) or a full FTP
                // path, NOT a directory to combine with program.Name. On Mitsubishi the
                // file in PRG/USER is addressed by its program name/number; program.Name
                // (the ISO O-number) is used for validation only, not the filename.
                string ncPath = ResolvePath(path);
                try { _ftp.UploadFile(ncPath, program.Content); return true; }
                catch (Exception ex)
                {
                    _errors.Add(new CncError(0, "WriteProgram", ex.Message));
                    return false;
                }
            }, ct);
        }

        public Task<CncResult<bool>> DeleteProgramAsync(string path, CancellationToken ct = default(CancellationToken))
        {
            return RunGuardedAsync(() =>
            {
                EnsureConnected();
                try { _ftp.DeleteFile(path); return true; }
                catch (Exception ex)
                {
                    _errors.Add(new CncError(0, "DeleteProgram", ex.Message));
                    return false;
                }
            }, ct);
        }

        public Task<CncResult<MachineSnapshot>> ReadAsync(CancellationToken ct = default(CancellationToken))
        {
            return RunGuardedAsync(() =>
            {
                EnsureConnected();
                return new MachineSnapshot
                {
                    CapturedAt = DateTime.Now,
                    Mode = MachineMode.Unknown,
                    Run = RunState.Unknown,
                    Motion = MotionState.Unknown,
                    Alarms = new List<string>(),
                    OperatorMessages = new List<string>()
                };
            }, ct);
        }

        public Task<CncResult<string>> ReadActiveProgramAsync(CancellationToken ct = default(CancellationToken))
        {
            return Task.FromResult(CncResult<string>.Fail("ReadActiveProgram", "Not supported via FTP"));
        }

        public Task<CncResult<bool>> SelectMainProgramAsync(string path, CancellationToken ct = default(CancellationToken))
        {
            return Task.FromResult(CncResult<bool>.Fail("SelectMainProgram", "Not supported via FTP"));
        }

        public void Dispose()
        {
            try { DisconnectAsync().GetAwaiter().GetResult(); } catch { /* cleanup — intentionally swallowed */ }
            try { _gate.Dispose(); } catch { /* cleanup — intentionally swallowed */ }
        }

        private async Task<CncResult<T>> RunGuardedAsync<T>(Func<T> body, CancellationToken ct)
        {
            await _gate.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                return await Task.Run(() =>
                {
                    _errors.Clear();
                    try
                    {
                        T value = body();
                        return _errors.Count > 0
                            ? CncResult<T>.Fail(_errors.ToArray())
                            : CncResult<T>.Ok(value);
                    }
                    catch (OperationCanceledException) { return CncResult<T>.Cancelled(); }
                    catch (Exception ex)
                    {
                        _errors.Add(new CncError(0, "MitsubishiMachine", ex.Message));
                        return CncResult<T>.Fail(_errors.ToArray());
                    }
                }, ct).ConfigureAwait(false);
            }
            finally { _gate.Release(); }
        }

        private void EnsureConnected()
        {
            if (_state != ConnectionState.Connected)
                throw new InvalidOperationException("MitsubishiMachine is not connected.");
        }

        private void SetState(ConnectionState next)
        {
            if (_state == next) return;
            _state = next;
            var h = StateChanged;
            if (h != null)
            {
                try { h(this, next); } catch (Exception ex) { _log.Warn(ex, "StateChanged handler threw"); }
            }
        }

        /// <summary>
        /// Build full FTP path. Mitsubishi programs have no extension and are addressed
        /// by their program name/number under <see cref="MitsubishiConnectionConfig.ProgramDirectory"/>.
        /// A bare identifier ("1") is combined with the program directory ("/PRG/1");
        /// an explicit path containing '/' is used as-is. Read and write resolve identically.
        /// </summary>
        private string ResolvePath(string path)
        {
            if (string.IsNullOrEmpty(path)) return _config.ProgramDirectory;
            return path.Contains("/") ? path : _config.ProgramDirectory + path;
        }
    }
}