#include "gtl_math_delta_phase_spec.h"

namespace gtl
{
    namespace math
    {

        delta_phase_spec::delta_phase_spec(gtl::analog_data *ref, gtl::analog_data *data)
            : _ref_spec(nullptr),
              _data_spec(nullptr),
              _phase(0),
              _freq(0),
              _max_freq(0)
        {
            _device = static_cast<gtl::device*>(data->root());

            if(_device)
                _device->lock_ai();

            _ref_spec = new gtl::math::spec(gtl::math::spec::types::phase, ref);
            _data_spec = new gtl::math::spec(gtl::math::spec::types::phase, data);

            if(_device)
                connect(_device, &gtl::device::recieved_data, this, &delta_phase_spec::calculate);

            if(_device)
                _device->unlock_ai();

            connect(_ref_spec, &gtl::math::spec::resolution_changed, this, &delta_phase_spec::resolution_changed);
            connect(_ref_spec, &gtl::math::spec::overlap_changed, this, &delta_phase_spec::overlap_changed);
        }

        delta_phase_spec::~delta_phase_spec()
        {
            delete _ref_spec;
            delete _data_spec;
        }

        qreal delta_phase_spec::frequency() const
        {
            return _freq;
        }

        void delta_phase_spec::set_frequency(qreal value)
        {
            if(value != _freq && value > 0 && value < _ref_spec->frequency())
            {
                _freq = value;

                if(!_max_freq)
                {
                    if(_device)
                        _device->lock_ai();

                    _ref_spec->set_frequency(_freq*2);
                    _data_spec->set_frequency(_freq*2);

                    if(_device)
                        _device->unlock_ai();
                }

                emit frequency_changed();
            }
        }

        qreal delta_phase_spec::max_frequency() const
        {
            return _max_freq;
        }

        void delta_phase_spec::set_max_frequency(qreal value)
        {
            if(value != _max_freq && value >= 0)
            {
                _max_freq = value;

                qreal max_freq = _max_freq ? _max_freq : _freq*2;

                if(_device)
                    _device->lock_ai();

                _ref_spec->set_frequency(max_freq);
                _data_spec->set_frequency(max_freq);

                if(_device)
                    _device->unlock_ai();
            }
        }

        qreal delta_phase_spec::resolution() const
        {
            return _ref_spec->resolution();
        }

        void delta_phase_spec::set_resolution(qreal value)
        {
            if(_device)
                _device->lock_ai();

            _ref_spec->set_resolution(value);
            _data_spec->set_resolution(value);

            if(_device)
                _device->unlock_ai();
        }

        qreal delta_phase_spec::overlap() const
        {
            return _ref_spec->overlap();
        }

        void delta_phase_spec::set_overlap(int value)
        {
            if(_device)
                _device->lock_ai();

            _ref_spec->set_overlap(value);
            _data_spec->set_overlap(value);

            if(_device)
                _device->unlock_ai();
        }

        qreal delta_phase_spec::value()
        {
            return _phase;
        }

        void delta_phase_spec::calculate()
        {
            if(_ref_spec->samples() != _data_spec->samples())
                return;

            if(_device)
                _device->lock_ai();

            if(_freq)
            {
                qreal phase = 0;
                int idx = std::round(_freq/_ref_spec->resolution());

                if(idx < _ref_spec->size() && idx < _data_spec->size())
                    phase = _data_spec->at(idx) - _ref_spec->at(idx);
                else
                    return;

                phase = 180*phase/M_PI;
                if(phase < 0)
                    phase += 360.;
//                if(phase >= 180.)
//                    phase = 360. - phase;

                _phase = phase;
                emit value_changed();
            }

            if(_device)
                _device->unlock_ai();
        }

    } // namespace math
} // namespace gtl