#include <utility>
#include "../Axis/Abs_Axis.h"
#include "../base/Memory.h"
#include "Sweep_Spectrum_p.h"
namespace renderive {
RENDERIVE_DEFINE_RENDERABLE_BINDING(Sweep_Spectrum, Sweep_Spectrum_Private, Sweep_Spectrum_Render_State, Sweep_Spectrum_Input_Data, "Sweep_Frequency")
std::shared_ptr<Axis> Sweep_Spectrum::frequency_axis() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::frequency_axis).lock();
}
void Sweep_Spectrum::set_frequency_axis(std::shared_ptr<Axis> value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::frequency_axis, std::weak_ptr<Axis>(value));
}
std::shared_ptr<Axis> Sweep_Spectrum::power_axis() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::power_axis).lock();
}
void Sweep_Spectrum::set_power_axis(std::shared_ptr<Axis> value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::power_axis, std::weak_ptr<Axis>(value));
}
Range Sweep_Spectrum::frequency_range() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::frequency_range);
}
void Sweep_Spectrum::set_frequency_range(Range value) {
    if (value.length() == 0.0)
        return;
    d()->set_state_value(&Sweep_Spectrum_Render_State::frequency_range, std::move(value));
}
int Sweep_Spectrum::bins_per_block() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::bins_per_block);
}
void Sweep_Spectrum::set_bins_per_block(int value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::bins_per_block, std::max(1, value));
}
int Sweep_Spectrum::block_count() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::block_num);
}
void Sweep_Spectrum::set_block_count(int value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::block_num, std::max(1, value));
}
Pen Sweep_Spectrum::pen() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::pen);
}
void Sweep_Spectrum::set_pen(Pen value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::pen, std::move(value));
}
Pen Sweep_Spectrum::cur_frequency_pen() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::current_frequency_pen);
}
void Sweep_Spectrum::set_cur_frequency_pen(Pen value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::current_frequency_pen, std::move(value));
}
bool Sweep_Spectrum::visible_range_only() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::visible_range_only);
}
void Sweep_Spectrum::set_visible_range_only(bool value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::visible_range_only, value);
}
Line_Interpolation_Mode Sweep_Spectrum::interpolation_mode() {
    return d()->edit_state_value(&Sweep_Spectrum_Render_State::interpolation_mode);
}
void Sweep_Spectrum::set_interpolation_mode(Line_Interpolation_Mode value) {
    d()->set_state_value(&Sweep_Spectrum_Render_State::interpolation_mode, value);
}
void Sweep_Spectrum::append_block(std::span<const double> data) {
    if (!ok())
        return;
    Sweep_Spectrum_Private* pd = d();
    int block_frequency_point_size{};
    {
        Render_State_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Render_State> state(pd);
        block_frequency_point_size = state->bins_per_block;
    }
    if (data.size() != block_frequency_point_size)
        return;
    Render_Input_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Input_Data> input(pd);
    input->data.push(data, Sweep_Spectrum_Input_Data::Latest_Only_Count);
}
void Sweep_Spectrum::append_block(std::pmr::vector<double>&& data) {
    if (!ok())
        return;
    Sweep_Spectrum_Private* pd = d();
    int block_frequency_point_size{};
    {
        Render_State_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Render_State> state(pd);
        block_frequency_point_size = state->bins_per_block;
    }
    if (data.size() != block_frequency_point_size)
        return;
    Render_Input_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Input_Data> input(pd);
    input->data.push(std::move(data), Sweep_Spectrum_Input_Data::Latest_Only_Count);
}
Sweep_Spectrum::Builder::Builder(std::shared_ptr<Renderable> parent, std::shared_ptr<Axis> frequency_axis, std::shared_ptr<Axis> power_axis) {
    ASSERT(parent, "Sweep_Frequency build error! parent == nullptr");
    ASSERT(frequency_axis && power_axis, "Sweep_Frequency build error! axis == nullptr");
    ASSERT(frequency_axis->attached_to_plot(), "Sweep_Frequency build error! frequency_axis->plot == nullptr");
    ASSERT(frequency_axis->shares_plot_with(*power_axis), "Sweep_Frequency build error! frequency_axis->plot != power_axis->plot");
    ASSERT(parent->shares_plot_with(*frequency_axis), "Sweep_Frequency build error! parent->plot != axis->plot");
    ASSERT(frequency_axis->orientation() != power_axis->orientation(), "Sweep_Frequency build error! axes must be orthogonal");
    this->parent = parent;
    this->frequency_axis = frequency_axis;
    this->power_axis = power_axis;
}
std::shared_ptr<Sweep_Spectrum> Sweep_Spectrum::Builder::build() {
    auto ret = renderive::make_shared<Sweep_Spectrum>();
    ret->init(parent);
    Sweep_Spectrum_Private* pd = ret->d();
    Render_Edit_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Render_State> edit(pd);
    Sweep_Spectrum_Render_State* sc = edit.operator->();
    PROP_R(std::weak_ptr<Axis>, frequency_axis)
    PROP_R(std::weak_ptr<Axis>, power_axis)
    PROP_R(Range, frequency_range)
    PROP_R(int, bins_per_block)
    PROP_R(int, block_num)
    PROP_R(Pen, pen)
    PROP_R(Pen, current_frequency_pen)
    PROP_R(bool, visible_range_only)
    PROP_R(Line_Interpolation_Mode, interpolation_mode)
    sc->bins_per_block = std::max(1, sc->bins_per_block);
    sc->block_num = std::max(1, sc->block_num);
    if (sc->frequency_range.length() == 0.0)
        sc->frequency_range = {0.0, 1.0};
    return ret;
}
} // namespace renderive