/*
 * DTS.Slice.Control.Event.Module.Channel.SaeJ211Filter.cs
 * 
 * Copyright © 2009
 * Diversified Technical Systems, Inc.
 * All Rights Reserved
 */

using System;
using DTS.Common.DAS.Concepts.DAS.Channel;
using DTS.Common.Utilities;
using DTS.Common.Utilities.DotNetProgrammingConstructs;
using DTS.Common.Utilities.Logging;
using DTS.Common.Utilities.SaeJ211;

namespace DTS.Slice.Control
{
    public partial class Event
    { // *** see DTS.Slice.Control.Event.cs ***
        public partial class Module
        { // *** see DTS.Slice.Control.Event.Module.cs ***
            public partial class Channel
            { // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
                /// <summary>
                /// Base class for all SaeJ211-based event module channel filters.  It is intended
                /// that fixed-filter-setting filters be derived from this class that will set their
                /// filter setting using the protected constructor.
                /// </summary>
                public class SaeJ211Filter
                    : Filter
                {
                    public SaeJ211Filter(SaeJ211Filter originalFilter)
                    {
                        OriginalType = originalFilter.OriginalType;
                        _CutoffFrequencyHz.Value = originalFilter.CutoffFrequencyHz;
                    }
                    /// <summary>
                    /// Initialize an instance of the DTS.Utility.SaeJ211Filter class.
                    /// </summary>
                    /// 
                    /// <param name="originalType">
                    /// The <see cref="ChannelFilter"/> to be applied by this filter (ad hoc
                    /// filters that correspond to CFC values will be converted to the CFC, hence the
                    /// "original" qualification). 
                    /// </param>
                    /// 
                    public SaeJ211Filter(ChannelFilter originalType)
                    {
                        try
                        {
                            switch (OriginalType = originalType)
                            {   //
                                // Try to set the frequency value according to type.  Note that we can't set to
                                // "ad hoc" using this particular constructor as we don't know what frequency
                                // should be associated with it.
                                //
                                case ChannelFilter.AdHoc:
                                    throw new Exception("cannot initialize SaeJ211 filter using only ChannelFilter of type " + OriginalType.ToString());

                                default:
                                    _CutoffFrequencyHz.Value = (double)originalType;
                                    break;
                            }
                        }

                        catch (System.Exception ex)
                        {
                            throw new Exception("encountered problem constructing " + GetType().FullName, ex);
                        }
                    }

                    /// <summary>
                    /// Initialize an instance of the DTS.Utility.SaeJ211Filter class.
                    /// </summary>
                    /// 
                    ///<param name="adHocFrequency">
                    ///The <see cref="double"/> ad hoc frequency of this filter.
                    /// </param>
                    ///
                    public SaeJ211Filter(double cutoffFrequencyHz)
                    {
                        try
                        {
                            OriginalType = ChannelFilter.AdHoc;
                            _CutoffFrequencyHz.Value = cutoffFrequencyHz;
                        }

                        catch (System.Exception ex)
                        {
                            throw new Exception("encountered problem constructing " + GetType().FullName, ex);
                        }
                    }

                    /// <summary>
                    /// Get <see cref="Boolean"/> value indicating whether or not this filter matches one of the
                    /// specified CFC values.
                    /// </summary>
                    override public bool IsCfc
                    {
                        get
                        {
                            try
                            {   //
                                // If we're not unfiltered and we're not ad hoc, then we
                                // must be CFC-compliant.
                                //
                                return Type != ChannelFilter.Unfiltered
                                    && Type != ChannelFilter.AdHoc;
                            }

                            catch (System.Exception ex)
                            {
                                throw new Exception("encountered problem determining whether or not filter corresponds to a CFC value", ex);
                            }
                        }
                    }

                    /// <summary>
                    /// Convert the specified frequency into a ChannelFilter type.
                    /// </summary>
                    /// 
                    /// <param name="frequency">
                    /// The <see cref="double"/> frequency to be converted.
                    /// </param>
                    /// 
                    /// <returns>
                    /// The best matching <see cref="ChannelFilter"/> type.  A CFC match is preferred;
                    /// if one does not exist, "ad hoc" will be selected (if frequency > 0).
                    /// </returns>
                    /// 
                    private ChannelFilter ConvertFrequencyToChannelFilter(double frequency)
                    {
                        try
                        {
                            var matchingFilterType = ChannelFilter.Unfiltered;
                            if (frequency > 0)
                            {
                                matchingFilterType = ChannelFilter.AdHoc;
                                var cfcCoder = new CfcValueAttributeCoder();
                                foreach (int filterValue in Enum.GetValues(typeof(ChannelFilter)))
                                    if (frequency == filterValue)
                                        matchingFilterType = (ChannelFilter)filterValue;
                            }
                            return matchingFilterType;
                        }
                        catch (System.Exception ex)
                        {
                            throw new Exception("encountered problem trying to match frequency to CRC value", ex);
                        }
                    }

                    /// <summary>
                    /// Get the "best fitting" <see cref="ChannelFilter"/> value for this filter.
                    /// </summary>
                    override public ChannelFilter Type
                    {
                        get
                        {
                            try
                            {
                                var actualType = OriginalType;

                                switch (OriginalType)
                                {
                                    case ChannelFilter.AdHoc:
                                        actualType = ConvertFrequencyToChannelFilter(CutoffFrequencyHz);
                                        break;

                                    default:
                                        //
                                        // Don't waste time on stuff we don't need to convert.
                                        //
                                        actualType = OriginalType;
                                        break;
                                }

                                return actualType;
                            }

                            catch (System.Exception ex)
                            {
                                throw new Exception("encountered problem determining filter type", ex);
                            }
                        }
                    }

                    public char IsoDescription => new IsoDescriptionAttributeCoder().DecodeAttributeValue(OriginalType)[0];

                    /// <summary>
                    /// Get the <see cref="double"/> cutoff frequency value.
                    /// </summary>
                    override public double CutoffFrequencyHz => _CutoffFrequencyHz.Value;

                    private readonly Property<double> _CutoffFrequencyHz
                        = new Property<double>(
                            typeof(SaeJ211Filter).Namespace + ".SaeJ211Filter.CutoffFrequencyHz",
                            -1,
                            true
                        );

                    /// <summary>
                    /// The <see cref="ChannelFilter"/>ing done by this object.
                    /// </summary>
                    public ChannelFilter OriginalType
                    {
                        get => _OriginalType.Value;
                        private set => _OriginalType.Value = value;
                    }
                    private readonly Property<ChannelFilter> _OriginalType
                        = new Property<ChannelFilter>(
                            typeof(SaeJ211Filter).Namespace + ".SaeJ211Filter.OriginalType",
                            ChannelFilter.Unfiltered,
                            false
                        );

                    private const string CutoffFrequencyUnitString = "Hz";

                    /// <summary>
                    /// The <see cref="string"/> name of this filter.
                    /// </summary>
                    public override string Name
                    {
                        get
                        {
                            try
                            {
                                if (null == _Name)
                                {
                                    var cult = new System.Globalization.CultureInfo("");
                                    _Name = ChannelFilter.AdHoc == Type
                                            ? CutoffFrequencyHz.ToString(cult) + CutoffFrequencyUnitString
                                            : new DescriptionAttributeCoder<ChannelFilter>().DecodeAttributeValue(Type);
                                }
                                return _Name;
                            }

                            catch (System.Exception ex)
                            {
                                throw new Exception("encountered problem generating name string for " + GetType().FullName, ex);
                            }
                        }
                    }
                    private string _Name = null;

                    /// <summary>
                    /// Apply this filter to the specified channel.
                    /// </summary>
                    /// 
                    /// <param name="channel">
                    /// The <see cref="DTS.Slice.Control.Event.Module.Channel"/> to be filtered.
                    /// </param>
                    /// 
                    /// <returns>
                    /// The array of filtered <see cref="double"/> EU data.
                    /// </returns>
                    /// 
                    public override double[] Apply
                        (
                        Channel channel,
                        DataDisplayUnits displayUnits,
                        bool bUseLegacyTDCSoftwareFilterAdjustment
                        )
                    {
                        try
                        {
                            var filterUtility = new FilterUtility();
                            filterUtility.Cfc = Type;
                            filterUtility.AdHocFrequency = CutoffFrequencyHz;
                            filterUtility.SampleRate = channel.ParentModule.SampleRateHz;

                            double[] data;
                            switch (displayUnits)
                            {
                                case DataDisplayUnits.Adc:
                                    if (channel.UnfilteredData is Serialization.SliceRaw.File.PersistentChannel)
                                    {
                                        if (channel.UnfilteredData is ILargeDataAware)
                                            if (!(channel.UnfilteredData as ILargeDataAware).IsDataArraySized)
                                                throw new Serialization.SliceRaw.File.PersistentChannel.DataTooBigForArrayException("Data is too big to be viewed or filtered.");

                                        using (var persistentUnfilteredData =
                                            channel.UnfilteredData as Serialization.SliceRaw.File.PersistentChannel)// ;
                                        {

                                            var dataCount = persistentUnfilteredData.Count;
                                            data = new double[dataCount];
                                            for (var i = 0; i < dataCount; i++)
                                                data[i] = persistentUnfilteredData[(ulong) i];
                                        }
                                            //persistentUnfilteredData.Dispose();
                                    }
                                    else if (channel.UnfilteredData is Serialization.TDAS.File.PersistentChannel)
                                    {
                                        if (channel.UnfilteredData is ILargeDataAware)
                                            if (!(channel.UnfilteredData as ILargeDataAware).IsDataArraySized)
                                                throw new Serialization.TDAS.File.PersistentChannel.DataTooBigForArrayException("Data is too big to be viewed or filtered.");

                                        using (var persistentUnfilteredData =
                                            channel.UnfilteredData as Serialization.TDAS.File.PersistentChannel)// ;
                                        {

                                            var dataCount = persistentUnfilteredData.Count;
                                            data = new double[dataCount];
                                            for (var i = 0; i < dataCount; i++)
                                                data[i] = persistentUnfilteredData[(ulong)i];
                                        }
                                        //persistentUnfilteredData.Dispose();
                                    }

                                    else data = channel.UnfilteredData.ConvertAll<double>(delegate(short datum) { return (double)datum; }).ToArray();
                                    break;

                                case DataDisplayUnits.Eu:
                                    data = channel.UnfilteredDataEu.ToArray();
                                    break;

                                case DataDisplayUnits.Mv:
                                    data = channel.UnfilteredDataMv.ToArray();
                                    break;

                                default:
                                    throw new NotImplementedException("handling for display unit type \"" + displayUnits.ToString() + "\" has not been implemented");
                            }

                    return filterUtility.ApplyFilter(data, new FilterUtility.InvalidDataDelegate(delegate()
                    {
                        var msg = string.Format("Invalid data in channel: {0}.", channel.ChannelDescriptionString);
                        //var dr = System.Windows.Forms.MessageBox.Show(msg, "Warning", System.Windows.Forms.MessageBoxButtons.OK);
                        APILogger.Log(msg);
                        throw new Exception(msg);
                    }), bUseLegacyTDCSoftwareFilterAdjustment);
                }

                catch ( System.Exception ex )
                {
                    throw new Exception( "encountered problem applying filter \"" + Name + "\" to channel", ex );
                }
            }

                    /// <summary>
                    /// Apply this filter to the specified channel.
                    /// </summary>
                    /// 
                    /// <param name="channel">
                    /// The <see cref="DTS.Slice.Control.Event.Module.Channel"/> to be filtered.
                    /// </param>
                    /// <param name="bUseLegacyTDCSoftwareFilterAdjustment">
                    /// controls whether filtered data is adjusted by one sample to match TDC behavior
                    /// 8747
                    /// </param>
                    /// <returns>
                    /// The array of filtered <see cref="double"/> EU data.
                    /// </returns>
                    public override double[] Apply
                (
                double [] data,
                double sampleRate,
                bool bUseLegacyTDCSoftwareFilterAdjustment
                )
            {
                try
                {
                    var filterUtility = new FilterUtility();
                    filterUtility.Cfc = Type;
                    filterUtility.AdHocFrequency = CutoffFrequencyHz;
                    filterUtility.SampleRate = sampleRate;                   

                    return filterUtility.ApplyFilter(data, new FilterUtility.InvalidDataDelegate(delegate()
                    {
                        var msg = string.Format("Invalid data in channel.");
                        //var dr = System.Windows.Forms.MessageBox.Show(msg, "Warning", System.Windows.Forms.MessageBoxButtons.OK);
                        APILogger.Log(msg);
                        throw new Exception(msg);
                    }), bUseLegacyTDCSoftwareFilterAdjustment);
                }

                catch (System.Exception ex)
                {
                    throw new Exception("encountered problem applying filter \"" + Name + "\" to channel", ex);
                }
            }
            /// <summary>
            /// Generate a string representation of this object.
            /// </summary>
            /// 
            /// <returns>
            /// A <see cref="string"/> representation of this object.
            /// </returns>
            /// 
            public override string ToString( )
            {
                try
                {
                    return Name;
                }

                catch ( System.Exception ex )
                {
                    throw new Exception( "encountered problem generating the string value for " + GetType( ).FullName, ex );
                }
            }

            /// <summary>
            /// Generate a string representation of this object.
            /// </summary>
            /// 
            /// <returns>
            /// A <see cref="string"/> representation of this object.
            /// </returns>
            /// 
            public override string  ToBaseString()
            {
                try
                {
                    return Name;
                }

                catch (System.Exception ex)
                {
                    throw new Exception("encountered problem generating the string value for " + GetType().FullName, ex);
                }
            }
            /// <summary>
            /// Determines whether this filter and the specified filter are the same.
            /// </summary>
            /// 
            /// <param name="obj">
            /// The filter <see cref="object"/> to be compared with this one.
            /// </param>
            /// 
            /// <returns>
            /// <see cref="bool"/> true if the filters are the same, false otherwise.
            /// </returns>
            ///
            public override bool Equals( object obj )
            {
                try
                {
                    if (null == obj as SaeJ211Filter) { return false; }
                    return Name.Equals( ( obj as SaeJ211Filter ).Name, StringComparison.OrdinalIgnoreCase );
                }

                catch ( System.Exception ex )
                {
                    throw new Exception(
                        "encountered problem equality checking filter \""
                        + Name
                        + "\" with filter "
                        + ( null != obj && obj is SaeJ211Filter && null != ( obj as SaeJ211Filter ).Name ? "\"" + ( obj as SaeJ211Filter ).Name + "\"" : "<null>" ), ex );
                }
            }
            /// <summary>
            /// provides an index for a given <see cref="DTS.Slice.Control.Event.Module.Channel.SaeJ211Filter"/>
            /// since we override Equals we should override get hashcode to ensure that any to objects considered
            /// "Equal" are also hashed to the same location, however the result index does not need to be unique 
            /// between non equal objects.  
            /// 6/10/2010 - dtm
            /// </summary>
            /// <returns></returns>
            public override int GetHashCode()
            {
                return Name.ToLower().GetHashCode();
            }
            /// <summary>
            /// Create a filter from the specified string.
            /// </summary>
            /// 
            /// <param name="serialization">
            /// The <see cref="string"/> representation of the filter to be instantiated.
            /// </param>
            /// 
            /// <returns>
            /// A <see cref="DTS.Slice.Control.Event.Module.Channel.Filter"/> equivalent of the 
            /// specified string.  Throws an exception if object could not be created.
            /// </returns>
            /// 
            static public Filter Parse( string serialization )
            {
                try
                {
                    Filter filter = null;

                    if ( !string.IsNullOrEmpty( serialization ) )
                    {
                        if ( serialization.Contains( CutoffFrequencyUnitString ) )
                        {
                            var cult = new System.Globalization.CultureInfo("");
                            filter = new DefaultSaeJ211Filter(double.Parse(serialization.Replace(CutoffFrequencyUnitString, ""), cult));
                        }

                        else
                        {
                            foreach ( ChannelFilter filterType in Enum.GetValues( typeof( ChannelFilter ) ) )
                            {
                                var coder = new DescriptionAttributeCoder<ChannelFilter>( );
                                if ( coder.DecodeAttributeValue( filterType ).Equals( serialization, StringComparison.OrdinalIgnoreCase ) )
                                    filter = new DefaultSaeJ211Filter( filterType );
                            }
                        }
                    }

                    return ( null != filter ? filter : new SaeJ211Filter( ChannelFilter.Unfiltered ) );
                }

                catch ( System.Exception ex )
                {
                    throw new Exception( "encountered problem parsing string " + ( null != serialization ? "\"" + serialization + "\"" : "<NULL>" ) + " into filter", ex );
                }
            }
        }
    }
    }
    }

}