package polynomial;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

/**
 * A skeleton class for representing Polynomials
 *
 * @author Sjaak Smetsers
 * @date 10-03-2015
 */
public class Polynomial {

    /**
     * A polynomial is a sequence of terms here kept in an List
     */
    List<Term> terms;

    /**
     * A constructor for creating the zero Polynomial zero is presented as an
     * empty list of terms and not as a single term with 0 as a coefficient
     */
    public Polynomial() {
        terms = new ArrayList<>();
    }

    /**
     * A Constructor creating a polynomial from the argument string.
     *
     * @param s a String representing a list of terms which is converted to a
     * scanner and passed to scanTerm for reading each individual term
     */
    public Polynomial( String s ) {
        terms = new ArrayList<>();
        Scanner scan = new Scanner(s);

        for (Term t = Term.scanTerm(scan); t != null; t = Term.scanTerm(scan)) {
            terms.add(t);
        }
    }

    /**
     * The copy constructor for making a deep copy
     *
     * @param p the copied polynomial
     *
     */
    public Polynomial( Polynomial p ) {
        terms = new ArrayList<>(p.terms.size());
        for (Term t : p.terms) {
            terms.add(new Term(t));
        }
    }
    
    /**
     * A straightforward conversion of a Polynomial into a string based on the
     * toString for terms
     *
     * @return a readable string representation of this
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        boolean not_first = false;
        for (Term t : terms) {
            if (not_first && t.getCoef() >= 0) 
                sb.append("+");
            sb.append(t);
            not_first = true;
        }
        return sb.toString();
    }

    public void plus(Polynomial b) {
        for (Term t : b.terms)
            plus(t);
    }
    
    public void plus(Term t) {
        Iterator<Term> iter = terms.iterator();
        while (iter.hasNext()) {
            Term this_t = iter.next();
            if (this_t.getExp() == t.getExp()) {
                this_t.plus(t);
                if (this_t.getCoef() == 0)
                    iter.remove();
                return;
            }
        }
        terms.add(t);
    }

    public void minus(Polynomial b) {
        b.times(new Polynomial("-1 0"));
        plus(b);
    }

    public void times(Polynomial b) {
        Polynomial result = new Polynomial();
        for (Term that_t : b.terms) 
            for (Term this_t : terms)
                result.plus(new Polynomial((that_t.getCoef() * this_t.getCoef()) + " " + (that_t.getExp() + this_t.getExp())));
        terms = result.terms;
    }

    public void divide(Polynomial b) {
    }

    @Override
    public boolean equals(Object other_poly) {
        Polynomial that = (Polynomial) other_poly;
        if (terms.size() != that.terms.size()) 
            return false;
        for (Term this_t : terms) {
            Iterator<Term> that_iter = that.terms.iterator();
            boolean found = false;
            while (that_iter.hasNext()) {
                if (this_t.equals(that_iter.next())) {
                    found = true;
                    that_iter.remove();
                    break;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }
    
    public double apply(double x) {
        double result = 0;
        for (Term t : terms)
            result += t.apply(x);
        return result;
    }

}