// 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_HW(vector<double_vector>*, vector<bool_vector>&, int, vector<double>*, int);
int HW(vector<bool>&); 
void TEST1(vector <bool>*, vector <bool>*, vector <bool>*);

bool DPA_HW_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;
  int ctext_size;
  int hamming_weight_cut_off = ceil(no_of_output_bits/2);


    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();
      }

      ctext_size = ctext.size();      
      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_HW(&current_data,ctext,hamming_weight_cut_off,&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 = 0;

    for(j=1;j<max_key_comb;j++) {
      if( *(max+j) > absmax) {
        absmax = *(max+j);
        keyvalue = j;
      }
    }
    
    cout<<"Key Guess is : "<<keyvalue<<"\n";
    fplog<<"Key Guess is : "<<keyvalue<<"\n";

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

    *final_key = keyvalue;
    if ((*final_key) == correct_key) {
      done = 1;
    } else if (vectors > ctext_size) {
      cout<<"Found Incorrect key\n";
      fplog<<"Found Incorrect key\n";
      exit(2);
    }
    else { 
      cout<<"Peak Value For Correct key : "<<max[correct_key]<<"\n";
      fplog<<"Peak Value For Correct key : "<<max[correct_key]<<"\n";
      done = 0;
    }

  return(done);
}

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

void DPA_HW(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<double_vector> :: iterator iter_cd_i = current_data->begin();
  vector<double> :: iterator iter_cd_j = iter_cd_i->begin();

  int i,j;
 
  //Power Model for DPA
  for(i=0; i < vectors; i++) {
    if(HW(ctext[i]) < bit) {
      wf0.push_back((*iter_cd_i));
    } else if (HW(ctext[i]) >= bit) {
      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);

}

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

int HW(vector<bool> &ctext) {

  int i,HW=0;
  int size = ctext.size();
  
  for(i=0;i<size;i++) {
    if (ctext[i] == 1) {
      HW +=1;
    }
  }
  
  return(HW);
}