#include "SA_MIProblem.h"
#include <SA_Initializer.h>

#include <iostream>
#include <sstream>
#include <string>

void PrintSolution(SA_Solution& sol);
void PrintMove(SA_Move& mov);

main(int argc,char **argv)
{
   std::string ans;
   std::cout << "Starting tests of SA_Problem and helper classes"
             << std::endl;

   std::cout << "Test 1: construct new SA_Problem instances and destroy" 
             << std::endl;
   int count=1000000;
   SA_Problem** pprob = new SA_Problem*[count];
   for (int i=0; i<count; i++) {
      pprob[i] = new SA_Problem(13);
   }
   std::cout << "   " << count << " SA_Problem instances allocated"
             << std::endl;
   for (int i=0; i<count; i++) {
      delete pprob[i];
   }
   std::cout << "   " << count << " SA_Problem instances deleted" << std::endl;

   std::cout << "Test 2: test EvaluateOptions method" << std::endl;
   SA_Problem prob;
   prob.EvaluateOptions(&argc,&argv);
   std::cout << "   fNdim is now " << prob.GetNdim() << std::endl;
   std::cout << "   fNvar is now " << prob.GetNvar(0) << "," 
                                   << prob.GetNvar(1) << ","
                                   << prob.GetNvar(2) << ","
                                   << prob.GetNvar(3) << std::endl;

   std::cout << "Test 3: test ReadProblemData method" << std::endl;
   prob.ReadProblemData("data.ser");
   std::cout << "   image size is " << prob.GetWidth() << " x "
                                    << prob.GetHeight() << std::endl;
   std::cout << "   fNdim is now " << prob.GetNdim() << std::endl;

   std::cout << "Test 4: construct new SA_Solution instances and destroy" 
             << std::endl;
   count=10000;
   SA_Solution** psol = new SA_Solution*[count];
   for (int i=0; i<count; i++) {
      psol[i] = prob.CreateSolution();
   }
   std::cout << "   " << count << " SA_Solution instances allocated"
             << std::endl;
   for (int i=0; i<count; i++) {
      delete psol[i];
   }
   std::cout << "   " << count << " SA_Solution instances deleted" << std::endl;

   std::cout << "Test 5: test GetInititalSolution and GetRandomSolution" 
             << std::endl;
   SA_Solution* sol = prob.CreateSolution();
   prob.GetInitialSolution(*sol);
   std::cout << "   GetInitialSolution made a solution with" << std::endl;
   PrintSolution(*sol);
   prob.GetRandomSolution(*sol);
   std::cout << "   GetRandomSolution made a solution with" << std::endl;
   PrintSolution(*sol);

   std::cout << "Test 6: test GetNeighbor, starting from initial solution" 
             << std::endl;
   std::cout << "   GetNeighbor from InitialSolution gives" << std::endl;
   prob.GetInitialSolution(*sol);
   prob.GetNeighbor(*sol,1);
   PrintSolution(*sol);
   std::cout << "   GetNeighbor followed by ResetSolution gives" << std::endl;
   prob.ResetSolution(*sol);
   PrintSolution(*sol);
   std::cout << "   GetNeighbor from InitialSolution gives" << std::endl;
   prob.GetInitialSolution(*sol);
   prob.GetNeighbor(*sol,1);
   PrintSolution(*sol);
   std::cout << "   GetNeighbor followed by UpdateSolution gives" << std::endl;
   prob.UpdateSolution(*sol);
   PrintSolution(*sol);

   std::cout << "Test 7: test GetLocalN and GetGlobalN"
             << std::endl;
   double localn=prob.GetLocalN();
   double globaln=prob.GetGlobalN();
   std::cout << "   global N is " << globaln
             << ",  local N is " << localn << std::endl;

   std::cout << "Test 8: test Copy solution from source to dest"
             << std::endl;
   SA_Solution* sol2 = prob.CreateSolution();
   prob.Copy(*sol,*sol2);
   std::cout << "   source is " << std::endl;
   PrintSolution(*sol);
   std::cout << "   dest is " << std::endl;
   PrintSolution(*sol2);

   std::cout << "Test 9: test OutputSolution and InputSolution"
             << std::endl;
   prob.GetNeighbor(*sol,1);
   prob.UpdateSolution(*sol);
   std::cout << "   solution written to stream is " << std::endl;
   PrintSolution(*sol);
   std::ostringstream ostr;
   prob.OutputSolution(ostr,*sol);
   std::istringstream istr(ostr.str());
   prob.InputSolution(istr,*sol2);
   std::cout << "   solution read from stream is " << std::endl;
   PrintSolution(*sol2);
   delete sol2;

   std::cout << "Test 10: construct new SA_Move instances and destroy" 
             << std::endl;
   count=10000;
   SA_Move** pmov = new SA_Move*[count];
   for (int i=0; i<count; i++) {
      pmov[i] = prob.CreateMove();
   }
   std::cout << "   " << count << " SA_Solution instances allocated"
             << std::endl;
   for (int i=0; i<count; i++) {
      delete pmov[i];
   }
   std::cout << "   " << count << " SA_Solution instances deleted" << std::endl;

   std::cout << "Test 11: extract a move from a solution"
             << std::endl;
   prob.GetInitialSolution(*sol);
   prob.GetNeighbor(*sol,1);
   SA_Move mov;
   prob.ExtractMove(*sol,mov);
   prob.UpdateSolution(*sol);
   std::cout << "   move is" << std::endl;
   PrintMove(mov);
   std::cout << "   shifted solution is" << std::endl;
   PrintSolution(*sol);

   std::cout << "Test 12: write a move to a stream and read it back"
             << std::endl;
   std::cout << "   move written as" << std::endl;
   PrintMove(mov);
   ostr.str("");
   prob.OutputMove(ostr,mov);
   prob.GetInitialSolution(*sol);
   istr.clear();
   istr.str(ostr.str());
   count = prob.InputApplyMoves(istr,*sol);
   std::cout << "   " << count << " moves applied, producing solution"
             << std::endl;
   PrintSolution(*sol);

   std::cout << "Test 13: output solution and read it back using actual file io"
             << std::endl;
   prob.GetNeighbor(*sol,1);
   prob.OutputSolution("test_stream.ser",*sol);
   std::cout << "   solution written as" << std::endl;
   PrintSolution(*sol);
   sol2 = prob.CreateSolution();
   prob.InputSolution("test_stream.ser",*sol2);
   std::cout << "   solution read back as" << std::endl;
   PrintSolution(*sol);
}

void PrintSolution(SA_Solution& sol)
{
   std::ostringstream ostr;
   ostr << sol;
   std::istringstream istr(ostr.str());
   int dim, count, nelem;
   double cost, newcost;
   istr >> dim >> cost >> newcost;
   std::cout << "    Ndim = " << dim << std::endl
             << "    Cost = " << cost << std::endl
             << "    Newcost = " << newcost << std::endl;
   istr >> count;
   nelem = count*count;
   double* array = new double[nelem];
   for (int i=0; i<nelem; i++)
      istr >> array[i];
   std::cout << "    Refa =   " << array[0] << "," << array[1] << ","
                                << array[2] << "," << array[3] << ","
                                << array[4] << ", ..." << std::endl;
   istr >> count;
   nelem = count*count;
   for (int i=0; i<nelem; i++)
      istr >> array[i];
   std::cout << "    Sig1a = "  << array[0] << "," << array[1] << ","
                                << array[2] << "," << array[3] << ","
                                << array[4] << ", ..." << std::endl;
   istr >> count;
   nelem = count*count;
   for (int i=0; i<nelem; i++)
      istr >> array[i];
   std::cout << "    Sig1ph = " << array[0] << "," << array[1] << ","
                                << array[2] << "," << array[3] << ","
                                << array[4] << ", ..." << std::endl;
   istr >> count;
   nelem = count*count;
   for (int i=0; i<nelem; i++)
      istr >> array[i];
   std::cout << "    Sig2ph = " << array[0] << "," << array[1] << ","
                                << array[2] << "," << array[3] << ","
                                << array[4] << ", ..." << std::endl;
   istr >> count;
   std::cout << ((count == 0)?
                "    Lastmove is empty" : 
                "    Lastmove is present" ) << std::endl;
   delete array;
}

void PrintMove(SA_Move& mov)
{
   std::ostringstream ostr;
   ostr << mov;
   std::istringstream istr(ostr.str());
   int count, nelem;
   int modelset;
   istr >> modelset;
   std::cout << "    Model_set = " << modelset << std::endl;
   istr >> count;
   if (count == 0) {
      std::cout << "    Model is empty" << std::endl;
   }
   else {
      istr >> count;
      nelem = count*count;
      double* array = new double[nelem];
      for (int i=0; i<nelem; i++)
         istr >> array[i];
      std::cout << "    Model =  " << array[0] << "," << array[1] << ","
                                   << array[2] << "," << array[3] << ","
                                   << array[4] << ", ..." << std::endl;
      delete array;
   }
}