#include "wielomian.hpp"

// WCZYTYWANIE 0

wielomian::wielomian(int st, double wsp)
    :n{st}
{
    a = new double[st + 1];
    a[0] = wsp;
}

wielomian::wielomian(int st, const double wsp[])
    :n{st}
{
    a = new double[st + 1];
    for(int i = 0; i <= n; ++i)
    {
        a[i] = wsp[i];
    }

    if(n != 0 && a[n] == 0)
    {
        throw invalid_argument("Zero wiodące w wielomianie");
    }
}

wielomian::wielomian(initializer_list <double> wsp)
    :n{(int)wsp.size()}
{
    a = new double[n];
    int temp = 0;
    for(auto& p : wsp)
    {
        a[temp++] = p;
    }

    if(n != 0 && a[n] == 0)
    {
        throw invalid_argument("Zero wiodące w wielomianie");
    }
}

wielomian::wielomian(const wielomian &w)
{
    n = w.stopien();
    a = new double[n + 1];
    for(int i = 0; i <= n; ++i)
    {
        a[i] = w[i];
    }
}

wielomian::wielomian(wielomian &&w)
{
    n = w.stopien();
    a = w.a;
    w.a = nullptr;

}

wielomian::~wielomian()
{
    if(a != nullptr)delete[] a;
}

int wielomian::stopien() const
{
    return n;
}

double& wielomian::operator[](int index)
{
if(index > n)
    {
        throw logic_error("Wielomian ma mniejszy stopień");
    }
    return a[index];
}

double wielomian::operator[](int index) const
{
if(index > n)
    {
        throw logic_error("Wielomian ma mniejszy stopień");
    }
    return a[index];
}

void wielomian::norm()
{
    if(n > 0 && !a[n])
    {
        int cnt = 0;
        for(int i = n; i > 0; --i)
        {
            if(a[i])break;
            cnt++;
        }
        int newn = n - cnt;
        double* ntab = new double[n - cnt + 1];
        for(int i = 0; i <= newn; ++i)
        {
            ntab[i] = a[i];
        }
        this->~wielomian();
        a = ntab;
        n = newn;
    }
}

wielomian& wielomian::operator= (const wielomian &w)
{
    n = w.stopien();
    if(this == &w)return *this;
    this->~wielomian();
    a = new double[n + 1];
    for(int i = 0; i <= n; ++i)
    {
        a[i] = w[i];
    }
}

wielomian& wielomian::operator= (wielomian &&w)
{
    if(this == &w)return *this;
    this->~wielomian();
    n = w.stopien();
    a = w.a;
    w.a = nullptr;
}

istream& operator>> (istream &we, wielomian &w) // WCZYTAWANIE UJEMNEGO STOPNIA
{
    w.~wielomian();

    we >> w.n;

    w.a = new double[w.n + 1];

    for(int i = 0; i <= w.n; ++i)
    {
        we >> w.a[i];
    }

    if(w.n != 0 && w.a[w.n] == 0)
    {
        throw invalid_argument("Zero wiodące w wielomianie");
    }

    return we;
}

ostream& operator<< (ostream &wy, const wielomian &w)
{
    wy << w.n << "\n";

    for(int i = 0; i <= w.n; ++i)
    {
        wy << w.a[i] << " ";
    }

    return wy;
}

wielomian operator+ (const wielomian& u, const wielomian& v)
{
    wielomian res;
    res.~wielomian();
    res.n = max(u.stopien(), v.stopien());
    res.a = new double [res.n + 1];
    for(int i = 0; i <= res.n; ++i)
    {
        double tu = (u.stopien() >= i) ? u[i] : 0;
        double tv = (v.stopien() >= i) ? v[i] : 0;
        res.a[i] = tv + tu;
    }

    res.norm();

    return res;
}

wielomian operator- (const wielomian& u, const wielomian& v) // ZMINIEJSZANIE STOPNIA
{
    //cout << __PRETTY_FUNCTION__ << "\n";
    wielomian res;
    res.~wielomian();
    res.n = max(u.stopien(), v.stopien());
    res.a = new double [res.n + 1];
    for(int i = 0; i <= res.n; ++i)
    {
        double tu = (u.stopien() >= i) ? u[i] : 0;
        double tv = (v.stopien() >= i) ? v[i] : 0;
        res.a[i] = tu - tv;
    }

    res.norm();

    return res;
}

wielomian operator* (const wielomian& u, const wielomian& v) // MNOZENIE i ZMINIEJSZANIE STOPNIA
{
    wielomian res;
    res.~wielomian();
    res.n = u.stopien() + v.stopien();
    res.a = new double [res.n + 1]();
    for(int i = 0; i <= u.stopien(); ++i)
    {
        for(int j = 0; j <= v.stopien(); ++j)
        {
            res.a[i + j] += u[i] * v[j];
        }
    }

    res.norm();

    return res;
}

wielomian operator* (const wielomian& u, double c) // BRAK ARGUMENTU?
{
    wielomian temp(u);

    for(int i = 0; i <= temp.n; ++i)
    {
        temp.a[i] *= c;
    }

    temp.norm();

    return temp;
}

wielomian& wielomian::operator+= (const wielomian &v)
{
    int prevn = n;
    double* tempa = a;
    n = max(n, v.stopien());
    a = new double[n + 1];

    for(int i = 0; i <= n; ++i)
    {
        double tu = (prevn >= i) ? tempa[i] : 0;
        double tv = (v.stopien() >= i) ? v[i] : 0;
        a[i] = tu + tv;
    }

    delete[] tempa;

    this->norm();

    return *this;
}

wielomian& wielomian::operator-= (const wielomian &v)
{
    cout << __PRETTY_FUNCTION__ << "\n";
    int prevn = n;
    double* tempa = a;
    n = max(n, v.stopien());
    a = new double[n + 1];

    for(int i = 0; i <= n; ++i)
    {
        double tu = (prevn >= i) ? tempa[i] : 0;
        double tv = (v.stopien() >= i) ? v[i] : 0;
        a[i] = tu - tv;
    }

    delete[] tempa;

    this->norm();

    return *this;
}

wielomian& wielomian::operator*= (const wielomian &v)
{
    int prevn = n;
    double* tempa = a;
    n = n + v.stopien();
    a = new double[n + 1]();
    for(int i = 0; i <= prevn; ++i)
    {
        for(int j = 0; j <= v.stopien(); ++j)
        {
            a[i + j] += tempa[i] * v[j];
        }
    }

    delete[] tempa;

    this->norm();

    return *this;
}

wielomian& wielomian::operator*= (double c)
{
    for(int i = 0; i <= this->n; ++i)
    {
        this->a[i] *= c;
    }

    this->norm();

    return *this;
}

double wielomian::operator() (double x) const
{
    double tx = 1;
    double sum = 0;

    for(int i = 0; i <= n; ++i)
    {
        sum += tx * a[i];
        tx *= x;
    }

    return sum;
}



#pragma once

#include <iostream>

using namespace std;

class wielomian
{
private:
    int n;
    double* a;
public:
    wielomian(int st = 0, double wsp = 1.0);
    wielomian(int st, const double wsp[]);
    wielomian(initializer_list <double> wsp);
    wielomian(const wielomian &w);
    wielomian(wielomian &&w);
    ~wielomian();

    int stopien() const;

    double& operator[](int index); // wczyt
    double operator[](int index) const; // odczyt
    wielomian& operator= (const wielomian &w);
    wielomian& operator= (wielomian &&w);
    friend istream& operator>> (istream &we, wielomian &w);
    friend ostream& operator<< (ostream &wy, const wielomian &w);
    friend wielomian operator+ (const wielomian& u, const wielomian& v);
    friend wielomian operator- (const wielomian& u, const wielomian& v);
    friend wielomian operator* (const wielomian& u, const wielomian& v);
    friend wielomian operator* (const wielomian& u, double c);
    wielomian& operator+= (const wielomian &v);
    wielomian& operator-= (const wielomian &v);
    wielomian& operator*= (const wielomian &v);
    wielomian& operator*= (double c);
    double operator() (double x) const;
    void norm();

};