#pragma once

#include <iosfwd>

#include <vector>

#include "../polynomial.h"

#include "assignment.h"

#include "integer.h"

#include "interval.h"

#include "interval_assignment.h"

#include "sign_condition.h"

#include "value.h"

#include "variable.h"

namespace poly {

  /**

   * Implements a wrapper for lp_polynomial_t.

   */

    /** The actual polynomial. */

    deleting_unique_ptr<lp_polynomial_t> mPoly;

   public:

    /** Create from a lp_polynomial_t pointer, claiming it's ownership. */

    Polynomial(lp_polynomial_t* poly);

    /** Copy from an internal lp_polynomial_t pointer. */

    Polynomial(const lp_polynomial_t* poly);

    /** Construct a zero polynomial from an interval context pointer. */

    Polynomial(const lp_polynomial_context_t* c);

    /** Construct a zero polynomial from a custom context. */

    Polynomial(const Context& c);

    /** Construct a zero polynomial. */

    Polynomial();

    /** Construct from a variable and a custom context. */

    Polynomial(const Context& c, Variable v);

    /** Construct from a variable. */

    Polynomial(Variable v);

    /** Construct i * v^n from a custom context. */

    Polynomial(const Context& c, Integer i, Variable v, unsigned n);

    /** Construct i * v^n. */

    Polynomial(Integer i, Variable v, unsigned n);

    /** Construct from an integer and a custom context. */

    Polynomial(const Context& c, Integer i);

    /** Construct from an integer. */

    Polynomial(Integer i);

    /** Construct from an integer and a custom context. */

    Polynomial(const Context& c, long i);

    /** Construct from an integer. */

    Polynomial(long i);

    /** Copy from a Polynomial. */

    Polynomial(const Polynomial& p);

    /** Move from a Polynomial. */

    Polynomial(Polynomial&& p);

    /** Copy from a Polynomial. */

    Polynomial& operator=(const Polynomial& p);

    /** Move from a Polynomial. */

    Polynomial& operator=(Polynomial&& p);

    /** Get a non-const pointer to the internal lp_polynomial_t. Handle with

     * care!

     */

    lp_polynomial_t* get_internal();

    /** Get a const pointer to the internal lp_polynomial_t. */

    const lp_polynomial_t* get_internal() const;

    /** Release the lp_polynomial_t pointer. This yields ownership of the

     * returned pointer. */

    lp_polynomial_t* release();

  };

  /** Swap two polynomials. */

  void swap(Polynomial& lhs, Polynomial& rhs);

  /** Return the hash of a polynomial. */

  std::size_t hash(const Polynomial& p);

  /** Stream the given Polynomial to an output stream. */

  std::ostream& operator<<(std::ostream& os, const Polynomial& p);

  /** Check if the given polynomial is zero. */

  bool is_zero(const Polynomial& p);

  /** Check if the given polynomial is constant. */

  bool is_constant(const Polynomial& p);

  /** Check if the given polynomial is linear. */

  bool is_linear(const Polynomial& p);

  /** Check if the leading coefficient is constant. */

  bool is_lc_constant(const Polynomial& p);

  /** Get the sign of the leading coefficient. Assumes is_lc_constant(p). */

  int lc_sgn(const Polynomial& p);

  /** Obtain the degree of the given polynomial in its main variable. */

  std::size_t degree(const Polynomial& p);

  /** Obtain the main variable of the given polynomial. */

  Variable main_variable(const Polynomial& p);

  /** Obtain the k'th coefficient of a polynomial. */

  Polynomial coefficient(const Polynomial& p, std::size_t k);

  /** Obtain the leading coefficient of a polynomial. */

  Polynomial leading_coefficient(const Polynomial& p);

  /** Obtain all non-constant coefficients of a polynomial. */

  std::vector<Polynomial> coefficients(const Polynomial& p);

  /** Check if the given polynomial is univariate. */

  bool is_univariate(const Polynomial& p);

  /** Converts a polynomial to a univariate polynomial. Assumes

   * is_univariate(p). */

  UPolynomial to_univariate(const Polynomial& p);

  /** Check if the given polynomial is univariate over a given assignment and

   * the main variable is unassigned. */

  bool is_univariate_over_assignment(const Polynomial& p, const Assignment& a);

  /** Check if the given polynomial is completely assigned over a given

   * assignment. */

  bool is_assigned_over_assignment(const Polynomial& p, const Assignment& a);

  /** Compute the sign of a polynomial over an assignment. */

  int sgn(const Polynomial& p, const Assignment& a);

  /** Evaluate a polynomial over an assignment. */

  Value evaluate(const Polynomial& p, const Assignment& a);

  /** Evaluate a polynomial constraint over an assignment. */

  bool evaluate_constraint(const Polynomial& p, const Assignment& a,

                           SignCondition sc);

  /** Evaluate a polynomial over an interval assignment. The result is only an

   * approximation. */

  Interval evaluate(const Polynomial& p, const IntervalAssignment& a);

  /** Compare polynomials. */

  bool operator==(const Polynomial& lhs, const Polynomial& rhs);

  /** Compare polynomials. */

  bool operator!=(const Polynomial& lhs, const Polynomial& rhs);

  /** Compare polynomials. */

  bool operator<(const Polynomial& lhs, const Polynomial& rhs);

  /** Compare polynomials. */

  bool operator<=(const Polynomial& lhs, const Polynomial& rhs);

  /** Compare polynomials. */

  bool operator>(const Polynomial& lhs, const Polynomial& rhs);

  /** Compare polynomials. */

  bool operator>=(const Polynomial& lhs, const Polynomial& rhs);

  /** Add two polynomials. */

  Polynomial operator+(const Polynomial& lhs, const Polynomial& rhs);

  /** Add a polynomial and an integer. */

  Polynomial operator+(const Polynomial& lhs, const Integer& rhs);

  /** Add an integer and a polynomial. */

  Polynomial operator+(const Integer& lhs, const Polynomial& rhs);

  /** Add and assign two polynomials. */

  Polynomial& operator+=(Polynomial& lhs, const Polynomial& rhs);

  /** Compute lhs += rhs1 * rhs2. */

  Polynomial& add_mul(Polynomial& lhs, const Polynomial& rhs1, const Polynomial& rhs2);

  /** Unary negation of a polynomial. */

  Polynomial operator-(const Polynomial& p);

  /** Subtract two polynomials. */

  Polynomial operator-(const Polynomial& lhs, const Polynomial& rhs);

  /** Subtract an integer from a polynomial. */

  Polynomial operator-(const Polynomial& lhs, const Integer& rhs);

  /** Subtract a polynomial from an integer. */

  Polynomial operator-(const Integer& lhs, const Polynomial& rhs);

  /** Subtract and assign two polynomials. */

  Polynomial& operator-=(Polynomial& lhs, const Polynomial& rhs);

  /** Compute lhs -= rhs1 * rhs2. */

  Polynomial& sub_mul(Polynomial& lhs, const Polynomial& rhs1, const Polynomial& rhs2);

  /** Multiply two polynomials. */

  Polynomial operator*(const Polynomial& lhs, const Polynomial& rhs);

  /** Multiply a polynomial and an integer. */

  Polynomial operator*(const Polynomial& lhs, const Integer& rhs);

  /** Multiply an integer and a polynomial. */

  Polynomial operator*(const Integer& lhs, const Polynomial& rhs);

  /** Multiply and assign two polynomials. */

  Polynomial& operator*=(Polynomial& lhs, const Polynomial& rhs);

  /** Multiply with x^n where x is the main variable. */

  Polynomial shl(const Polynomial& lhs, unsigned n);

  /** Compute a polynomial to some power. */

  Polynomial pow(const Polynomial& lhs, unsigned exp);

  /** Checks whether lhs divides rhs. */

  bool divides(const Polynomial& lhs, const Polynomial& rhs);

  /** Compute the quotient of two polynomials, assuming divides(rhs, lhs). */

  Polynomial div(const Polynomial& lhs, const Polynomial& rhs);

  /** Compute the remainder of two polynomials. */

  Polynomial rem(const Polynomial& lhs, const Polynomial& rhs);

  /** Compute the pseudo-remainder of two polynomials. */

  Polynomial prem(const Polynomial& lhs, const Polynomial& rhs);

  /** Compute the sparse pseudo-remainder of two polynomials. */

  Polynomial sprem(const Polynomial& lhs, const Polynomial& rhs);

  /** Compute quotient and remainder of two polynomials. */

  std::pair<Polynomial, Polynomial> div_rem(const Polynomial& lhs,

                                            const Polynomial& rhs);

  /** Compute the derivative of a polynomial (in its main variable). */

  Polynomial derivative(const Polynomial& p);

  /** Compute the gcd of two polynomials. */

  Polynomial gcd(const Polynomial& p, const Polynomial& q);

  /** Compute the lcm of two polynomials. */

  Polynomial lcm(const Polynomial& p, const Polynomial& q);

  /** Compute the content of a polynomial. */

  Polynomial content(const Polynomial& p);

  /** Compute the primitive part of a polynomial. */

  Polynomial primitive_part(const Polynomial& p);

  /** Compute the content and the primitive part of a polynomial. */

  std::pair<Polynomial, Polynomial> content_primitive_part(const Polynomial& p);

  /** Compute the resultant of two polynomials. */

  Polynomial resultant(const Polynomial& p, const Polynomial& q);

  /** Compute the discriminant of a polynomial. */

  Polynomial discriminant(const Polynomial& p);

  /** Compute the principal subresultant coefficients of two polynomials. */

  std::vector<Polynomial> psc(const Polynomial& p, const Polynomial& q);

  /**

   * Compute a square-free factorization of a polynomial.

   * Attention: this does not yield a full factorization!

   */

  std::vector<Polynomial> square_free_factors(const Polynomial& p);

  /** Compute a content-free factorization of a polynomial. */

  std::vector<Polynomial> content_free_factors(const Polynomial& p);

  /** Isolate the real roots of a Polynomial with respect to an Assignment for

   * all but the main variable. */

  std::vector<Value> isolate_real_roots(const Polynomial& p,

                                        const Assignment& a);

  std::vector<Interval> infeasible_regions(const Polynomial& p,

                                           const Assignment& a,

                                           SignCondition sc);

}  // namespace poly