/*  nobII.c

This file is part of a program that implements a Software-Defined Radio.

Copyright (C) 2014 Warren Pratt, NR0V
Copyright (C) 2024 Edouard Griffiths, F4EXB Adapted to SDRangel

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

The author can be reached by email at

warren@wpratt.com

*/

#include "comm.hpp"

#define MAX_ADV_SLEW_TIME           (0.01) // Slew time
#define MAX_ADV_TIME                (0.01) // Lead time
#define MAX_HANG_SLEW_TIME          (0.01) // Slew time
#define MAX_HANG_TIME               (0.01) // Lag time
#define MAX_SEQ_TIME                (0.025)
#define MAX_SAMPLERATE              (1536000.0)

#include "nob.hpp"
#include "RXA.hpp"

namespace WDSP {

void NOB::init_nob()
{
    int i;
    double coef;

    adv_slew_count = (int)(advslewtime * samplerate);
    adv_count = (int)(advtime * samplerate);
    hang_count = (int)(hangtime * samplerate);
    hang_slew_count = (int)(hangslewtime * samplerate);
    max_imp_seq = (int)(max_imp_seq_time * samplerate);
    backmult = exp (-1.0 / (samplerate * backtau));
    ombackmult = 1.0 - backmult;

    if (adv_slew_count > 0)
    {
        coef = PI / (adv_slew_count + 1);

        for (i = 0; i < adv_slew_count; i++)
            awave[i] = 0.5 * cos ((i + 1) * coef);
    }

    if (hang_slew_count > 0)
    {
        coef = PI / hang_slew_count;

        for (i = 0; i < hang_slew_count; i++)
            hwave[i] = 0.5 * cos (i * coef);
    }

    flush();
}

NOB::NOB (
    int _run,
    int _buffsize,
    float* _in,
    float* _out,
    double _samplerate,
    int _mode,
    double _advslewtime,
    double _advtime,
    double _hangslewtime,
    double _hangtime,
    double _max_imp_seq_time,
    double _backtau,
    double _threshold
)
{
    run = _run;
    buffsize = _buffsize;
    in = _in;
    out = _out;
    samplerate = _samplerate;
    mode = _mode;
    advslewtime = _advslewtime;
    advtime = _advtime;
    hangslewtime = _hangslewtime;
    hangtime = _hangtime;
    max_imp_seq_time = _max_imp_seq_time;
    backtau = _backtau;
    threshold = _threshold;
    dline_size = (int)(MAX_SAMPLERATE * (
        MAX_ADV_SLEW_TIME +
        MAX_ADV_TIME +
        MAX_HANG_SLEW_TIME +
        MAX_HANG_TIME +
        MAX_SEQ_TIME ) + 2);
    dline = new double[dline_size * 2];
    imp = new int[dline_size];
    awave = new double[(int)(MAX_ADV_SLEW_TIME  * MAX_SAMPLERATE + 1)];
    hwave = new double[(int)(MAX_HANG_SLEW_TIME * MAX_SAMPLERATE + 1)];

    filterlen = 10;
    bfbuff = new double[filterlen * 2];
    ffbuff = new double[filterlen * 2];
    fcoefs = new double[filterlen];
    fcoefs[0] = 0.308720593;
    fcoefs[1] = 0.216104415;
    fcoefs[2] = 0.151273090;
    fcoefs[3] = 0.105891163;
    fcoefs[4] = 0.074123814;
    fcoefs[5] = 0.051886670;
    fcoefs[6] = 0.036320669;
    fcoefs[7] = 0.025424468;
    fcoefs[8] = 0.017797128;
    fcoefs[9] = 0.012457989;

    init_nob();
}

NOB::~NOB()
{
    delete[] fcoefs;
    delete[] ffbuff;
    delete[] bfbuff;
    delete[] hwave;
    delete[] awave;
    delete[] imp;
    delete[] dline;
}

void NOB::flush()
{
    out_idx = 0;
    scan_idx = out_idx + adv_slew_count + adv_count + 1;
    in_idx = scan_idx + max_imp_seq + hang_count + hang_slew_count + filterlen;
    state = 0;
    overflow = 0;
    avg = 1.0;
    bfb_in_idx = filterlen - 1;
    ffb_in_idx = filterlen - 1;
    std::fill(dline, dline + dline_size * 2, 0);
    std::fill(imp, imp + dline_size, 0);
    std::fill(bfbuff, bfbuff + filterlen * 2, 0);
    std::fill(ffbuff, ffbuff + filterlen * 2, 0);
}

void NOB::execute()
{
    double scale;
    double mag;
    int bf_idx;
    int ff_idx;
    int lidx, tidx;
    int i, j, k;
    int bfboutidx;
    int ffboutidx;
    int hcount;
    int len;
    int ffcount;
    int staydown;

    if (run)
    {
        for (i = 0; i < buffsize; i++)
        {
            dline[2 * in_idx + 0] = in[2 * i + 0];
            dline[2 * in_idx + 1] = in[2 * i + 1];
            mag = sqrt(dline[2 * in_idx + 0] * dline[2 * in_idx + 0] + dline[2 * in_idx + 1] * dline[2 * in_idx + 1]);
            avg = backmult * avg + ombackmult * mag;

            if (mag > (avg * threshold))
                imp[in_idx] = 1;
            else
                imp[in_idx] = 0;

            if ((bf_idx = out_idx + adv_slew_count) >= dline_size)
                bf_idx -= dline_size;

            if (imp[bf_idx] == 0)
            {
                if (++bfb_in_idx == filterlen)
                    bfb_in_idx -= filterlen;

                bfbuff[2 * bfb_in_idx + 0] = dline[2 * bf_idx + 0];
                bfbuff[2 * bfb_in_idx + 1] = dline[2 * bf_idx + 1];
            }

            switch (state)
            {
                case 0:     // normal output & impulse setup
                    {
                        out[2 * i + 0] = dline[2 * out_idx + 0];
                        out[2 * i + 1] = dline[2 * out_idx + 1];
                        Ilast = dline[2 * out_idx + 0];
                        Qlast = dline[2 * out_idx + 1];

                        if (imp[scan_idx] > 0)
                        {
                            time = 0;

                            if (adv_slew_count > 0)
                                state = 1;
                            else if (adv_count > 0)
                                state = 2;
                            else
                                state = 3;

                            tidx = scan_idx;
                            blank_count = 0;

                            do
                            {
                                len = 0;
                                hcount = 0;

                                while ((imp[tidx] > 0 || hcount > 0) && blank_count < max_imp_seq)
                                {
                                    blank_count++;
                                    if (hcount > 0)
                                        hcount--;
                                    if (imp[tidx] > 0)
                                        hcount = hang_count + hang_slew_count;
                                    if (++tidx >= dline_size)
                                        tidx -= dline_size;
                                }

                                j = 1;
                                len = 0;
                                lidx = tidx;

                                while (j <= adv_slew_count + adv_count && len == 0)
                                {
                                    if (imp[lidx] == 1)
                                    {
                                        len = j;
                                        tidx = lidx;
                                    }

                                    if (++lidx >= dline_size)
                                        lidx -= dline_size;

                                    j++;
                                }

                                if((blank_count += len) > max_imp_seq)
                                {
                                    blank_count = max_imp_seq;
                                    overflow = 1;
                                    break;
                                }
                            }
                            while (len != 0);

                            if (overflow == 0)
                            {
                                blank_count -= hang_slew_count;
                                Inext = dline[2 * tidx + 0];
                                Qnext = dline[2 * tidx + 1];

                                if (mode == 1 || mode == 2 || mode == 4)
                                {
                                    bfboutidx = bfb_in_idx;
                                    I1 = 0.0;
                                    Q1 = 0.0;

                                    for (k = 0; k < filterlen; k++)
                                    {
                                        I1 += fcoefs[k] * bfbuff[2 * bfboutidx + 0];
                                        Q1 += fcoefs[k] * bfbuff[2 * bfboutidx + 1];

                                        if (--bfboutidx < 0)
                                            bfboutidx += filterlen;
                                    }
                                }

                                if (mode == 2 || mode == 3 || mode == 4)
                                {
                                    if ((ff_idx = scan_idx + blank_count) >= dline_size)
                                        ff_idx -= dline_size;

                                    ffcount = 0;

                                    while (ffcount < filterlen)
                                    {
                                        if (imp[ff_idx] == 0)
                                        {
                                            if (++ffb_in_idx == filterlen)
                                                ffb_in_idx -= filterlen;

                                            ffbuff[2 * ffb_in_idx + 0] = dline[2 * ff_idx + 0];
                                            ffbuff[2 * ffb_in_idx + 1] = dline[2 * ff_idx + 1];
                                            ++ffcount;
                                        }

                                        if (++ff_idx >= dline_size)
                                            ff_idx -= dline_size;
                                    }

                                    if ((ffboutidx = ffb_in_idx + 1) >= filterlen)
                                        ffboutidx -= filterlen;

                                    I2 = 0.0;
                                    Q2 = 0.0;

                                    for (k = 0; k < filterlen; k++)
                                    {
                                        I2 += fcoefs[k] * ffbuff[2 * ffboutidx + 0];
                                        Q2 += fcoefs[k] * ffbuff[2 * ffboutidx + 1];

                                        if (++ffboutidx >= filterlen)
                                            ffboutidx -= filterlen;
                                    }
                                }

                                switch (mode)
                                {
                                    case 0: // zero
                                        deltaI = 0.0;
                                        deltaQ = 0.0;
                                        I = 0.0;
                                        Q = 0.0;
                                        break;
                                    case 1: // sample-hold
                                        deltaI = 0.0;
                                        deltaQ = 0.0;
                                        I = I1;
                                        Q = Q1;
                                        break;
                                    case 2: // mean-hold
                                        deltaI = 0.0;
                                        deltaQ = 0.0;
                                        I = 0.5 * (I1 + I2);
                                        Q = 0.5 * (Q1 + Q2);
                                        break;
                                    case 3: // hold-sample
                                        deltaI = 0.0;
                                        deltaQ = 0.0;
                                        I = I2;
                                        Q = Q2;
                                        break;
                                    case 4: // linear interpolation
                                        deltaI = (I2 - I1) / (adv_count + blank_count);
                                        deltaQ = (Q2 - Q1) / (adv_count + blank_count);
                                        I = I1;
                                        Q = Q1;
                                        break;
                                }
                            }
                            else
                            {
                                if (adv_slew_count > 0)
                                {
                                    state = 5;
                                }
                                else
                                {
                                    state = 6;
                                    time = 0;
                                    blank_count += adv_count + filterlen;
                                }
                            }
                        }

                        break;
                    }

                case 1:     // slew output in advance of blanking period
                    {
                        scale = 0.5 + awave[time];
                        out[2 * i + 0] = Ilast * scale + (1.0 - scale) * I;
                        out[2 * i + 1] = Qlast * scale + (1.0 - scale) * Q;

                        if (++time == adv_slew_count)
                        {
                            time = 0;

                            if (adv_count > 0)
                                state = 2;
                            else
                                state = 3;
                        }

                        break;
                    }

                case 2:     // initial advance period
                    {
                        out[2 * i + 0] = I;
                        out[2 * i + 1] = Q;
                        I += deltaI;
                        Q += deltaQ;

                        if (++time == adv_count)
                        {
                            state = 3;
                            time = 0;
                        }

                        break;
                    }

                case 3:     // impulse & hang period
                    {
                        out[2 * i + 0] = I;
                        out[2 * i + 1] = Q;
                        I += deltaI;
                        Q += deltaQ;

                        if (++time == blank_count)
                        {
                            if (hang_slew_count > 0)
                            {
                                state = 4;
                                time = 0;
                            }
                            else
                            {
                                state = 0;
                            }
                        }

                        break;
                    }

                case 4:     // slew output after blanking period
                    {
                        scale = 0.5 - hwave[time];
                        out[2 * i + 0] = Inext * scale + (1.0 - scale) * I;
                        out[2 * i + 1] = Qnext * scale + (1.0 - scale) * Q;

                        if (++time == hang_slew_count)
                            state = 0;

                        break;
                    }

                case 5:
                    {
                        scale = 0.5 + awave[time];
                        out[2 * i + 0] = Ilast * scale;
                        out[2 * i + 1] = Qlast * scale;

                        if (++time == adv_slew_count)
                        {
                            state = 6;
                            time = 0;
                            blank_count += adv_count + filterlen;
                        }

                        break;
                    }

                case 6:
                    {
                        out[2 * i + 0] = 0.0;
                        out[2 * i + 1] = 0.0;

                        if (++time == blank_count)
                            state = 7;

                        break;
                    }

                case 7:
                    {
                        out[2 * i + 0] = 0.0;
                        out[2 * i + 1] = 0.0;
                        staydown = 0;
                        time = 0;

                        if ((tidx = scan_idx + hang_slew_count + hang_count) >= dline_size)
                            tidx -= dline_size;

                        while (time++ <= adv_count + adv_slew_count + hang_slew_count + hang_count)                                                                            //  CHECK EXACT COUNTS!!!!!!!!!!!!!!!!!!!!!!!
                        {
                            if (imp[tidx] == 1) staydown = 1;
                            if (--tidx < 0) tidx += dline_size;
                        }

                        if (staydown == 0)
                        {
                            if (hang_count > 0)
                            {
                                state = 8;
                                time = 0;
                            }
                            else if (hang_slew_count > 0)
                            {
                                state = 9;
                                time = 0;

                                if ((tidx = scan_idx + hang_slew_count + hang_count - adv_count - adv_slew_count) >= dline_size)
                                    tidx -= dline_size;

                                if (tidx < 0)
                                    tidx += dline_size;

                                Inext = dline[2 * tidx + 0];
                                Qnext = dline[2 * tidx + 1];
                            }
                            else
                            {
                                state = 0;
                                overflow = 0;
                            }
                        }

                        break;
                    }

                case 8:
                    {
                        out[2 * i + 0] = 0.0;
                        out[2 * i + 1] = 0.0;

                        if (++time == hang_count)
                        {
                            if (hang_slew_count > 0)
                            {
                                state = 9;
                                time = 0;

                                if ((tidx = scan_idx + hang_slew_count - adv_count - adv_slew_count) >= dline_size)
                                    tidx -= dline_size;

                                if (tidx < 0)
                                    tidx += dline_size;

                                Inext = dline[2 * tidx + 0];
                                Qnext = dline[2 * tidx + 1];
                            }
                            else
                            {
                                state = 0;
                                overflow = 0;
                            }
                        }

                        break;
                    }

                case 9:
                    {
                        scale = 0.5 - hwave[time];
                        out[2 * i + 0] = Inext * scale;
                        out[2 * i + 1] = Qnext * scale;

                        if (++time >= hang_slew_count)
                        {
                            state = 0;
                            overflow = 0;
                        }

                        break;
                    }
                default:
                    break;
            }

            if (++in_idx == dline_size)
                in_idx = 0;

            if (++scan_idx == dline_size)
                scan_idx = 0;

            if (++out_idx == dline_size)
                out_idx = 0;
        }
    }
    else if (in != out)
    {
        std::copy(in, in + buffsize * 2, out);
    }
}

void NOB::setBuffers(float* _in, float* _out)
{
    in = _in;
    out = _out;
}

void NOB::setSize(int size)
{
    buffsize = size;
    flush();
}

/********************************************************************************************************
*                                                                                                       *
*                                        Common interface                                               *
*                                                                                                       *
********************************************************************************************************/

void NOB::setRun(int _run)
{
    run = _run;
}

void NOB::setMode(int _mode)
{
    mode = _mode;
}

void NOB::setBuffsize(int size)
{
    buffsize = size;
}

void NOB::setSamplerate(int rate)
{
    samplerate = (double) rate;
    init_nob();
}

void NOB::setTau(double tau)
{
    advslewtime = tau;
    hangslewtime = tau;
    init_nob();
}

void NOB::setHangtime(double _time)
{
    hangtime = _time;
    init_nob();
}

void NOB::setAdvtime(double _time)
{
    advtime = _time;
    init_nob();
}

void NOB::setBacktau(double tau)
{
    backtau = tau;
    init_nob();
}

void NOB::setThreshold(double thresh)
{
    threshold = thresh;
}

} // namespace