using System;
using System.Linq;
using DataPROWin7.DataModel.Classes.Hardware;
using DTS.Common.Converters;
using DTS.Common.Enums.Hardware;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.SharedResource.Strings;
using DTS.Common.Constant.DASSpecific;

namespace DataPROWin7
{
    public class ChannelRepresentation
    {
        public enum ChannelTypeEnum
        {
            SQUIB,
            TOMDigital,
            DigitalInput,
            Other
        }

        private readonly ChannelTypeEnum _channelType = ChannelTypeEnum.Other;

        public ChannelRepresentation(DataModel.DASHardware h, DTS.DASLib.Service.DASChannel c,
            int startingChannelNumber)
        {
            //adjust the starting channel number (which appears to be a DAS channel number) to a module channel number
            if (h.CareAboutModules)
            {
                startingChannelNumber = 1 + c.ModuleChannelNumber;
            }
            if (c is DTS.DASLib.Service.OutputSquibChannel)
            {
                startingChannelNumber = DoSquibConversion(startingChannelNumber);
                _channelType = ChannelTypeEnum.SQUIB;
            }
            else if (c is DTS.DASLib.Service.OutputTOMDigitalChannel)
            {
                _channelType = ChannelTypeEnum.TOMDigital;
            }
            else
            {
                if (((c as DTS.DASLib.Service.AnalogInputDASChannel).SupportedBridges.Length == 1) &&
                    ((c as DTS.DASLib.Service.AnalogInputDASChannel).SupportedBridges[0] ==
                     SensorConstants.BridgeType.DigitalInput))
                {
                    _channelType = ChannelTypeEnum.DigitalInput;
                }
            }

            ConvertChannelNumbers(h.DASTypeEnum, startingChannelNumber, h.SerialNumber, c.OwningModule.SerialNumber(),
                _channelType);
        }


        private int GetModuleChannelNumber(DataModel.HardwareChannel c)
        {
            if (null == c.Hardware)
            {
                return 1 + c.ChannelNumber;
            }
            var moduleChannelNumber = 0;
            var moduleArrayIndex = -1;

            foreach (var ch in c.Hardware.Channels)
            {
                if (ch.ModuleArrayIndex != moduleArrayIndex)
                {
                    moduleChannelNumber = 0;
                    moduleArrayIndex = ch.ModuleArrayIndex;
                }
                moduleChannelNumber++;
                if (ch.ChannelNumber == c.ChannelNumber)
                {
                    return moduleChannelNumber;
                }
            }
            return 1 + c.ChannelNumber;
        }

        public ChannelRepresentation(DataModel.HardwareChannel c, int startingChannelNumber, IDASHardware[] hardwares = null)
        {
            if (null != c.Hardware && c.Hardware.CareAboutModules)
            {
                startingChannelNumber = GetModuleChannelNumber(c);
            }
            if (c.IsSupportedBridgeType(SensorConstants.BridgeType.SQUIB))
            {
                startingChannelNumber = DoSquibConversion(startingChannelNumber);
                _channelType = ChannelTypeEnum.SQUIB;
            }
            else if (c.IsSupportedBridgeType(SensorConstants.BridgeType.TOMDigital))
            {
                _channelType = ChannelTypeEnum.TOMDigital;
            }
            else if (c.IsSupportedBridgeType(SensorConstants.BridgeType.DigitalInput))
            {
                _channelType = ChannelTypeEnum.DigitalInput;
            }

            var moduleSerialNumber = c.ModuleSerialNumber;
            var dasSerialNumber = c.Hardware.SerialNumber;

            var h = c.Hardware.GetHardware();
            if (h.StandIn)
            {
                dasSerialNumber = EnumDescriptionTypeConverter.GetEnumDescription(h.DASTypeEnum);
                switch (c.Hardware.DASTypeEnum)
                {
                    case HardwareTypes.TDAS_LabRack:
                    case HardwareTypes.TDAS_Pro_Rack:
                        break;
                    default:
                        moduleSerialNumber = dasSerialNumber;
                        break;
                }
            }
            else if (c.Hardware.IsPseudoRackModule() && c.Hardware.IsModule())
            {
                moduleSerialNumber = c.Hardware.SerialNumber;
                dasSerialNumber = c.Hardware.ParentDAS;
            }
            else if (c.Hardware.IsTSRAIRModule() && c.Hardware.IsModule())
            {
                moduleSerialNumber = c.Hardware.SerialNumber;
                dasSerialNumber = string.IsNullOrWhiteSpace(c.Hardware.ParentDAS) ?
                    c.Hardware.Connection.Split(new[] { "xEMB" }, StringSplitOptions.RemoveEmptyEntries)[0] :
                    c.Hardware.ParentDAS;
            }

            ConvertChannelNumbers(c.Hardware.DASTypeEnum, startingChannelNumber, dasSerialNumber, moduleSerialNumber,
                _channelType, hardwares);
            if (!c.Hardware.IsTSRAIR())
            {
                DASSerialNumber = dasSerialNumber;
            }
        }

        public string DASSerialNumber { get; set; } = string.Empty;

        public string SerialNumber //Module
        {
            get;
            set;
        } = string.Empty;

        public string ChannelNumberString { get; set; } = string.Empty;

        public int ChannelNumber { get; set; } = 0;

        private int DoSquibConversion(int squibChannelNumber)
        {
            Math.DivRem(squibChannelNumber, 8, out var remainder);
            switch (remainder)
            {
                case 1:
                    return 1;
                case 3:
                    return 2;
                case 5:
                    return 3;
                case 7:
                    return 4;
                default:
                    return 0;
            }
        }

        private void ConvertChannelNumbers(HardwareTypes dasType, int startingChannelNumber, string dasSerialNumber,
            string moduleSerialNumber,
            ChannelTypeEnum channelType, IDASHardware[] hardwares = null)
        {
            var displayChannelNumber = 0;
            switch (dasType)
            {
                case HardwareTypes.TDAS_Pro_Rack:
                case HardwareTypes.TDAS_LabRack:

                    if (string.IsNullOrWhiteSpace(moduleSerialNumber))
                    {
                        SerialNumber = StringResources.UnknownModule;
                        Math.DivRem(startingChannelNumber - 1, 8, out displayChannelNumber);
                    }
                    else
                    {
                        SerialNumber = moduleSerialNumber;
                        if (moduleSerialNumber.StartsWith("DIM"))
                        {
                            Math.DivRem(startingChannelNumber - 1, 16, out displayChannelNumber);
                        }
                        else
                        {
                            Math.DivRem(startingChannelNumber - 1, 8, out displayChannelNumber);
                        }
                    }
                    displayChannelNumber++;
                    DASSerialNumber = dasSerialNumber;
                    break;
                case HardwareTypes.SLICE2_TOM:
                case HardwareTypes.SLICE2_SLT:
                    // Start counting the Digital Output channels from 1
                    Math.DivRem(startingChannelNumber - 1, 8, out displayChannelNumber);
                    displayChannelNumber++;
                    SerialNumber = dasSerialNumber;
                    DASSerialNumber = StringResources.ChannelDASNA;
                    break;
                case HardwareTypes.G5VDS: // Start counting the Digital Input channels from 1
                case HardwareTypes.G5INDUMMY:
                    Math.DivRem(startingChannelNumber - 1, 32, out displayChannelNumber);
                    displayChannelNumber++;
                    SerialNumber = dasSerialNumber;
                    DASSerialNumber = StringResources.ChannelDASNA;
                    break;
                case HardwareTypes.SLICE1_G5Stack:
                    displayChannelNumber = startingChannelNumber;
                    SerialNumber = dasSerialNumber;
                    DASSerialNumber = StringResources.ChannelDASNA;
                    break;
                case HardwareTypes.SLICE_Base: //Is this the micro base?
                case HardwareTypes.SLICE_Micro_Base: //Is this the micro base?
                case HardwareTypes.SLICE1_5_Nano_Base: //This is for nano
                case HardwareTypes.SLICE1_5_Micro_Base: //This is for micro
                case HardwareTypes.SLICE_NANO_Base: //This is for nano
                    Math.DivRem(startingChannelNumber - 1, 3, out displayChannelNumber);
                    displayChannelNumber++;
                    if (string.IsNullOrWhiteSpace(moduleSerialNumber))
                    {
                        SerialNumber = StringResources.UnknownModule;
                    }
                    else
                    {
                        SerialNumber = moduleSerialNumber;
                    }
                    DASSerialNumber = dasSerialNumber;
                    break;
                case HardwareTypes.SLICE2_SLS:
                case HardwareTypes.SLICE2_SIM:
                case HardwareTypes.SLICE2_Base:
                case HardwareTypes.SLICE2_DIM:
                case HardwareTypes.SLICE2_SLD:
                case HardwareTypes.SLICE6_Base:
                case HardwareTypes.SLICE6_AIR:
                case HardwareTypes.SLICE6_AIR_BR:
                case HardwareTypes.SLICE_PRO_CAN_FD:

                    bool isPseudoDAS = false;
                    IDASHardware[] list = null;
                    if (null != hardwares)
                    {
                        list = hardwares;
                    }
                    else { list = DASHardwareList.GetAllHardware(); }
                    if (list.Any())
                    {
                        //13096 Unhandled exception clicking save in hardware disco (test setup)
                        var matches = from das in list where das.SerialNumber == dasSerialNumber select das;
                        if (matches.Any())
                        {
                            isPseudoDAS = matches.First().IsPseudoRack();
                        }
                    }
                    displayChannelNumber = startingChannelNumber;
                    SerialNumber = isPseudoDAS ? moduleSerialNumber : dasSerialNumber;
                    DASSerialNumber = dasSerialNumber;
                    break;
                case HardwareTypes.EMB_ANG_ARS:
                case HardwareTypes.EMB_ATM:
                case HardwareTypes.EMB_LIN_ACC_HI:
                case HardwareTypes.EMB_LIN_ACC_LO:
                    displayChannelNumber = startingChannelNumber;
                    SerialNumber = moduleSerialNumber; //dasSerialNumber;
                    DASSerialNumber = dasSerialNumber; //.Substring(0, dasSerialNumber.IndexOf('-'));
                    break;
                case HardwareTypes.TSR_AIR:
                case HardwareTypes.TSR_AIR_RevB:
                case HardwareTypes.DIR:
                case HardwareTypes.DKR:
                    Math.DivRem(startingChannelNumber - 1, 3, out displayChannelNumber);
                    displayChannelNumber++;
                    displayChannelNumber = startingChannelNumber;
                    if (string.IsNullOrWhiteSpace(moduleSerialNumber))
                    {
                        SerialNumber = StringResources.UnknownModule;
                    }
                    else
                    {
                        SerialNumber = moduleSerialNumber;
                    }
                    DASSerialNumber = dasSerialNumber;
                    break;
                case HardwareTypes.SLICE6_AIR_TC:
                    if (string.IsNullOrWhiteSpace(moduleSerialNumber))
                    {
                        var displayModuleNumber = Math.DivRem(startingChannelNumber - 1, SLICE6AIRTC.ThermocouplersPerModule, out displayChannelNumber);
                        SerialNumber = string.Format(StringResources.ModuleNumber, displayModuleNumber.ToString());
                    }
                    else
                    {
                        SerialNumber = moduleSerialNumber;
                        if (moduleSerialNumber.StartsWith(StringResources.StreamOut))
                        {
                            //Stream out
                            displayChannelNumber = 1;
                        }
                        else
                        {
                            //Thermocoupler
                            SerialNumber = dasSerialNumber;
                            displayChannelNumber = startingChannelNumber;
                        }
                    }
                    DASSerialNumber = dasSerialNumber;                    
                    break;
                default:
                    displayChannelNumber = startingChannelNumber;
                    SerialNumber = dasSerialNumber;
                    DASSerialNumber = dasSerialNumber;
                    break;
            }
            if (channelType == ChannelTypeEnum.SQUIB)
            {
                ChannelNumberString = StringResources.ChannelPrefix_Squib + displayChannelNumber.ToString("00");
            }
            else if (channelType == ChannelTypeEnum.TOMDigital)
            {
                ChannelNumberString = StringResources.ChannelPrefix_DigitalOut +
                                      displayChannelNumber.ToString("00");
            }
            else if (channelType == ChannelTypeEnum.DigitalInput)
            {
                ChannelNumberString = StringResources.ChannelPrefix_DigitalIn +
                                      displayChannelNumber.ToString("00");
            }
            else
            {
                ChannelNumberString = StringResources.ChannelPrefix_Other + displayChannelNumber.ToString("00");
            }
            ChannelNumber = displayChannelNumber;
        }
    }
}