// Copyright (c) The University of Cincinnati. All rights reserved.
// UC MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
// THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  UC SHALL NOT BE LIABLE
// FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
// DERIVATIVES.
// By using or copying this Software, Licensee agrees to abide by the
// intellectual property laws, and all other applicable laws of the
// U.S., and the terms of this license.

// Author : Antarpreet Singh
//

#include <iostream>
#include <vector>
#include <string>
#include <math.h>

using namespace std;

typedef vector <double> double_vector;  
typedef vector <bool> bool_vector;

void DPA_OPB(vector<double_vector>*, vector<bool_vector>*, int, vector<double>*, int);
void DPA_DOM(int, vector<double_vector>&, vector<double_vector>&, vector<double>*);
void DES10(vector <bool>*, vector <bool>*, vector <bool>*);
void TEST1(vector <bool>*, vector <bool>*, vector <bool>*);

bool DPA_OPB_DOM(int no_of_output_bits, int max_key_comb, int vectors, vector <bool_vector> &ptext, vector <double_vector> &current_data, vector <double_vector> &diffwf, int *final_key, vector <bool_vector> &kg, double *max, int clock_posedge_time_min, int clock_posedge_time_max, int correct_key, ofstream &fplog,string testname,string algorithm) { 

  vector <bool_vector> ctext;
  vector <bool> ctext_temp;
  
  vector <double> diffwf_temp;

  int i,j,k;
  double absmax;
  bool done;

  int keyvalue[no_of_output_bits];

  for(k=0;k<no_of_output_bits;k++) {
 
    for(j=0;j<max_key_comb;j++) {

      //Peform DES
      for(i=0;i<ptext.size()-1;i++) {
	      if (algorithm == "DES10") {
        	DES10(&ptext[i],&kg[j],&ctext_temp);
	      } 
	      else if (algorithm == "TEST1") {
        	TEST1(&ptext[i],&kg[j],&ctext_temp);
	      }
        ctext.push_back(ctext_temp);
        ctext_temp.clear();
      }
      
      if(vectors > ctext.size()) {
      cout<<" All the vectors are exhausted. Unable to find key"<<"\n";
      fplog<<" All the vectors are exhausted. Unable to find key"<<"\n";
      exit(1);
      }
      //Perform DPA
      DPA_OPB(&current_data,&ctext,k,&diffwf_temp,vectors);
      diffwf.push_back(diffwf_temp);
      diffwf_temp.clear();
      ctext.clear();
    }

 
    for(j=0;j<max_key_comb;j++) {
      *(max+j) = diffwf[j][0];  
      for(i=clock_posedge_time_min;i<clock_posedge_time_max;i++) {
        if( diffwf[j][i] > max[j]) {
          *(max+j) = diffwf[j][i];
        }
      }
    }

    absmax = *max;
    keyvalue[k] = 0;

    for(j=1;j<max_key_comb;j++) {
      if( *(max+j) > absmax) {
        absmax = *(max+j);
        keyvalue[k] = j;
      }
    }

    cout<<"Bit is : "<<k<<"\n";
    fplog<<"Bit is : "<<k<<"\n";
    cout<<"Key Guess is : "<<keyvalue[k]<<"\n";
    fplog<<"Key Guess is : "<<keyvalue[k]<<"\n";

    cout<<"Peak Value For Key Guess : "<<max[keyvalue[k]]<<"\n";
    fplog<<"Peak Value For Key Guess : "<<max[keyvalue[k]]<<"\n";
    cout<<"Peak Value For Correct key : "<<max[correct_key]<<"\n";
    fplog<<"Peak Value For Correct key : "<<max[correct_key]<<"\n";

    if ( k != no_of_output_bits-1 ) {
      diffwf.clear();
    }
    
  }
  
  done = 1; 
  for(k=0;k<no_of_output_bits-1;k++){
    if(keyvalue[k] != keyvalue[k+1]) {
      done = 0;
    }
  }
 
  *final_key = keyvalue[0];
  
  if(done == 1 && *final_key != correct_key) {
    cout<<"Found Incorrect key\n";
    fplog<<"Found Incorrect key\n";
    //exit(2);
  }

     
  return(done);
}

/******************************************************************/

void DPA_OPB(vector<double_vector> *current_data, vector<bool_vector> *ctext, int bit, vector<double> *diffwf1, int vectors) {

  vector <double_vector> wf0;
  vector <double_vector> wf1;
 
  vector<bool_vector> :: iterator iter_ii;
  vector<bool_vector> :: iterator iter_ii_init;
  vector<bool> :: iterator iter_jj;
 
  vector<double_vector> :: iterator iter_cd_i = current_data->begin();
  vector<double> :: iterator iter_cd_j = iter_cd_i->begin();

  iter_ii_init=ctext->begin();

  //Power Model for DPA
  for(iter_ii=ctext->begin(); (iter_ii-iter_ii_init) < vectors; iter_ii++) {
    iter_jj = iter_ii->begin();
    if(*(iter_jj+bit) == 0) {
      wf0.push_back((*iter_cd_i));
    } else if (*(iter_jj+bit) == 1) {
      wf1.push_back((*iter_cd_i));
    }   
    iter_cd_i++; 
  } 

  int no_of_samples_x = (*current_data)[0].size(); 
  int no_of_samples_y = current_data->size()-1; 
 
  DPA_DOM(no_of_samples_x,wf0,wf1,diffwf1);

}
/******************************************************************/
void DPA_DOM(int no_of_samples_x, vector<double_vector> &wf0, vector<double_vector> &wf1, vector<double> *diffwf1) {

  int i,j;

  double meanwf0[no_of_samples_x];
  double meanwf1[no_of_samples_x];

    for(i=0;i<no_of_samples_x;i++) {
        meanwf0[i] = 0; 
        meanwf1[i] = 0; 
    }

    int wf0size = wf0.size();
    int wf1size = wf1.size();

    for(i=0;i<no_of_samples_x;i++) {
      for(j=0;j<wf0size;j++) {
        meanwf0[i] = meanwf0[i] + wf0[j][i]; 
      }
      for(j=0;j<wf1size;j++) {
        meanwf1[i] = meanwf1[i] + wf1[j][i]; 
      }
    }
 
    wf0.clear();
    wf1.clear();
   
    for(i=0;i<no_of_samples_x;i++) {
        meanwf0[i] = meanwf0[i]/(wf0size+1); 
        meanwf1[i] = meanwf1[i]/(wf1size+1); 
    }
    
    for(i=0;i<no_of_samples_x;i++) {
        (*diffwf1).push_back(fabs(meanwf1[i] - meanwf0[i])); 
    }
}

/******************************************************************/