using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DTS.SensorDB
{
    /// <summary>
    /// stolen from HLAPI
    /// this is only sparsely used in DataPRO currently and is mostly reference
    /// </summary>
    public class TSFInputChannelDescription
    {
        private int _version;
        public int Version { get { return _version; } set { _version = value; } }

        private TSFChannelDescription _parent;
        public TSFChannelDescription Parent { get { return _parent; } set { _parent = value; } }

        private int _source;
        public int Source { get { return _source; } set { _source = value; } }

        private ulong _crc32;
        public ulong CRC32 { get { return _crc32; } set { _crc32 = value; } }

        private bool _analogInfoValid;
        public bool AnalogInfoValid { get { return _analogInfoValid; } set { _analogInfoValid = value; } }

        /// <summary>
        /// HLAPI_INPUT_TYPE
        /// </summary>
        private char _analogChannelType;
        public char AnalogChannelType { get { return _analogChannelType; } set { _analogChannelType = value; } }

        /// <summary>
        /// See HLAPI_INPUT_FILTER_MODE
        /// </summary>
        private char _analogChannelFilterMode;
        public char AnalogChannelFilterMode { get { return _analogChannelFilterMode; } set { _analogChannelFilterMode = value; } }

        /// <summary>
        /// See HLAPI_INPUT_OFFSET_MODE
        /// </summary>
        private char _analogChannelOffsetMode;
        public char AnalogChannelOffsetMode { get { return _analogChannelOffsetMode; } set { _analogChannelOffsetMode = value; } }

        /// <summary>
        /// See HLAPI_INPUT_SHUNT_MODE
        /// </summary>
        private char _analogChannelShuntMode;
        public char AnalogChannelShuntMode { get { return _analogChannelShuntMode; } set { _analogChannelShuntMode = value; } }

        private double _analogExcitationVoltage;
        public double AnalogExcitationVoltage { get { return _analogExcitationVoltage; } set { _analogExcitationVoltage = value; } }

        private double _analogGain;
        public double AnalogGain { get { return _analogGain; } set { _analogGain = value; } }

        private int _analogShuntResistanceOhms;
        public int AnalogShuntResistanceOhms { get { return _analogShuntResistanceOhms; } set { _analogShuntResistanceOhms = value; } }

        private int _analogShuntEmulationOhms;
        public int AnalogShuntEmulationOhms { get { return _analogShuntEmulationOhms; } set { _analogShuntEmulationOhms = value; } }

        private double _analogShuntEU;
        public double AnalogShuntEU { get { return _analogShuntEU; } set { _analogShuntEU = value; } }

        private double _analogSensitivity;
        public double AnalogSensitivity { get { return _analogSensitivity; } set { _analogSensitivity = value; } }

        private char _analogSensitivityUnits;
        public char AnalogSensitivityUnits { get { return _analogSensitivityUnits; } set { _analogSensitivityUnits = value; } }

        private string _analogEULabel;
        public string AnalogEULabel { get { return _analogEULabel; } set { _analogEULabel = value; } }

        private bool _analogInvertData;
        public bool AnalogInvertData { get { return _analogInvertData; } set { _analogInvertData = value; } }

        private bool _digitalInfoValid;
        public bool DigitalInfoValid { get { return _digitalInfoValid; } set { _digitalInfoValid = value; } }

        private bool _realtimeInfoValid;
        public bool RealtimeInfoValid { get { return _realtimeInfoValid; } set { _realtimeInfoValid = value; } }

        private bool _useForRealtime;
        public bool UseForRealtime { get { return _useForRealtime; } set { _useForRealtime = value; } }

        private static object MyLock = new object();

        private List<short> _realtimeADC = new List<short>();
        public short[] RealtimeADC
        {
            get { lock (MyLock) { return _realtimeADC.ToArray(); } }
            set { lock (MyLock) { _realtimeADC = new List<short>(value); } }
        }

        public int RealtimeSamples
        {
            get { lock (MyLock) { return RealtimeADC.Length; } }
        }


        public TSFInputChannelDescription() { }
        public TSFInputChannelDescription(TSFInputChannelDescription copy, TSFChannelDescription channel)
        {
            _analogChannelFilterMode = copy._analogChannelFilterMode;
            _analogChannelOffsetMode = copy._analogChannelOffsetMode;
            _analogChannelShuntMode = copy._analogChannelShuntMode;
            _analogChannelType = copy._analogChannelType;
            _analogEULabel = copy._analogEULabel;
            _analogExcitationVoltage = copy._analogExcitationVoltage;
            _analogGain = copy._analogGain;
            _analogInfoValid = copy._analogInfoValid;
            _analogInvertData = copy._analogInvertData;
            _analogSensitivity = copy._analogSensitivity;
            _analogSensitivityUnits = copy._analogSensitivityUnits;
            _analogShuntEmulationOhms = copy._analogShuntEmulationOhms;
            _analogShuntEU = copy._analogShuntEU;
            _analogShuntResistanceOhms = copy._analogShuntResistanceOhms;
            _crc32 = copy._crc32;
            _digitalInfoValid = copy._digitalInfoValid;
            _parent = channel;
            _realtimeADC = new List<short>();
            _realtimeInfoValid = false;
            _source = copy._source;
            _useForRealtime = copy._useForRealtime;
            _version = copy._version;
        }
    }
}