using DTS.Common.Enums;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Interface.Hardware;
using DTS.Common.Utilities.Logging;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

namespace DTS.Common.Classes.Hardware
{
    public class DASMonitorInfo : IDASMonitorInfo
    {
        public string SerialNumber { get; private set; }

        public double[] TiltSensorCals { get; private set; } = new double[18];

        public short[] TiltSensorDataPre { get; private set; } = new short[3];

        public DFConstantsAndEnums.TiltAxes TiltAxes { get; private set; } = DFConstantsAndEnums.TiltAxes.IXIYIZ;

        public int AxisIgnored { get; private set; }

        public double MountOffsetAxisOne { get; private set; } = double.NaN;

        public double MountOffsetAxisTwo { get; private set; } = double.NaN;

        private string[] _channelNames = new string[0];

        public string GetChannelName(int index)
        {
            if (index >= _channelNames.Length) { return $"{Strings.Strings.Ch}#{1 + index:00}"; }
            return _channelNames[index];
        }

        private double[] _offsetTolerancesHigh = new double[6];
        public double GetOffsetTolerancemVHigh(int index)
        {
            if (index >= _offsetTolerancesHigh.Length) { return 0D; }
            return _offsetTolerancesHigh[index];
        }

        private double[] _offsetTolerancesLow = new double[6];
        public double GetOffsetTolerancemVLow(int index)
        {
            if (index >= _offsetTolerancesLow.Length) { return 0D; }
            return _offsetTolerancesLow[index];
        }

        public void ReadFromFile(string path)
        {
            if(!File.Exists(path)) { return; }
            try
            {
                var lines = File.ReadAllLines(path);
                var keys = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
                for (var i = 0; i < lines.Length && i < keys.Length; i++)
                {
                    var line = lines[i];
                    var key = keys[i];
                    switch (key)
                    {
                        case Fields.SerialNumber:
                            SerialNumber = line;
                            break;
                        case Fields.TiltSensorCals:
                            TiltSensorCals = ToDoubleArray(line);
                            break;
                        case Fields.TiltSensorDataPre:
                            TiltSensorDataPre = ToShortArray(line);
                            break;
                        case Fields.TiltAxes:
                            TiltAxes = (DFConstantsAndEnums.TiltAxes)Enum.Parse(typeof(DFConstantsAndEnums.TiltAxes), line);
                            break;
                        case Fields.AxesIgnored:
                            AxisIgnored = int.Parse(line, CultureInfo.InvariantCulture);
                            break;
                        case Fields.MountOffsetAxisOne:
                            MountOffsetAxisOne = double.Parse(line, CultureInfo.InvariantCulture);
                            break;
                        case Fields.MountOffsetAxisTwo:
                            MountOffsetAxisTwo = double.Parse(line, CultureInfo.InvariantCulture);
                            break;
                        case Fields.ChannelNames:
                            _channelNames = ToStringArray(line);
                            break;
                        case Fields.OffsetTolerancesLow:
                            _offsetTolerancesLow = ToDoubleArray(line);
                            break;
                        case Fields.OffsetTolerancesHigh:
                            _offsetTolerancesHigh = ToDoubleArray(line);
                            break;
                    }
                }
            }
            catch( Exception ex)
            {
                APILogger.Log(ex);
            }
        }
        private short [] ToShortArray(string line)
        {
            var shorts = new List<short>();
            var tokens = line.Split(new[] { SEPARATOR }, StringSplitOptions.None);
            foreach (var token in tokens)
            {
                if (short.TryParse(line, NumberStyles.Any, CultureInfo.InvariantCulture, out var s))
                {
                    shorts.Add(s);
                }
            }
            return shorts.ToArray();
        }
        private string [] ToStringArray(string line)
        {
            return line.Split(new[] { SEPARATOR }, StringSplitOptions.None);
        }
        private double [] ToDoubleArray(string line)
        {
            var doubles = new List<double>();
            var tokens = line.Split(new[] { SEPARATOR }, StringSplitOptions.None);
            foreach (var token in tokens)
            {
                if (double.TryParse(token, NumberStyles.Any, CultureInfo.InvariantCulture, out double d))
                {
                    doubles.Add(d);
                }
            }
            return doubles.ToArray();
        }
        private const string SEPARATOR = ",";
        public void WriteToFile(string path)
        {
            try
            {
                var lines = new List<string>();
                var keys = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
                foreach (var key in keys)
                {
                    switch (key)
                    {
                        case Fields.SerialNumber:
                            lines.Add(SerialNumber);
                            break;
                        case Fields.TiltSensorCals:
                            lines.Add(ToString(TiltSensorCals));
                            break;
                        case Fields.TiltSensorDataPre:
                            lines.Add(ToString(TiltSensorDataPre));
                            break;
                        case Fields.TiltAxes:
                            lines.Add(TiltAxes.ToString());
                            break;
                        case Fields.AxesIgnored:
                            lines.Add(AxisIgnored.ToString());
                            break;
                        case Fields.MountOffsetAxisOne:
                            lines.Add(MountOffsetAxisOne.ToString(CultureInfo.InvariantCulture));
                            break;
                        case Fields.MountOffsetAxisTwo:
                            lines.Add(MountOffsetAxisTwo.ToString(CultureInfo.InvariantCulture));
                            break;
                        case Fields.ChannelNames:
                            lines.Add(ToString(_channelNames));
                            break;
                        case Fields.OffsetTolerancesLow:
                            lines.Add(ToString(_offsetTolerancesLow));
                            break;
                        case Fields.OffsetTolerancesHigh:
                            lines.Add(ToString(_offsetTolerancesHigh));
                            break;
                    }
                }
                File.WriteAllLines(path, lines.ToArray());
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
            }
        }
        private string ToString(string[] values)
        {
            return string.Join(SEPARATOR, values);
        }
        private string ToString(double[] values)
        {
            var l = new List<string>();
            foreach (var val in values)
            {
                l.Add(val.ToString(CultureInfo.InvariantCulture));
            }
            return ToString(l.ToArray());
        }
        private string ToString(short[] values)
        {
            var l = new List<string>();
            foreach (var val in values)
            {
                l.Add(val.ToString(CultureInfo.InvariantCulture));
            }
            return ToString(l.ToArray());
        }
        private enum Fields
        {
            SerialNumber,
            TiltSensorCals,
            TiltSensorDataPre,
            TiltAxes,
            AxesIgnored,
            MountOffsetAxisOne,
            MountOffsetAxisTwo,
            ChannelNames,
            OffsetTolerancesLow,
            OffsetTolerancesHigh
        }
        private double [] GetTiltSensorCals(IDASCommunication das)
        {
            return das is ITiltSensorCalAware iTiltAware ? iTiltAware.TiltSensorCals : (new double[0]);
        }
        private short [] GetTiltSensorData(IDASCommunication das)
        {
            return new short[] { 0, 0, 0 };
        }
        public DASMonitorInfo(IDASCommunication das, IsoViewMode mode)
        {
            var keys = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
            foreach (var key in keys)
            {
                switch (key)
                {
                    case Fields.SerialNumber:
                        SerialNumber = das.SerialNumber;
                        break;
                    case Fields.TiltSensorCals:
                        TiltSensorCals = GetTiltSensorCals(das);
                        break;
                    case Fields.TiltSensorDataPre:
                        TiltSensorDataPre = GetTiltSensorData(das);
                        break;
                    case Fields.TiltAxes:
                        TiltAxes = GetTiltAxes(das);
                        break;
                    case Fields.AxesIgnored:
                        AxisIgnored = GetAxisIgnored(das);
                        break;
                    case Fields.MountOffsetAxisOne:
                        MountOffsetAxisOne = GetMountOffsetAxisOne(das);
                        break;
                    case Fields.MountOffsetAxisTwo:
                        MountOffsetAxisTwo = GetMountOffsetAxisTwo(das);
                        break;
                    case Fields.ChannelNames:
                        _channelNames = GetChannelNames(das, mode);
                        break;
                    case Fields.OffsetTolerancesLow:
                        _offsetTolerancesLow = GetOffsetTolerancemVLow(das);
                        break;
                    case Fields.OffsetTolerancesHigh:
                        _offsetTolerancesHigh = GetOffsetTolerancemVHigh(das);
                        break;
                }
            }
        }
        private double [] GetOffsetTolerancemVHigh(IDASCommunication das)
        {
            if (NoModules(das)) { return new double[0]; }
            var list = new List<double>();
            foreach (var module in das.ConfigData.Modules)
            {
                foreach (var ch in module.Channels)
                {
                    if (ch is IAnalogInputDASChannel aic)
                    {
                        list.Add(aic.OffsetToleranceHighMilliVolts);
                    }
                    else { list.Add(0); }
                }
            }
            return list.ToArray();
        }
        private double [] GetOffsetTolerancemVLow(IDASCommunication das)
        {
            if (NoModules(das)) { return new double[0]; }
            var list = new List<double>();
            foreach (var module in das.ConfigData.Modules)
            {
                foreach (var ch in module.Channels)
                {
                    if (ch is IAnalogInputDASChannel aic)
                    {
                        list.Add(aic.OffsetToleranceLowMilliVolts);
                    }
                    else { list.Add(0); }
                }
            }
            return list.ToArray();
        }
        private bool NoModules(IDASCommunication das)
        {
            return null == das.ConfigData || null == das.ConfigData.Modules || 0 == das.ConfigData.Modules.Length;
        }
        private double GetMountOffsetAxisTwo(IDASCommunication das)
        {
            return NoModules(das) ? float.NaN : das.ConfigData.Modules[0].MountOffsetAxisTwo;
        }
        private double GetMountOffsetAxisOne(IDASCommunication das)
        {
            return NoModules(das) ? float.NaN : das.ConfigData.Modules[0].MountOffsetAxisOne;
        }
        private int GetAxisIgnored(IDASCommunication das)
        {
            return NoModules(das) ? 0 : das.ConfigData.Modules[0].AxisIgnored;
        }
        private DFConstantsAndEnums.TiltAxes GetTiltAxes(IDASCommunication das)
        {
            return NoModules(das) ? DFConstantsAndEnums.TiltAxes.IXIYIZ : das.ConfigData.Modules[0].TiltAxes;
        }
        private string [] GetChannelNames(IDASCommunication das, IsoViewMode viewMode)
        {
            if(NoModules(das)) { return new string[0]; }
            var list = new List<string>();
            foreach (var mod in das.ConfigData.Modules)
            {
                foreach (var ch in mod.Channels)
                {
                    switch (viewMode)
                    {
                        case IsoViewMode.ISOOnly:
                            list.Add(ch.IsoChannelName);
                            break;
                        case IsoViewMode.ISOAndUserCode:
                            list.Add($"{ ch.IsoChannelName}\\{ch.UserChannelName}");
                            break;
                        case IsoViewMode.UserCodeOnly:
                            list.Add(ch.UserCode);
                            break;
                        case IsoViewMode.ChannelNameOnly:
                            list.Add(ch.UserChannelName);
                            break;
                    }
                }
            }
            return list.ToArray();
        }
        public DASMonitorInfo(string path)
        {
            try
            {
                ReadFromFile(path);
            }
            catch(Exception ex)
            {
                APILogger.Log(ex);
            }
        }
    }
}