#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.01
#define MAX_FREQ            200.0
#define MIN_SWEEP_RATE      0.01
#define MAX_SWEEP_RATE      20.0


void setFreq(double freq) // [0.01 - 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;
}