using System;
using System.IO;
using System.IO.Ports;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace Elwig.Helpers.Weighing {
    public class SystecScale : ICommandScale {

        protected enum Output { RTS, DTR, OUT1, OUT2 };

        protected SerialPort? Serial = null;
        protected SerialPort? ControlSerialEmpty = null, ControlSerialFilling = null;
        protected TcpClient? Tcp = null;
        protected Stream Stream;

        protected readonly Output? EmptyMode = null;
        protected readonly Output? FillingClearanceMode = null;
        protected readonly int EmptyDelay;

        public string Manufacturer => "SysTec";
        public int InternalScaleNr => 1;
        public string Model { get; private set; }
        public string ScaleId { get; private set; }
        public bool IsReady { get; private set; }
        public bool HasFillingClearance { get; private set; }
        public int? WeightLimit { get; private set; }
        public string? LogPath { get; private set; }

        public SystecScale(string id, string model, string connection, string? empty = null, string? filling = null, int? limit = null, string? log = null) {
            ScaleId = id;
            Model = model;
            IsReady = true;
            HasFillingClearance = false;
            LogPath = log;

            if (connection.StartsWith("serial:")) {
                Serial = Utils.OpenSerialConnection(connection);
                Stream = Serial.BaseStream;
            } else if (connection.StartsWith("tcp:")) {
                Tcp = Utils.OpenTcpConnection(connection);
                Stream = Tcp.GetStream();
            } else {
                throw new ArgumentException("Unsupported scheme");
            }

            if (empty != null) {
                var parts = empty.Split(':');
                if (parts.Length == 3) {
                    if (parts[0] != Serial?.PortName)
                        ControlSerialEmpty = Utils.OpenSerialConnection($"serial://{parts[0]}:9600");
                } else if (parts.Length != 2) {
                    throw new ArgumentException("Invalid value for 'empty'");
                }
                EmptyMode = ConvertOutput(parts[^2]);
                EmptyDelay = int.Parse(parts[^1]);
            }

            WeightLimit = limit;
            if (filling != null) {
                var parts = filling.Split(':');
                if (parts.Length == 2) {
                    if (parts[0] != Serial?.PortName)
                        ControlSerialFilling = parts[0] != ControlSerialEmpty?.PortName ? Utils.OpenSerialConnection($"serial://{parts[0]}:9600") : ControlSerialEmpty;
                } else if (parts.Length != 1) {
                    throw new ArgumentException("Invalid value for 'filling'");
                }
                FillingClearanceMode = ConvertOutput(parts[^1]);
            }

            if (FillingClearanceMode != null && WeightLimit == null)
                throw new ArgumentException("Weight limit has to be set, if filling clearance supervision is enabled");
        }

        public void Dispose() {
            Stream.Close();
            Serial?.Close();
            ControlSerialEmpty?.Close();
            ControlSerialFilling?.Close();
            Tcp?.Close();
            GC.SuppressFinalize(this);
        }

        protected static Output? ConvertOutput(string? value) {
            return value switch {
                null => null,
                "RTS" => Output.RTS,
                "DTR" => Output.DTR,
                "OUT1" => Output.OUT1,
                "OUT2" => Output.OUT2,
                _ => throw new ArgumentException($"Invalid value for argument: '{value}'"),
            };
        }

        protected async Task SendCommand(string command) {
            byte[] bytes = Encoding.ASCII.GetBytes($"<{command}>");
            await Stream.WriteAsync(bytes);
            if (LogPath != null) await File.AppendAllTextAsync(LogPath, $"<{command}>");
        }

        protected async Task<string> ReceiveResponse() {
            string? line = null;
            using (var reader = new StreamReader(Stream, Encoding.ASCII, false, -1, true)) {
                line = await reader.ReadLineAsync();
                if (LogPath != null) await File.AppendAllTextAsync(LogPath, $"{line}\r\n");
            }
            if (line == null || line.Length < 4 || !line.StartsWith("<") || !line.EndsWith(">")) {
                throw new IOException("Invalid response from scale");
            }

            var error = line[1..3];
            if (error[0] == '0') {
                if (error[1] != '0') {
                    throw new IOException($"Invalid response from scale (error code {error})");
                }
            } else if (error[0] == '1') {
                string msg = $"Unbekannter Fehler (Fehler code {error})";
                switch (error[1]) {
                    case '1': msg = "Allgemeiner Waagenfehler"; break;
                    case '2': msg = "Waage in Überlast"; break;
                    case '3': msg = "Waage in Bewegung"; break;
                    case '5': msg = "Tarierungs- oder Nullsetzfehler"; break;
                    case '6': msg = "Drucker nicht bereit"; break;
                    case '7': msg = "Druckmuster enthält ungültiges Kommando"; break;
                }
                throw new IOException($"Waagenfehler {error}: {msg}");
            } else if (error[0] == '3') {
                string msg = $"Unbekannter Fehler (Fehler code {error})";
                switch (error[1]) {
                    case '1': msg = "Übertragunsfehler"; break;
                    case '2': msg = "Ungültiger Befehl"; break;
                    case '3': msg = "Ungültiger Parameter"; break;
                }
                throw new IOException($"Kommunikationsfehler {error}: {msg}");
            } else {
                throw new IOException($"Invalid response from scale (error code {error})");
            }

            return line[1..^1];
        }

        protected async Task<WeighingResult> Weigh(bool incIdentNr) {
            await SendCommand(incIdentNr ? $"RN{InternalScaleNr}" : $"RM{InternalScaleNr}");
            string record = await ReceiveResponse();
            if (record.Length != 62)
                throw new IOException("Invalid response from scale: Received record has invalid size");
            var line = record[2..];

            var status     = line[ 0.. 2];
            var date       = line[ 2..10];
            var time       = line[10..15];
            var identNr    = line[15..19].Trim();
            var scaleNr    = line[19..20];
            var brutto     = line[20..28].Trim();
            var tara       = line[28..36].Trim();
            var netto      = line[36..44].Trim();
            var unit       = line[44..46];
            var taraCode   = line[46..48];
            var zone       = line[48..49].Trim();
            var terminalNr = line[49..52].Trim();
            var crc16      = line[52..60].Trim();

            if (Utils.CalcCrc16Modbus(record[..54]) != ushort.Parse(crc16)) {
                throw new IOException($"Invalid response from scale: Invalid CRC16 checksum ({crc16} != {Utils.CalcCrc16Modbus(record[..54]).ToString()})");
            } else if (unit != "kg") {
                throw new IOException($"Unsupported unit in weighing response: '{unit}'");
            }

            identNr = identNr.Length > 0 && identNr != "0" ? identNr : null;
            var parsedDate = DateOnly.Parse(date);
            return new() {
                Weight = int.Parse(netto),
                WeighingId = identNr,
                FullWeighingId = identNr != null ? $"{parsedDate:yyyy-MM-dd}/{identNr}" : null,
                Date = parsedDate,
                Time = TimeOnly.Parse(time),
            };
        }

        public async Task<WeighingResult> Weigh() {
            return await Weigh(true);
        }

        public async Task<WeighingResult> GetCurrentWeight() {
            return await Weigh(false);
        }

        public async Task Empty() {
            SerialPort? p = ControlSerialEmpty ?? Serial;
            if (EmptyMode == Output.RTS && p != null) {
                p.RtsEnable = true;
                await Task.Delay(EmptyDelay);
                p.RtsEnable = false;
            } else if (EmptyMode == Output.DTR && p != null) {
                p.DtrEnable = true;
                await Task.Delay(EmptyDelay);
                p.DtrEnable = false;
            } else if (EmptyMode == Output.OUT1 || EmptyMode == Output.OUT2) {
                int output = EmptyMode == Output.OUT1 ? 1 : 2;
                await SendCommand($"OS{output:00}");
                await ReceiveResponse();
                await Task.Delay(EmptyDelay);
                await SendCommand($"OC{output:00}");
                await ReceiveResponse();
            }
        }

        protected async Task SetFillingClearance(bool status) {
            SerialPort? p = ControlSerialFilling ?? Serial;
            if (FillingClearanceMode == Output.RTS && p != null) {
                p.RtsEnable = status;
            } else if (FillingClearanceMode == Output.DTR && p != null) {
                p.DtrEnable = status;
            } else if (FillingClearanceMode == Output.OUT1 || FillingClearanceMode == Output.OUT2) {
                string cmd = status ? "OS" : "OC";
                int output = FillingClearanceMode == Output.OUT1 ? 1 : 2;
                await SendCommand($"{cmd}{output:00}");
                await ReceiveResponse();
            }
        }

        public async Task GrantFillingClearance() {
            await SetFillingClearance(true);
        }

        public async Task RevokeFillingClearance() {
            await SetFillingClearance(false);
        }
    }
}