using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Newtonsoft.Json;
using PolynomialTask.Exceptions;

namespace PolynomialTask
{
    class PolynomialType
    {
        /// <summary>
        /// Key is degree, value is coefficient
        /// </summary>
        public Dictionary<int, double> Polynomial { get; private set; }
        public int DegreeOfPolynomial { get; private set; }
        private static Random _random;
        static PolynomialType()
        {
            _random = new Random();
        }
        /// <summary>
        /// Determines whether polynomial contains specified degree
        /// </summary>
        /// <param name="degree"></param>
        /// <returns></returns>
        public bool ContainsDegree(int degree)
        {
            return Polynomial.ContainsKey(degree);
        }
        /// <summary>
        /// Determines whether polynomial contains specified coefficient
        /// </summary>
        /// <param name="coefficient"></param>
        /// <returns></returns>
        public bool ContainsCoefficient(double coefficient)
        {
            return Polynomial.ContainsValue(coefficient);
        }
        /// <summary>
        /// Creates polynomial that equals to 0
        /// </summary>
        public PolynomialType()
        {
            Polynomial = new Dictionary<int, double> { {0, 0.0 } };
            DegreeOfPolynomial = 0;
        }
        /// <summary>
        /// Creates polynomial with custom degree
        /// </summary>
        public PolynomialType(int degree)
        {
            Polynomial = new Dictionary<int, double> ();
            int digitNumber = 100;
            //PolynomialType polynomial = new PolynomialType();
            for (int i = 1; i <= degree; i++)
            {
                //Add(i, _random.NextDouble() * digitNumber);
                Polynomial.Add(i, _random.NextDouble() * digitNumber);
            }
            DegreeOfPolynomial = FindDegreeOfPolynomial(Polynomial);
        }
        /// <summary>
        /// Creates polynomial from custom data
        /// </summary>
        public PolynomialType(Dictionary<int, double> polynomial)
        {
            Polynomial = polynomial;
            DegreeOfPolynomial = FindDegreeOfPolynomial(polynomial);
        }
        //indexer
        public double this[int degree]
        {
            get =>
                Polynomial.ContainsKey(degree) ? Polynomial[degree]
                    : throw new IncorrectPolymonialKeyIndexException(degree);
            set => Polynomial.TryAdd(degree, value);
        }
        /// <summary>
        /// Gets max degree in polynomial
        /// </summary>
        /// <param name="polynomial"></param>
        /// <returns></returns>
        private int FindDegreeOfPolynomial(Dictionary<int, double> polynomial)
        {
            if (polynomial == null)
                throw new PolymonialIsNullException();
            var degrees = new int[polynomial.Count];
            Polynomial.Keys.CopyTo(degrees, 0);
            return degrees.Max();
        }
        public void Add(int degree, double coefficient)
        {
            if (double.IsNaN(coefficient)
                || degree == int.MaxValue
                || degree == int.MinValue)
            {
                throw double.IsNaN(coefficient)
                    ? new IncorrectPolymonialDataException("Incorrect data: coefficient equals to " + coefficient)
                    : new IncorrectPolymonialDataException("Incorrect data: degree equals to " + degree);
            }
            Polynomial.Add(degree, coefficient);
            DegreeOfPolynomial = FindDegreeOfPolynomial(Polynomial);
        }
        /// <summary>
        /// Looks for coefficient in polynomial and gets corresponding degrees
        /// </summary>
        /// <param name="coefficient"></param>
        /// <returns></returns>
        public int[] GetDegree(double coefficient)
        {
            if (!Polynomial.ContainsValue(coefficient))
                throw new IncorrectPolymonialValueException();
            return (int[]) Polynomial.Where(pair => pair.Value == coefficient).Select(pair => pair.Key);
        }
        /// <summary>
        /// Looks for coefficient in polynomial and sets new degree
        /// </summary>
        /// <param name="coefficient"></param>
        /// <param name="degreeToSet"></param>
        /// <returns></returns>
        public bool SetDegree(double coefficient, int degreeToSet)
        {
            if (!Polynomial.ContainsValue(coefficient))
                throw new IncorrectPolymonialValueException();
            var degreesToChange = Polynomial.Where(pair => pair.Value == coefficient)
                .Select(pair => pair.Key)
                .ToArray();
            for (var i = 0; i < degreesToChange.Length; i++)
            {
                degreesToChange[i] = degreeToSet;
            }
            return true;
        }

        public override string ToString()
        {
            StringBuilder result = new StringBuilder();
            var degreesArray = Polynomial.Keys.ToArray();
            var coefficientsArray = Polynomial.Values.ToArray();
            for (int i = 0; i < Polynomial.Count; i++)
            {
                string nextSign = i + 1 < coefficientsArray.Length ? coefficientsArray[i + 1] > 0 ? " + " : " " : " ";
                result.Append(coefficientsArray[i] + "x^" + degreesArray[i] + nextSign);
            }

            return result.ToString();
        }

        public static PolynomialType operator +(PolynomialType polynomial1, PolynomialType polynomial2)
        {
            if (polynomial1 == null || polynomial2 == null)
            {
                throw new ArgumentNullException();
            }
            var result = new PolynomialType();
            var resultDegree = polynomial1.DegreeOfPolynomial > polynomial2.DegreeOfPolynomial
                ? polynomial1.DegreeOfPolynomial
                : polynomial2.DegreeOfPolynomial;
            for (var degree = resultDegree; degree >= 0; degree--)
            {
                if (polynomial1.ContainsDegree(degree) && polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, polynomial1[degree] + polynomial2[degree]);
                }
                else if (polynomial1.ContainsDegree(degree) && !polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, polynomial1[degree]);
                }
                else if (!polynomial1.ContainsDegree(degree) && polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, polynomial2[degree]);
                }
            }
            return result;
        }
        public static PolynomialType operator -(PolynomialType polynomial1, PolynomialType polynomial2)
        {
            if (polynomial1 == null || polynomial2 == null)
            {
                throw new ArgumentNullException();
            }
            var result = new PolynomialType();
            var resultDegree = polynomial1.DegreeOfPolynomial > polynomial2.DegreeOfPolynomial
                ? polynomial1.DegreeOfPolynomial
                : polynomial2.DegreeOfPolynomial;
            for (var degree = resultDegree; degree >= 0; degree--)
            {
                if (polynomial1.ContainsDegree(degree) && polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, polynomial1[degree] - polynomial2[degree]);
                }
                else if (polynomial1.ContainsDegree(degree) && !polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, polynomial1[degree]);
                }
                else if (!polynomial1.ContainsDegree(degree) && polynomial2.ContainsDegree(degree))
                {
                    result.Add(degree, -polynomial2[degree]);
                }
            }
            return result;
        }
        public static PolynomialType operator *(PolynomialType polynomial1, PolynomialType polynomial2)
        {
            if (polynomial1 == null || polynomial2 == null)
            {
                throw new ArgumentNullException();
            }
            var result = new PolynomialType();
            foreach (var (degree1, coefficient1) in polynomial1.Polynomial)
            {
                foreach (var (degree2, coefficient2) in polynomial2.Polynomial)
                {
                    result.Add(degree1 + degree2, coefficient1 * coefficient2);
                }
            }
            return result;
        }

        public static void Serialize(PolynomialType polynomialToSerialize)
        {
            if (polynomialToSerialize == null)
                throw new InvalidSerializationException();
            string path = Environment.CurrentDirectory + @"\Polynomial.json";
            var jsonString = JsonConvert.SerializeObject(polynomialToSerialize, Formatting.Indented);
            File.WriteAllText(path, jsonString);
        }
        public static PolynomialType Deserialize()
        {
            string path = Environment.CurrentDirectory + @"\Polynomial.json";
            var jsonString = File.ReadAllText(path);
            return JsonConvert.DeserializeObject<PolynomialType>(jsonString);
        }
    }
}