using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  /*
  // vectors of algebraic types
  public sealed class AlgebraicVector<T> : IAlgebraicType<AlgebraicVector<T>> where T : IAlgebraicType<T>, new() {
    private T[] elems;

    public T this[int idx] { get { return elems[idx]; } set { elems[idx] = value; } }

    public int Length => elems.Length;

    private AlgebraicVector() { }

    public AlgebraicVector(int len) { elems = new T[len]; }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="elems">The array is copied (element-wise clone)</param>
    public AlgebraicVector(T[] elems) {
      this.elems = new T[elems.Length];
      for (int i = 0; i < elems.Length; ++i) { this.elems[i] = elems[i].Clone(); }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="elems">Array is not copied!</param>
    /// <returns></returns>
    public AlgebraicVector<T> FromArray(T[] elems) {
      var v = new AlgebraicVector<T>();
      v.elems = elems;
      return v;
    }

    public void CopyTo(T[] dest) {
      if (dest.Length != elems.Length) throw new InvalidOperationException("arr lengths do not match in Vector<T>.Copy");
      Array.Copy(elems, dest, dest.Length);
    }

    public AlgebraicVector<T> Clone() { return new AlgebraicVector<T>(elems); }


    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicVector<T> Zero => new AlgebraicVector<T>(Length);
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicVector<T> One { get { var v = new AlgebraicVector<T>(Length); for (int i = 0; i < elems.Length; ++i) elems[i] = new T().One; return v; } }
    public AlgebraicVector<T> Assign(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].Assign(a.elems[i]); } return this; }
    public AlgebraicVector<T> Add(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].Add(a.elems[i]); } return this; }
    public AlgebraicVector<T> Sub(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].Sub(a.elems[i]); } return this; }
    public AlgebraicVector<T> Mul(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].Mul(a.elems[i]); } return this; }
    public AlgebraicVector<T> Div(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].Div(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignNeg(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignNeg(a.elems[i]); } return this; }
    public AlgebraicVector<T> Scale(double s) { for (int i = 0; i < elems.Length; ++i) { elems[i].Scale(s); } return this; }
    public AlgebraicVector<T> Scale(T s) { for (int i = 0; i < elems.Length; ++i) { elems[i].Mul(s); } return this; }
    public AlgebraicVector<T> AssignInv(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignInv(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignLog(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignLog(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignExp(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignExp(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignSin(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignSin(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignCos(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignCos(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignIntPower(AlgebraicVector<T> a, int p) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignIntPower(a.elems[i], p); } return this; }
    public AlgebraicVector<T> AssignIntRoot(AlgebraicVector<T> a, int r) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignIntRoot(a.elems[i], r); } return this; }
    public AlgebraicVector<T> AssignAbs(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignAbs(a.elems[i]); } return this; }
    public AlgebraicVector<T> AssignSgn(AlgebraicVector<T> a) { for (int i = 0; i < elems.Length; ++i) { elems[i].AssignSgn(a.elems[i]); } return this; }
  }

  */


  /// <summary>
  /// A sparse vector of algebraic types. Elements are accessed via a key of type K
  /// </summary>
  /// <typeparam name="K">Key type</typeparam>
  /// <typeparam name="T">Element type</typeparam>
  [DebuggerDisplay("SparseVector: {ToString()}")]
  public sealed class AlgebraicSparseVector<K, T> : IAlgebraicType<AlgebraicSparseVector<K, T>> where T : IAlgebraicType<T> {
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private Dictionary<K, T> elems;
    public IReadOnlyDictionary<K, T> Elements => elems;


    public AlgebraicSparseVector(AlgebraicSparseVector<K, T> original) {
      elems = original.elems.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Clone());
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="keys"></param>
    /// <param name="values">values are cloned</param>
    public AlgebraicSparseVector(K[] keys, T[] values) {
      if (keys.Length != values.Length) throw new ArgumentException("lengths of keys and values doesn't match in SparseVector");
      elems = new Dictionary<K, T>(keys.Length);
      for (int i = 0; i < keys.Length; ++i) {
        elems.Add(keys[i], values[i].Clone());
      }
    }

    public AlgebraicSparseVector() {
      this.elems = new Dictionary<K, T>();
    }

    // keep only elements from a
    private void AssignFromSource(AlgebraicSparseVector<K, T> a, Func<T, T, T> mapAssign) {
      // remove elems from this which don't occur in a
      List<K> keysToRemove = new List<K>();
      foreach (var kvp in elems) {
        if (!a.elems.ContainsKey(kvp.Key)) keysToRemove.Add(kvp.Key);
      }
      foreach (var o in keysToRemove) elems.Remove(o); // -> zero

      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          mapAssign(kvp.Value, value);
        else
          elems.Add(kvp.Key, mapAssign(kvp.Value, kvp.Value.Zero));
      }
    }

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicSparseVector<K, T> Zero => new AlgebraicSparseVector<K, T>();
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicSparseVector<K, T> One => throw new NotSupportedException();

    public AlgebraicSparseVector<K, T> Scale(T s) { foreach (var kvp in elems) { kvp.Value.Mul(s); } return this; }
    public AlgebraicSparseVector<K, T> Scale(double s) { foreach (var kvp in elems) { kvp.Value.Scale(s); } return this; }

    public AlgebraicSparseVector<K, T> Assign(AlgebraicSparseVector<K, T> a) { elems.Clear(); AssignFromSource(a, (src, dest) => dest.Assign(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignInv(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignInv(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignNeg(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignNeg(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignLog(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignLog(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignExp(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignExp(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignIntPower(AlgebraicSparseVector<K, T> a, int p) { AssignFromSource(a, (src, dest) => dest.AssignIntPower(src, p)); return this; }
    public AlgebraicSparseVector<K, T> AssignIntRoot(AlgebraicSparseVector<K, T> a, int r) { AssignFromSource(a, (src, dest) => dest.AssignIntRoot(src, r)); return this; }
    public AlgebraicSparseVector<K, T> AssignSin(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignSin(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignCos(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignCos(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignTanh(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignTanh(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignAbs(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignAbs(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignSgn(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignSgn(src)); return this; }
    public AlgebraicSparseVector<K, T> Add(AlgebraicSparseVector<K, T> a) {
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Add(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Clone()); // 0 + a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Sub(AlgebraicSparseVector<K, T> a) {
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Sub(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Zero.Sub(kvp.Value)); // 0 - a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Mul(AlgebraicSparseVector<K, T> a) {
      var keys = elems.Keys.ToArray();
      foreach (var k in keys) if (!a.elems.ContainsKey(k)) elems.Remove(k); // 0 * a => 0
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Mul(kvp.Value); // this * a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Div(AlgebraicSparseVector<K, T> a) {
      return Mul(a.Clone().Inv());
    }

    public AlgebraicSparseVector<K, T> AssignMin(AlgebraicSparseVector<K, T> other) {
      // assumes that keys without a matching key in other are zero and vice versa
      foreach (var kvp in elems) if (!other.elems.ContainsKey(kvp.Key)) kvp.Value.AssignMin(kvp.Value.Zero); // min(v, 0)
      foreach (var kvp in other.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.AssignMin(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Zero.AssignMin(kvp.Value));
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> AssignMax(AlgebraicSparseVector<K, T> other) {
      // assumes that keys without a matching key in other are zero and vice versa
      foreach (var kvp in elems) if (!other.elems.ContainsKey(kvp.Key)) kvp.Value.AssignMax(kvp.Value.Zero); // max(v, 0)
      foreach (var kvp in other.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.AssignMax(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Zero.AssignMax(kvp.Value));
      }
      return this;
    }


    public AlgebraicSparseVector<K, T> Clone() {
      return new AlgebraicSparseVector<K, T>(this);
    }

    public override string ToString() {
      return "[" + string.Join(" ", elems.Select(kvp => kvp.Key + ": " + kvp.Value)) + "]";
    }
  }
}