#include <iostream>
#include <strstream>

#include <vector>
#include <algorithm>
#include <bitset>

using namespace std;

#include "GPS.h"
#include "util/util.h"
#include "param/complex.h"
#include "param/fft.h"

typedef double real_t;
typedef Complex<real_t> complex_t;

#define IF_FREQ  4.309E6 // Hz
#define CLK_FREQ 5.714E6 // Hz
#define OUT_FREQ ((IF_FREQ < (CLK_FREQ / 2)) ? IF_FREQ : (CLK_FREQ - IF_FREQ))

/*
 * 5714         sampled data = 1     ms, resolution 1000  Hz => 21 step (+-10KHz)
 * 4096(2^{14}) sampled data = 0.717 ms, resolution 1395  Hz => 15 step (+-10KHz)
 * 8192(2^{15}) sampled data = 1.434 ms, resolution 697.5 Hz => 29 step (+-10KHz)
 */
 
#define DATA_SIZE_AQ 5714
//#define DATA_SIZE_AQ 8192
//#define DATA_SIZE_AQ 64

#define FREQ_RANGE_AQ 10E3

#define FREQ_STEP (CLK_FREQ / DATA_SIZE_AQ)

typedef struct{
  template <class T>
  T operator()(const T &value){return value > 0 ? value : -value;}
  template <class T>
  T operator()(const Complex<T> &value){return value.abs();}
} Func_abs;

int main(int argc, char *argv[]){
  
  for(int sid = 1; sid < 37; sid++){
    
    cout << "SID: " << sid << endl;
    
    for(int i = -(int)floor(FREQ_RANGE_AQ / FREQ_STEP); i <= (int)floor(FREQ_RANGE_AQ / FREQ_STEP); i++){
     
      // 3. Generate local codes using eq.(7.1), l_{si}(n)
      vector<complex_t> local_signal_td;
      real_t f_i(OUT_FREQ + FREQ_STEP * i);
      cout << "FREQ index: " << i << "; FREQ: " << f_i << endl;
      CA_Code ca_code(sid);
      int ca_code_index(0);
      real_t time(0);
      for(int j = 0; j < DATA_SIZE_AQ; j++, time += (1. / CLK_FREQ)){
        int current_ca_code_index((int)(time / CA_Code::LENGTH_1CHIP));
        //cout << ca_code_index << endl;
        while(current_ca_code_index > ca_code_index){
          ca_code_index++;
          ca_code.next();
        }
        local_signal_td.push_back(iexp(2. * M_PI * f_i * time) * ca_code.get_multi());
      }
      //copy(local_signal_td.begin(), local_signal_td.end(), ostream_iterator<complex_t>(cout, " "));
      //cout << endl;
      
      // 4. Perform FFT on local codes, l_{si}(n) -> L_{si}(k)
      vector<complex_t> local_signal_fd(FFT::fft(local_signal_td));
      vector<real_t> local_signal_power(local_signal_fd.size());
      transform(local_signal_fd.begin(), local_signal_fd.end(),
                  local_signal_power.begin(),
                  Func_abs());
      copy(local_signal_power.begin(), local_signal_power.end(), ostream_iterator<real_t>(cout, "\n"));
      cout << endl;
    }
  }
    
  return 0;
}