#include "Spectrum_p.h"
namespace YSG {
using Spectrum_Binding = Renderable_Binding<Spectrum, Spectrum_Private, Spectrum_Render_State, Spectrum_Input_Data>;
Spectrum::Spectrum() {
    Spectrum_Binding::init(this, "Spectrum");
}
Spectrum_Private* Spectrum::d() {
    return Spectrum_Binding::d(this);
}
Render_Data* Spectrum::create_render_data() {
    return Spectrum_Binding::create_render_data();
}
Render_State* Spectrum::create_render_state() {
    return Spectrum_Binding::create_render_state();
}
Input_Data* Spectrum::create_input_data() {
    return Spectrum_Binding::create_input_data();
}
Frequent_Axis* Spectrum::frequent_axis(SRC src) {
    return d()->state_value(&Spectrum_Render_State::frequent_axis, src);
}
void Spectrum::set_frequent_axis(Frequent_Axis* value) {
    d()->set_state_value(&Spectrum_Render_State::frequent_axis, value);
}
Axis* Spectrum::power_axis(SRC src) {
    return d()->state_value(&Spectrum_Render_State::power_axis, src);
}
void Spectrum::set_power_axis(Axis* value) {
    d()->set_state_value(&Spectrum_Render_State::power_axis, value);
}
int Spectrum::frequent_point_size(SRC src) {
    return d()->state_value(&Spectrum_Render_State::frequent_point_size, src);
}
Range Spectrum::frequent_range(SRC src) {
    return d()->state_value(&Spectrum_Render_State::frequent_range, src);
}
double Spectrum::middle_sweep_frequent(SRC src) {
    return d()->state_value(&Spectrum_Render_State::middle_sweep_frequent, src);
}
void Spectrum::set_middle_sweep_frequent(double value) {
    d()->set_state_value(&Spectrum_Render_State::middle_sweep_frequent, value);
}
Range Spectrum::sweep_frequent_range(SRC src) {
    return d()->state_value(&Spectrum_Render_State::sweep_frequent_range, src);
}
void Spectrum::set_sweep_frequent_range(Range value) {
    d()->set_state_value(&Spectrum_Render_State::sweep_frequent_range, std::move(value));
}
bool Spectrum::use_max_line(SRC src) {
    return d()->state_value(&Spectrum_Render_State::use_max_line, src);
}
void Spectrum::set_use_max_line(bool value) {
    d()->set_state_value(&Spectrum_Render_State::use_max_line, value);
}
bool Spectrum::use_min_line(SRC src) {
    return d()->state_value(&Spectrum_Render_State::use_min_line, src);
}
void Spectrum::set_use_min_line(bool value) {
    d()->set_state_value(&Spectrum_Render_State::use_min_line, value);
}
bool Spectrum::use_max_marker(SRC src) {
    return d()->state_value(&Spectrum_Render_State::use_max_marker, src);
}
void Spectrum::set_use_max_marker(bool value) {
    d()->set_state_value(&Spectrum_Render_State::use_max_marker, value);
}
bool Spectrum::use_min_marker(SRC src) {
    return d()->state_value(&Spectrum_Render_State::use_min_marker, src);
}
void Spectrum::set_use_min_marker(bool value) {
    d()->set_state_value(&Spectrum_Render_State::use_min_marker, value);
}
bool Spectrum::use_sweep_frequent_rect(SRC src) {
    return d()->state_value(&Spectrum_Render_State::use_sweep_frequent_rect, src);
}
void Spectrum::set_use_sweep_frequent_rect(bool value) {
    d()->set_state_value(&Spectrum_Render_State::use_sweep_frequent_rect, value);
}
QBrush Spectrum::max_brush(SRC src) {
    return d()->state_value(&Spectrum_Render_State::max_brush, src);
}
void Spectrum::set_max_brush(QBrush value) {
    d()->set_state_value(&Spectrum_Render_State::max_brush, std::move(value));
}
QBrush Spectrum::cur_brush(SRC src) {
    return d()->state_value(&Spectrum_Render_State::cur_brush, src);
}
void Spectrum::set_cur_brush(QBrush value) {
    d()->set_state_value(&Spectrum_Render_State::cur_brush, std::move(value));
}
QBrush Spectrum::min_brush(SRC src) {
    return d()->state_value(&Spectrum_Render_State::min_brush, src);
}
void Spectrum::set_min_brush(QBrush value) {
    d()->set_state_value(&Spectrum_Render_State::min_brush, std::move(value));
}
QPen Spectrum::max_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::max_pen, src);
}
void Spectrum::set_max_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::max_pen, std::move(value));
}
QPen Spectrum::cur_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::cur_pen, src);
}
void Spectrum::set_cur_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::cur_pen, std::move(value));
}
QPen Spectrum::min_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::min_pen, src);
}
void Spectrum::set_min_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::min_pen, std::move(value));
}
QPen Spectrum::select_marker_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::select_marker_pen, src);
}
void Spectrum::set_select_marker_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::select_marker_pen, std::move(value));
}
QPen Spectrum::marker_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::marker_pen, src);
}
void Spectrum::set_marker_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::marker_pen, std::move(value));
}
QPen Spectrum::middle_frequent_pen(SRC src) {
    return d()->state_value(&Spectrum_Render_State::middle_frequent_pen, src);
}
void Spectrum::set_middle_frequent_pen(QPen value) {
    d()->set_state_value(&Spectrum_Render_State::middle_frequent_pen, std::move(value));
}
QBrush Spectrum::sweep_rect_brush(SRC src) {
    return d()->state_value(&Spectrum_Render_State::sweep_rect_brush, src);
}
void Spectrum::set_sweep_rect_brush(QBrush value) {
    d()->set_state_value(&Spectrum_Render_State::sweep_rect_brush, std::move(value));
}
void Spectrum::set_frequent_point_size(int frequent_point_size) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->frequent_point_size = frequent_point_size;
}
void Spectrum::set_frequent_range(Range frequent_range) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->frequent_range = frequent_range;
}
Spectrum::Builder::Builder(Frequent_Axis* frequent_axis, Axis* power_axis) {
    ASSERT(frequent_axis->mPlot != nullptr, "Afterglow build error!  frequent_axis->mPlot == nullptr");
    ASSERT(frequent_axis->mPlot == power_axis->mPlot, "Afterglow build error!  frequent_axis->mPlot != power_axis->mPlot");
    plot = frequent_axis->mPlot;
    this->frequent_axis = frequent_axis;
    this->power_axis = power_axis;
}
Spectrum* Spectrum::Builder::build() {
    auto ret = new Spectrum;
    ret->init(plot, layerName);
    Spectrum_Private* pd = ret->d();
    Spectrum_Render_State* sc = reinterpret_cast<Spectrum_Render_State*>(pd->state(State_Edit));
    PROP_R(FrequentAxis *, frequent_axis)
    PROP_R(Axis *, power_axis);
    PROP_R(int, frequent_point_size);
    PROP_R(Range, frequent_range);
    PROP_R(double, middle_sweep_frequent);
    PROP_R(Range, sweep_frequent_range);
    PROP_R(bool, use_max_line);
    PROP_R(bool, use_min_line);
    PROP_R(bool, use_max_marker);
    PROP_R(bool, use_min_marker);
    PROP_R(bool, use_sweep_frequent_rect);
    PROP_R(QBrush, max_brush);
    PROP_R(QBrush, cur_brush);
    PROP_R(QBrush, min_brush);
    PROP_R(QPen, max_pen);
    PROP_R(QPen, cur_pen);
    PROP_R(QPen, min_pen);
    PROP_R(QPen, select_marker_pen);
    PROP_R(QPen, marker_pen);
    PROP_R(QPen, middle_frequent_pen);
    PROP_R(QBrush, sweep_rect_brush);
    return ret;
}
void Spectrum_Private::update_frequent_point_size(int frequent_point_size, Range frequent_range) {
    if (frequent_point_size == 0) return;
    cacheFrequentPointSize = frequent_point_size;
    cacheFrequentRange = frequent_range;
    maxPowers.resize(frequent_point_size);
    curPowers.resize(frequent_point_size);
    minPowers.resize(frequent_point_size);
    frequents.resize(frequent_point_size);
    double cur = frequent_range.lower;
    double step = frequent_range.length() / (frequent_point_size - 1);
    frequents[0] = frequent_range.lower;
    for (int i = 1; i < frequent_point_size; ++i) {
        cur += step;
        frequents[i] = cur;
    }
    maxPowers.fill(frequent_range.lower);
    minPowers.fill(frequent_range.upper);
}
void Spectrum_Private::set_frequent_data(const QVector<double>& lineData, const Spectrum_Render_State* s) {
    if (lineData.size() != s->frequent_point_size) {
        qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << s->frequent_point_size;
        return;
    }
    curPowers = lineData;
    curPowers.detach();
    double min = std::numeric_limits<double>::max();
    double max = std::numeric_limits<double>::min();
    int minIndex = 0, maxIndex = 0;
    for (int i = 0; i < s->frequent_point_size; ++i) {
        double& curData = curPowers[i];
        if (s->use_max_line && curData > maxPowers.at(i)) {
            maxPowers[i] = curData;
        }
        if (s->use_min_line && curData < minPowers.at(i)) {
            minPowers[i] = curData;
        }
        if (s->use_max_marker && curData > max) {
            max = curData;
            maxIndex = i;
        }
        if (s->use_min_marker && curData < min) {
            min = curData;
            minIndex = i;
        }
    }
    maxMarkerKey = frequents[maxIndex];
    maxMarkerValue = curPowers[maxIndex];
    minMarkerKey = frequents[minIndex];
    minMarkerValue = curPowers[minIndex];
}
double Spectrum_Private::get_y(const double& x, bool& ok) {
    int i = binary_search(x, frequents, ok);
    if (!ok) return -1;
    const double& x1 = frequents.at(i);
    const double& x2 = frequents.at(i + 1);
    const double& y1 = curPowers.at(i);
    const double& y2 = curPowers.at(i + 1);
    double k = (y2 - y1) / (x2 - x1);
    double b = y1 - k * x1;
    return (int)(k * x + b);
}
void Spectrum_Private::draw_line(QPainter* painter, const Spectrum_Render_State* s, const QVector<double>& ys, const QPen& pen, const QBrush& brush) {
    if (frequents.empty()) return;
    int n = frequents.size();
    QVector<QPointF> points(n + 2);
    double upperBoundPixel = s->power_axis->coord_to_pixel(s->power_axis->coord_range().upper, SRC::Render);
    points.first() = QPointF(s->frequent_axis->coord_to_pixel(frequents.first(), SRC::Render), upperBoundPixel);
    points.last() = QPointF(s->frequent_axis->coord_to_pixel(frequents.last(), SRC::Render), upperBoundPixel);
    for (int i = 0; i < n; ++i) {
        double x = s->frequent_axis->coord_to_pixel(frequents.at(i), SRC::Render);
        double y = s->power_axis->coord_to_pixel(ys.at(i), SRC::Render);
        points[i + 1] = QPointF(x, y);
    }
    painter->setPen(pen);
    if (pen.style() != Qt::NoPen) painter->drawPolyline(points.data() + 1, n);
    painter->setBrush(brush);
    if (brush.style() != Qt::NoBrush) painter->drawPolygon(points.data(), n + 2);
}
void Spectrum_Private::draw_spectrum(QPainter* painter, Spectrum_Render_State* s) {
    if (s->use_max_line) draw_line(painter, s, maxPowers, s->max_pen, s->max_brush);
    draw_line(painter, s, curPowers, s->cur_pen, s->cur_brush);
    if (s->use_min_line) draw_line(painter, s, minPowers, s->min_pen, s->min_brush);
    if (s->use_max_marker) s->draw_marker(painter, maxMarkerKey, maxMarkerValue, false, false);
    if (s->use_min_marker) s->draw_marker(painter, minMarkerKey, minMarkerValue, false, false);
    for (Marker& customMarker : s->markerList) {
        bool ok;
        double value = get_y(customMarker.frequent, ok);
        if (ok) s->draw_marker(painter, customMarker.frequent, value, customMarker.drawLine, s->markerList.indexOf(customMarker) == s->curSelectIndex);
    }
    if (s->use_sweep_frequent_rect) {
        s->draw_axis_rect(painter, s->sweep_frequent_range, s->middle_sweep_frequent);
    }
}
void Spectrum_Private::draw(QPainter* painter) {
    auto s = render_state();
    Performance_Shower* shower = q()->mPlot->d->mShower;
    if (shower) {
        shower->set_performance_line("mFrequentPointSize", Performance_Line(QString("mFrequentPointSize:%1").arg(s->frequent_point_size)));
    }
    draw_spectrum(painter, s);
    if (q()->hover_ok(q())) {
        q()->draw_hover(painter, s->frequent_axis, s->power_axis);
    }
}
void Spectrum::give_data(const QVector<double>& lineData) {
    if (!ok()) return;
    Spectrum_Private* pd = d();
    Render_State_Lease<Spectrum_Private, Spectrum_Render_State> state(pd);
    int frequent_point_size = state->frequent_point_size;
    if (lineData.size() != frequent_point_size) {
        qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << frequent_point_size;
        return;
    }
    Render_Input_Lease<Spectrum_Private, Spectrum_Input_Data> input(pd);
    input->mDataList.push_back(lineData);
}
void Spectrum::add_custom_marker(double frequent) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->markerList.append(Marker{frequent, false});
}
void Spectrum::add_custom_line_marker(double frequent) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->markerList.append(Marker{frequent, true});
}
void Spectrum::remove_custom_marker(double frequent) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    for (Marker& marker : edit->markerList) {
        if (qFuzzyCompare(marker.frequent, frequent)) {
            edit->markerList.removeOne(marker);
            break;
        }
    }
}
void Spectrum::remove_current_marker(SRC src) {
    Q_UNUSED(src)
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->markerList.removeAt(edit->curSelectIndex);
}
void Spectrum::clear_all_custom_marker(SRC src) {
    Q_UNUSED(src)
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->markerList.clear();
}
double Spectrum::get_mark_frequent(int markIndex, SRC src) {
    auto render_state = d()->state_data(src);
    if (markIndex < 0 || markIndex >= render_state->markerList.size())
        return -1;
    return render_state->markerList[markIndex].frequent;
}
void Spectrum::set_marker_frequent(int markerIndex, double frequent) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    QVector<Marker>& markers = edit->markerList;
    if (markerIndex < 0 || markerIndex >= markers.size())
        return;
    markers[markerIndex].frequent = frequent;
}
void Spectrum::set_current_marker_frequent(double frequent) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->set_cur_frequent(frequent);
}
int Spectrum::select_line_marker_size(SRC src) {
    auto render_state = d()->state_data(src);
    return render_state->markerList.size();
}
int Spectrum::cur_select_marker_index(SRC src) {
    auto render_state = d()->state_data(src);
    return render_state->curSelectIndex;
}
void Spectrum::set_selected_line_marker(int markerIndex) {
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->set_select_index(markerIndex);
}
void Spectrum::select_next(SRC src) {
    Q_UNUSED(src)
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->select_next_marker();
}
void Spectrum::select_previous(SRC src) {
    Q_UNUSED(src)
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->select_prev_marker();
}
void Spectrum::un_select_marker(SRC src) {
    Q_UNUSED(src)
    Render_Edit_Lease<Spectrum_Private, Spectrum_Render_State> edit(d());
    edit->un_select();
}
double Spectrum::get_power(double frequent, bool& ok, SRC src) {
    Q_UNUSED(src)
    return d()->get_y(frequent, ok);
}
}