#include <Arduino.h>

#if defined(__SAM3X8E__)
#include <DueTimer.h>
#endif

#include "mode.h"
#include "dac.h"
#include "amptimer.h"

struct SSweep
{
    bool enable;

    double startFreq;   // Hz
    double endFreq;     // Hz
    double sweepRate;   // Hz/sec

    double currFreq;    // current frequency
    bool dir;           // current direction. false - mean from start to end

    SSweep()
    {
        enable = false;

        startFreq = 0.5;
        endFreq = 10;
        sweepRate = 0.5;

        currFreq = startFreq;
        dir = false;
    }
};

#define SWEEP_STEPS_MAX_COUNT       2000


double m_freq = 0;

SSweep m_sweep;



#if !defined(__SAM3X8E__)
    int tick_mult = 1;
    int tick_count = 0;
    uint32_t  tmr_tick_in_count = 20;

    int sweep_tick_mult = 1;
    int sweep_tick_count = 0;
    uint32_t  sweep_tmr_tick_in_count = 20;
#endif



#if defined(__SAM3X8E__)
void Timer1Interrupt()
{
#else
ISR(TIMER1_OVF_vect)
{
    TCNT1 = tmr_tick_in_count;

    if (tick_mult > 1)
    {
        tick_count++;

        if (tick_count < tick_mult)
            return;
    }

    tick_count = 0;

#endif


    uint32_t val = getNextDAC() >> 4; // conv resolution from 16 to 12 bit 

    dac_write(val);


}

#if defined(__SAM3X8E__)
void Timer2Interrupt()
{
    if (!m_sweep.enable)
        return;

#else
ISR(TIMER5_OVF_vect)
{
    TCNT5 = sweep_tmr_tick_in_count;

    if (sweep_tick_mult > 1)
    {
        sweep_tick_count++;

        if (sweep_tick_count < sweep_tick_mult)
            return;
    }

    sweep_tick_count = 0;

#endif

    double diff = m_sweep.sweepRate / (double)SWEEP_STEPS_MAX_COUNT;

    if (m_sweep.endFreq < m_sweep.startFreq) diff *= -1.0;

    double nextFreq = m_sweep.dir ? m_sweep.currFreq - diff : m_sweep.currFreq + diff;

    double maxfreq = max(m_sweep.endFreq, m_sweep.startFreq);
    double minfreq = min(m_sweep.endFreq, m_sweep.startFreq);

    if (nextFreq > maxfreq || nextFreq < minfreq)
    {
        nextFreq = m_sweep.currFreq;
        m_sweep.dir = !m_sweep.dir;
    }

    m_sweep.currFreq = nextFreq;



//    static int dbg_step = 0; dbg_step++;
//    if ((dbg_step % 16) == 0)
//		Serial.println(nextFreq, 3);
//    dbg_step = dbg_step % 16;



    setFreq(nextFreq);


}


void timer_init()
{
#if defined(__SAM3X8E__)
    Timer1.attachInterrupt(Timer1Interrupt);
    Timer2.attachInterrupt(Timer2Interrupt);
#else
    TCCR1B = 0x00;
    TCCR5B = 0x00;
#endif
}



double getFreq()
{
    return m_freq;
}


#define MIN_FREQ            0.1
#define MAX_FREQ            200.0
#define MIN_SWEEP_RATE      0.01
#define MAX_SWEEP_RATE      20.0


void setFreq(double freq) // [0.1 - 200.0]
{
    if (freq < MIN_FREQ) freq = MIN_FREQ;
    if (freq > MAX_FREQ) freq = MAX_FREQ;

    m_freq = freq;


#if defined(__SAM3X8E__)

    Timer1.stop();
    Timer1.setFrequency(freq * getTabSize());
    Timer1.start();

#else

    int mult = 1;

    uint32_t pulses = (uint32_t)(F_CPU / (freq * getTabSize()));

    while (pulses > 40000)
    {
        pulses /= 2;
        mult *= 2;
    }

    tmr_tick_in_count = 65535 - pulses; 

    tick_mult = mult;

#endif // __SAM3X8E__


}


void setSweepEnable(bool bEnable)
{
    m_sweep.enable = bEnable;
}

void setSweep(double start, double end, double rate)
{
    if (start < MIN_FREQ) start = MIN_FREQ;
    if (start > MAX_FREQ) start = MAX_FREQ;
    if (end < MIN_FREQ) end = MIN_FREQ;
    if (end > MAX_FREQ) end = MAX_FREQ;
    if (rate < MIN_SWEEP_RATE) rate = MIN_SWEEP_RATE;
    if (rate > MAX_SWEEP_RATE) rate = MAX_SWEEP_RATE;

    m_sweep.startFreq = start;
    m_sweep.endFreq = end;
    m_sweep.sweepRate = rate;

    m_sweep.currFreq = m_sweep.startFreq;
    m_sweep.dir = false; // false - mean from start to end; true - from end to start


#if defined(__SAM3X8E__)

    Timer2.stop();
    Timer2.setFrequency(rate * SWEEP_STEPS_MAX_COUNT);
    Timer2.start();

#else

    int mult = 1;

    uint32_t pulses = (uint32_t)(F_CPU / (rate * SWEEP_STEPS_MAX_COUNT));//

    while (pulses > 40000)
    {
        pulses /= 2;
        mult *= 2;
    }

    sweep_tmr_tick_in_count = 65535 - pulses;

    sweep_tick_mult = mult;

#endif // __SAM3X8E__
}


void setSweep(const char* szSweep)
{
    if (strstr(szSweep, "?") != NULL)
    {
        return;
    }
    else if (strstr(szSweep, "no") != NULL)
    {
        setSweepEnable(false);
        return;
    }

    double startFreq = atof(szSweep);
    double endFreq = 0;
    double sweepRate = 0;
    
    char* szNext = strstr(szSweep, ";");

    if (szNext != NULL)
    {
        szNext += 1;

        endFreq = atof(szNext);

        szNext = strstr(szNext, ";");

        if (szNext != NULL)
        {
            szNext += 1;

            sweepRate = atof(szNext);

            setSweep(startFreq, endFreq, sweepRate);

            setSweepEnable(true);
        }
    }

}


char sweepparams[50];

const char* getSweepParams()
{
    if (m_sweep.enable)
        sprintf(sweepparams, "%0.3f;%0.3f;%0.3f;", m_sweep.startFreq, m_sweep.endFreq, m_sweep.sweepRate);
    else
        strcpy(sweepparams, "no");

    return sweepparams;
}