//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace OpenTap
{
    /// <summary>
    /// A <see cref="Connection"/> that has an RF cable loss parameter.
    /// </summary>
    [Display("RF Connection", "Directionless RF connection modeled as a set of cable loss points with frequency and loss values.", "Basic Connections")]
    public class RfConnection : Connection
    {
        /// <summary>
        /// Represents a point in a frequency/loss table.
        /// </summary>
        public class CableLossPoint : ValidatingObject
        {
            internal class FrequencyComparer : IComparer<CableLossPoint>
            {
                public static readonly FrequencyComparer Instance = new FrequencyComparer();

                public int Compare(CableLossPoint x, CableLossPoint y)
                {
                    if (ReferenceEquals(x, y))
                        return 0;
                    if (ReferenceEquals(null, y))
                        return 1;
                    if (ReferenceEquals(null, x))
                        return -1;
                    var frequencyComparison = x.Frequency.CompareTo(y.Frequency);
                    return frequencyComparison;
                    
                }
            }
            
            /// <summary> Returns an error if the frequency is less 0. </summary>
            protected override string GetError(string propertyName = null)
            {
                if (propertyName == nameof(Frequency) || propertyName == null)
                {
                    if (Frequency < 0)
                        return "Frequency must not be negative";
                }
                return null;
            }

            /// <summary>
            /// The frequency at which the loss is applied.
            /// </summary>
            [Unit("Hz", true)]
            public double Frequency { get; set; }
            /// <summary>
            /// The cable loss in dB.
            /// </summary>
            [Unit("dB")]
            public double Loss { get; set; }

            static readonly UnitAttribute frequencyUnit = typeof(CableLossPoint).GetProperty(nameof(Frequency)).GetAttribute<UnitAttribute>();
            static readonly UnitAttribute lossUnit = typeof(CableLossPoint).GetProperty(nameof(Loss)).GetAttribute<UnitAttribute>();

            /// <summary>
            /// Prints the loss point, e.g "10dB @ 100kHz".
            /// </summary>
            /// <returns></returns>
            public override string ToString()
            {
                var freqParser = new NumberFormatter(CultureInfo.CurrentCulture, frequencyUnit) { IsCompact = true };
                var lossParser = new NumberFormatter(CultureInfo.CurrentCulture, lossUnit) { IsCompact = true };

                return $"{lossParser.FormatNumber(Loss)} @{freqParser.FormatNumber(Frequency)}";
            }
        }

        /// <summary>
        /// The cable loss in dB between the two ports.
        /// </summary>
        [Display("Cable Loss")]
        public List<CableLossPoint> CableLoss { get; set; }
       

        /// <summary>
        /// Initializes a new instance of the <see cref="RfConnection"/> class.
        /// </summary>
        public RfConnection()
        {
            Name = "RF";
            CableLoss = new List<CableLossPoint>();
            Rules.Add(() => CableLoss.Any(c => c.Frequency < 0) == false, "Frequency must not be negative.", "CableLoss");
            Rules.Add(() => CableLoss.Count == CableLoss.Select(c => c.Frequency).Distinct().Count(), "A frequency may only be specified once.", "CableLoss");
            
            Rules.Add(() => PortDirectionsAreGood(), () => "An output port cannot be connected to another output port.", "Port1");
            Rules.Add(() => PortDirectionsAreGood(), () => "An output port cannot be connected to another output port.", "Port2");
        }

        private bool PortDirectionsAreGood()
        {
            return (Port1 == null) || (Port2 == null) || ((Port1 is OutputPort) ? !(Port2 is OutputPort) : true);
        }

        /// <summary>
        /// Given a particular frequency, an interpolated CableLoss value is returned, based on CableLoss values at the two closest frequencies.
        /// If exact frequency is defined, that CableLoss value will be returned.
        /// </summary>
        public double GetInterpolatedCableLoss(double frequency)
        {
            // If there are no cable loss points configured assume no loss.
            if (CableLoss.Count == 0) return 0.0;
            
            // If there is only one point there is nothing to interpolate
            if (CableLoss.Count == 1) return CableLoss[0].Loss;
            
            // Sort the loss table by frequency.
            // only do so if it actually needs to be sorted.
            if(!CableLoss.IsSortedBy(loss => loss.Frequency))
                CableLoss = CableLoss.OrderBy(loss => loss.Frequency).ToList();
            
            // for searching.
            var loss = new CableLossPoint { Frequency = frequency };
            
            // Find the index by binary search.
            // if the result >= 0 it means an exact match was found.
            // if the result <0 it means that the match lies somewhere between two points or at the bounds.
            int index = CableLoss.BinarySearch(loss, CableLossPoint.FrequencyComparer.Instance);
            
            // Calculate loss using linear interpolation or nearest neighbour when outside the bounds.
            if (index < 0)
            {
                // the match is at the bounds.
                // that means the index found is the first element greater than the searched frequency.
                // hence 0 -> the result is less than the minimum (nearest interpolation)
                // and count -> the result is greater than the maximum. (nearest interpolation).
                // otherwise interpolate between index -1 and index.
                index = ~index;
            }
            else
            { 
                // exact match.
                return CableLoss[index].Loss;
            }
            if (index == 0)
                return CableLoss[0].Loss;
            if (index == CableLoss.Count)
                return CableLoss[index - 1].Loss;
            
            CableLossPoint below = CableLoss[index - 1]; //Check for below, or if value exists.
            CableLossPoint above = CableLoss[index];

           // linear interpolation.
           return below.Loss + (frequency - below.Frequency) * (above.Loss - below.Loss) / (above.Frequency - below.Frequency);
           
        }
    }
}