#include <iostream>
#include <fstream>
#include <string>

#include "ecdh.h"

#include "../ecclib/gfp/gfp.h"
#include "../ecclib/protocols/ecdh.h"
#include "../ecclib/protocols/eckeygen.h"
#include "../ecclib/utils/param.h"
#include "../ecclib/utils/rand.h"
#include "random.h"
#include "endian.h"

#define param (&param_)

ecdh::ecdh(const curve_type_t type)
{
  // Load curve data
  param_load(&param_, type);
}

void ecdh::generate_key_pair()
{
  // Generate key pair
  eckeygen(private_key_, &public_key_, &param_);
}

void ecdh::set_private_key(const gfp_t private_key)
{
  // Copy private key
  gfp_copy(private_key_, private_key);
  // Compute public key
  ecdh_phase_one(&public_key_, private_key_, &param_);
}

std::vector<uint8_t> ecdh::get_data() const
{
  /// Encode public key.
  std::ofstream mylog2;
  mylog2.open ("mylog2.txt");

  std::vector<uint32_t> x_coo;
  std::vector<uint32_t> y_coo;

  mylog2 << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string( (uint8_t) public_key_.x[i]) << "\t";
  }
  mylog2 << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string( (uint8_t) public_key_.y[i]) << "\t";
  }


  for(int i = 0; i < 8; i++){
   x_coo.push_back(ntoh<uint32_t> (public_key_.x[i]));
   y_coo.push_back(ntoh<uint32_t> (public_key_.y[i]));
  }

  mylog2 << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string(x_coo[i]) << "\t";
  }
  mylog2 << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string(y_coo[i]) << "\t";
  }

  uint8_t *x_coo_ptr = (uint8_t*) (x_coo.data());
  uint8_t *y_coo_ptr = (uint8_t*) (y_coo.data());

  mylog2 << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string(x_coo_ptr[i]) << "\t";
  }
  mylog2 << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog2 << std::to_string(i) << ": " <<  std::to_string(y_coo_ptr[i]) << "\t";
  }

  std::vector<uint8_t> result;
  result.push_back(0x04);
  for(uint8_t i = 0; i < 32; i++){
    result.push_back((x_coo_ptr[i]));
  }
  for(uint8_t i = 0; i < 32; i++){
    result.push_back(y_coo_ptr[i]);
  }
/*
  for(uint8_t i = 0; i < 65; i++){
  mylog2 << std::to_string(result[i]) << " ";
  }
  mylog2 << "\n";
*/
  return result;
}

std::vector<uint8_t> ecdh::get_shared_secret(const std::vector<uint8_t>& other_party_data) const
{
  std::ofstream mylog;
  mylog.open ("mylog.txt");
  /// \todo Decode second public key and run phase 2 of ECDH. Return the shared secret.
  //std::vector<uint8_t> other_party_data_copy = other_party_data;


  //other_party_data_copy.erase(other_party_data_copy.begin());
  eccp_point_affine_t second_public_key_;
  uint8_t* second_public_key_x = (uint8_t*) second_public_key_.x;
  uint8_t* second_public_key_y = (uint8_t*) second_public_key_.y;

  std::vector<uint8_t> x_coo2;
  std::vector<uint8_t> y_coo2;

  for(uint8_t i = 0; i < 65; i++){
  mylog << std::to_string(i) << ": " <<  std::to_string(other_party_data[i]) << "\t";
  }
  mylog << "\n";


  for(uint8_t i = 1; i < 33; i++){
    x_coo2.push_back(other_party_data[i]);
    y_coo2.push_back(other_party_data[i + 32]);
  }


for(uint8_t i = 0; i < 35; i++){
  mylog << std::to_string(i) << ": " << std::to_string(x_coo2[i]) << "\t";
}
mylog << "\n";
for(uint8_t i = 0; i < 35; i++){
  mylog << std::to_string(i) << ": " <<  std::to_string(y_coo2[i]) << "\t";
}



  uint32_t *x_coo_ptr2 = (uint32_t*) (x_coo2.data());
  uint32_t *y_coo_ptr2 = (uint32_t*) (y_coo2.data());

  mylog << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(x_coo_ptr2[i]) << "\t";
  }
  mylog << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(y_coo_ptr2[i]) << "\t";
  }

  std::vector<uint32_t> ptrx;
  std::vector<uint32_t> ptry;

  for(uint8_t i = 1; i < 8; i++){
    ptrx.push_back((hton<uint32_t> (x_coo_ptr2[i])));
    ptry.push_back((hton<uint32_t> (y_coo_ptr2[i])));
  }

  mylog << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(ptrx[i]) << "\t";
  }
  mylog << "\n";
  for(uint8_t i = 0; i < 8; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(ptry[i]) << "\t";
  }


  uint8_t *ptrx2 = (uint8_t*) (ptrx.data());
  uint8_t *ptry2 = (uint8_t*) (ptry.data());

  for(uint8_t i = 0; i < 32; i++){
    second_public_key_x[i] = ptrx2[i];
    second_public_key_y[i] = ptry2[i];
  }

  mylog << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(second_public_key_x[i]) << "\t";
  }
  mylog << "\n";
  for(uint8_t i = 0; i < 32; i++){
    mylog << std::to_string(i) << ": " <<  std::to_string(second_public_key_y[i]) << "\t";
  }



/*
  for(uint8_t i = 1; i < 8; i++){
    x_coo2.push_back(hton<uint32_t> (other_party_data[i]));
    y_coo2.push_back(hton<uint32_t> (other_party_data[i + 8]));
  }

  uint8_t *x_coo_ptr2 = (uint8_t*) (x_coo2.data());
  uint8_t *y_coo_ptr2 = (uint8_t*) (y_coo2.data());

  for(uint8_t i = 0; i < 32; i++){
    second_public_key_x[i] = x_coo_ptr2[i];
  }
  for(uint8_t i = 0; i < 32; i++){
    second_public_key_y[i] = y_coo_ptr2[i];
  }


*/
  eccp_point_affine_t result;

  ecdh_phase_two(&result, private_key_, &second_public_key_, &param_);

  std::vector<uint8_t> shared_secret_;
  uint8_t* result_x_ptr = (uint8_t*) result.x;
  for(uint8_t i = 0; i < 32; i++){
    shared_secret_.push_back(result_x_ptr[i]);
  }

  //mylog.close();

  return shared_secret_;
}