using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace Raytheon.Units
{
   /// <summary>
   /// This class represents energy.  
   /// 
   /// It has no constructors.  Instead, it provides multiple methods for creating objects of this 
   /// type.  Those methods are of the form FromXXX, where XXX is a unit (e.g. FromHertz).
   /// 
   /// Properties (e.g. Hertz) are provided to convert the value to other units and return as type 
   /// double.
   /// </summary>
   [Serializable]
    [DataContract]
    public class Frequency
    {
        public enum Unit
        {
            Hertz,
            KiloHertz,
            MegaHertz,
            GigaHertz
        }

        public static IDictionary<Unit, List<string>> UnitAbbreviations = new Dictionary<Unit, List<string>>()
        {
            {Unit.Hertz, new List<string>(){ "Hz" } },
            {Unit.KiloHertz, new List<string>(){ "kHz" } },
            {Unit.MegaHertz, new List<string>(){ "MHz" } },
            {Unit.GigaHertz, new List<string>(){ "GHz" } },
        };

        private const Unit DefaultUnits = Unit.Hertz;

        [DataMember(Name = "Frequency", IsRequired = true)]
        private double _frequency; // Hertz

        // map: unit => abbreviation, conversion method and property
        private static IDictionary<Unit, UnitInfo<Frequency>> _unitInfo = new Dictionary<Unit, UnitInfo<Frequency>>()
        {
            { Unit.Hertz, new UnitInfo<Frequency>(UnitAbbreviations[Unit.Hertz], FromHertz, typeof(Frequency).GetProperty("Hertz").GetGetMethod()) },
            { Unit.KiloHertz, new UnitInfo<Frequency>(UnitAbbreviations[Unit.KiloHertz], FromKiloHertz, typeof(Frequency).GetProperty("KiloHertz").GetGetMethod()) },
            { Unit.MegaHertz, new UnitInfo<Frequency>(UnitAbbreviations[Unit.MegaHertz], FromMegaHertz, typeof(Frequency).GetProperty("MegaHertz").GetGetMethod()) },
            { Unit.GigaHertz, new UnitInfo<Frequency>(UnitAbbreviations[Unit.GigaHertz], FromGigaHertz, typeof(Frequency).GetProperty("GigaHertz").GetGetMethod()) }
        };

        /// <summary>
        /// Prevents a default instance of the <see cref="Frequency"/> class from being created.  
        /// Use FromXXX methods to create objects of this type.
        /// </summary>
        /// <exception cref="System.Exception">No one should be calling this, it is only here to prevent users from creating default object</exception>
        private Frequency()
        {
            throw new InvalidOperationException("No one should be calling this, it is only here to prevent users from creating default object");
        }

        /// <summary>
        /// ctor used by this class to create objects in FromXXX methods 
        /// </summary>
        /// <param name="frequency">The frequency - Hertz.</param>
        private Frequency(double frequency)
        {
            _frequency = frequency;
        }

        #region conversion properties

        public double GigaHertz
        {
            get { return _frequency / Constants.GIGA; }
        }

        public double Hertz
        {
            get { return _frequency; }
        }

        public double KiloHertz
        {
            get { return _frequency / Constants.KILO; }
        }

        public double MegaHertz
        {
            get { return _frequency / Constants.MEGA; }
        }

        #endregion

        #region creation methods

        /// <summary>
        /// Returns Frequency object interpreting passed value as Hertz
        /// </summary>
        /// <param name="frequency">Hertz</param>
        /// <returns></returns>
        public static Frequency FromGigaHertz(double frequency)
        {
            return new Frequency(frequency * Constants.GIGA);
        }

        /// <summary>
        /// Returns Frequency object interpreting passed value as Hertz
        /// </summary>
        /// <param name="frequency">Hertz</param>
        /// <returns></returns>
        public static Frequency FromHertz(double frequency)
        {
            return new Frequency(frequency);
        }

        /// <summary>
        /// Returns Frequency object interpreting passed value as Hertz
        /// </summary>
        /// <param name="frequency">Hertz</param>
        /// <returns></returns>
        public static Frequency FromKiloHertz(double frequency)
        {
            return new Frequency(frequency * Constants.KILO);
        }

        /// <summary>
        /// Returns Frequency object interpreting passed value as Hertz
        /// </summary>
        /// <param name="frequency">Hertz</param>
        /// <returns></returns>
        public static Frequency FromMegaHertz(double frequency)
        {
            return new Frequency(frequency * Constants.MEGA);
        }

        #endregion

        public override bool Equals(object obj)
        {
            Frequency e = obj as Frequency;

            return (e == null) ? false : (this._frequency == e._frequency);
        }

        public override int GetHashCode()
        {
            return _frequency.GetHashCode();
        }

        #region binary operators

        // not implementing %, &, |, ^, <<, >>

        
        public static Frequency operator +(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot add a null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot add null Frequency");

            return new Frequency(left._frequency + right._frequency);
        }

        
        public static Frequency operator -(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot subtract a null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot subtract a null Frequency");

            return new Frequency(left._frequency - right._frequency);
        }

        
        public static Frequency operator *(Frequency frequency, double scalar)
        {
            if (null == frequency)
                throw new ArgumentNullException("frequency", "Cannot multiply a null Frequency");

            return new Frequency(frequency._frequency * scalar);
        }

        
        public static Frequency operator *(double scalar, Frequency frequency)
        {
            if (null == frequency)
                throw new ArgumentNullException("frequency", "Cannot multiply a null Frequency");

            return new Frequency(scalar * frequency._frequency);
        }

        
        public static Frequency operator /(Frequency frequency, double scalar)
        {
            if (null == frequency)
                throw new ArgumentNullException("frequency", "Cannot divide a null Frequency");

            if (0.0 == scalar)
                throw new DivideByZeroException("Cannot divide Frequency by 0");

            return new Frequency(frequency._frequency / scalar);
        }

        #endregion

        #region comparison operators

        public static bool operator ==(Frequency left, Frequency right)
        {
            bool bReturn = false;
            if (object.ReferenceEquals(left, null))
            {
                if (object.ReferenceEquals(right, null))
                {
                    //both are null, so we are ==
                    bReturn = true;
                }
            }
            else
            {
                if (!object.ReferenceEquals(left, null) &&
                    !object.ReferenceEquals(right, null))
                {
                    bReturn = left._frequency == right._frequency;
                }
            }
            return bReturn;
        }

        public static bool operator !=(Frequency left, Frequency right)
        {
            return !(left == right);
        }

        
        public static bool operator <(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot compare null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot compare null Frequency");

            return (left._frequency < right._frequency);
        }

        
        public static bool operator >(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot compare null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot compare null Frequency");

            return (left._frequency > right._frequency);
        }

        
        public static bool operator <=(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot compare null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot compare null Frequency");

            return (left._frequency <= right._frequency);
        }

        
        public static bool operator >=(Frequency left, Frequency right)
        {
            if (null == left)
                throw new ArgumentNullException("left", "Cannot compare null Frequency");

            if (null == right)
                throw new ArgumentNullException("right", "Cannot compare null Frequency");

            return (left._frequency >= right._frequency);
        }

        #endregion

        #region operators with other classes

        // no operators right now

        #endregion

        #region parsing

        public static Frequency Parse(string s)
        {
            return Common.Parse(s, _unitInfo);
        }

        public static bool TryParse(string s, out Frequency value)
        {
            try
            {
                value = Frequency.Parse(s);
                return true;
            }
            catch (Exception)
            {
                value = null;
                return false;
            }
        }

        #endregion

        /// <summary>
        /// Returns a string appended with default units (e.g. "1.23 m/sec^2").
        /// </summary>
        /// <returns>
        /// A string that represents this instance
        /// </returns>
        public override string ToString()
        {
            return ToString(DefaultUnits);
        }

        /// <summary>
        /// overload that returns a string appended with specified units (e.g. "1.23 ft/sec^2").
        /// </summary>
        /// <param name="units"></param>
        /// <returns></returns>
        public string ToString(Unit units)
        {
            double value = (double)_unitInfo[units].PropertyGetter.Invoke(this, null);

            return $"{value} {_unitInfo[units].Abbreviation[0]}";
        }
    }
}