//---------------------------------------------------------------------------

/*------------------------------------------------------------------------------

SMS3 main file for the CodeGear console (batch) version

The program reads an input file control.txt which specifies the ID, landscape details,
starting location and goal location for movements to be simulated.

For each ID, sets of parameter combinations required to run SMS3 are read
from the parameters.txt file:
  perceptual range (PR) evaluation method,
  PR (upon changing PR, the landscape's 'memory' of previously calculated
    effective costs is reset),
  directional persistence (DP),
  goal bias (GB) ,
  memory size.

Thus, if there are C valid records in control.txt and P valid records in
parameters.txt, there will be C x P records written to the output log.csv file.
The total number of paths simulated will depend on the values of the Npaths field
in each control.txt record.

Optionally, after each combination of parameters is completed, a landscape
density file (ArcGIS raster export format) can be written as a record of the
frequency with which each landscape square is visited by the individuals released
(controlled by WRITE_LANDS in Parameters.h). The landscape number is allocated
incrementally, and changes when either the cost grid or the target grid changes
in the control.txt file.

Author: Steve Palmer, University of Aberdeen

Last updated: 1 May 2012

------------------------------------------------------------------------------*/

#include <iostream>
#include <time.h>
#include "Landscape.h"
#include "Animal.h"
#include "MoveInd.h"

#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused

StochasticLib1 sto1a(SEED);

// set up global landscape pointer
Landscape* pLandscape;

int main(int argc, char* argv[])
{
int i,j,t0,t1,parameterset,Npaths,goaltype,cellsize,move;
locn start,source,goal,origin,XYmax;
int landID,maxcost,prevnodatacost;
int nodatacost; // cost to use in place of 'nodata' value
int maxsteps;   // max. no. of steps used (unless NOLIMIT is applied)

pLandscape = 0;
parameterset = 0;

char txt[20];
char id[20],cost[20],target[20];
char prevcost[20],prevtarget[20];
int startpatch,Xstart,Ystart,Xgoal,Ygoal;
char costgrid[20],tgtgrid[20];
bool new_landscape;
bool files_ok = 1;
bool start_ok = 0;

t0 = time(0);

// open input control file
ifstream inctrl ("control.txt");
if (!inctrl.is_open()) {
  cout<<endl<<"***** ERROR - Unable to open input file control.txt"<<endl;
  files_ok = 0;
}
else {
  // read header record
  for (i = 0; i < 12; i++) inctrl>>txt;
}

// open log file
ofstream outlog ("log.csv");
if (!outlog.is_open()) {
  cout<<endl<<"***** ERROR - Unable to open output file log.csv"<<endl;
  files_ok = 0;
}
else // write header record
  outlog<<"ControlID,Landscape,ParameterSet,CellSize,PRmethod,PR,DP,GB,MemSize"
    <<",StartX,StartY,StartPatch,GoalType,GoalX,GoalY,RunTime"<<endl;

strcpy(prevcost,"aaaaaaaaaa");
strcpy(prevtarget,"aaaaaaaaaa");
prevnodatacost = 0;

inctrl>>id;
new_landscape = 1;
while (files_ok && id[0]) {
  inctrl>>cost>>target>>nodatacost>>maxsteps>>Npaths
    >>Xstart>>Ystart>>startpatch>>goaltype>>Xgoal>>Ygoal;
  cout<<endl<<"ID = "<<id;
  cout<<" Cost = "<<cost;
  cout<<" Tgt = "<<target;
  cout<<" Start = ("<<Xstart<<","<<Ystart<<")";
//  cout<<" Goal = ("<<Xgoal<<","<<Ygoal<<")";
  cout<<endl;
  start.x = Xstart; start.y = Ystart;
  if (goaltype < 0 || goaltype > 2) {
    cout<<endl<<"***** ERROR - Invalid goal type "<<goaltype
      <<" for ID "<<id<<endl;
    cout<<"      Setting goal type to 0 (no goal)"<<endl;
    goaltype = 0;
  }
  if (strcmp(cost,prevcost)) {
    cout<<"***** New cost grid"<<endl;
    strcpy(costgrid,cost);
    strcat(costgrid,".txt");
    new_landscape = 1;
  }
  if (strcmp(target,prevtarget)) {
    cout<<"***** New target"<<endl;
    strcpy(tgtgrid,target);
    strcat(tgtgrid,".txt");
    new_landscape = 1;
  }
  if (nodatacost != prevnodatacost) {
    cout<<"***** New no-data cost"<<endl;
    new_landscape = 1;
  }
  if (new_landscape) {
    // delete existing landscape, if any
    if (pLandscape != 0) delete pLandscape;
    // create new landscape
    pLandscape = new Landscape;
    landID = pLandscape->get_id();
    maxcost = pLandscape->ReadLandscape(costgrid,tgtgrid,"null");
    new_landscape = 0;
    parameterset = 0;
  }
  if (maxcost < 1) {
    cout<<endl<<"*****"<<endl;
    cout<<"***** Aborting landscape ID = "<<id<<endl;
    cout<<"*****"<<endl;
  }

  // Check that start location lies within the landscape
  cellsize = pLandscape->get_cellsize();
  if (maxcost > 0) {
    origin = pLandscape->get_origin();
    XYmax = pLandscape->get_XYmax();
    if (start.x < origin.x || start.y < origin.y
    || start.x > XYmax.x || start.y > XYmax.y) {
      cout<<endl<<"***** ERROR - Start location is not within landscape bounds"<<endl<<endl;
      start_ok = 0;
    }
    else { // convert start and goal co-ordinates to cell numbers
      source.x = (start.x - origin.x) / cellsize;
      source.y = (start.y - origin.y) / cellsize;
      cout<<"Start = ("<<start.x<<","<<start.y<<") "
        <<"converted to cell ("<<source.x<<","<<source.y<<") "<<endl;
      start_ok = 1;
      goal.x = (Xgoal - origin.x) / cellsize;
      goal.y = (Ygoal - origin.y) / cellsize;
      cout<<"Goal = ("<<Xgoal<<","<<Ygoal<<") "
        <<"converted to cell ("<<goal.x<<","<<goal.y<<") "<<endl;
    }
  }

  if (maxcost > 0 && start_ok && nodatacost > 0 && maxsteps > 0) {
    // run SMS for the current landscape
    int method,pr,ms,prevpr,prevmethod;
    double dp,gb;
    // open parameter control file
    ifstream inparms ("parameters.txt");
    if (!inparms.is_open()) {
      cout<<endl<<"***** ERROR - Unable to open input file parameters.txt"<<endl<<endl;
      files_ok = 0;
    }
    else { // parameter control file is present
      prevpr = 0; prevmethod = -1;
      // read header record
      for (i = 0; i < 5; i++) {
        inparms>>txt;
//      cout<<"i = "<<i<<" txt = "<<txt<<endl;
      }
      // read first data record
      method = 0; // to ensure valid method is read
      inparms>>method;
      if (!method) {
        cout<<endl<<"***** ERROR - Problem with file parameters.txt"<<endl<<endl;
        files_ok = 0;
      }
//      cout<<"method = "<<method<<endl;
      while (method) {
        int time0,time1;
        time0 = time(0);
        inparms>>pr>>dp>>gb>>ms;
        cout<<"landscape "<<landID<<" method "<<method<<" PR "<<pr
          <<" DP "<<dp<<" GB "<<gb<<" mem size "<<ms<<endl;
        if (pr != prevpr || method != prevmethod) {
          // reset retained effective costs when PR and/or PR method changes
          pLandscape->ResetEffCosts();
        }
        // reset all visits counters to zero
        pLandscape->ResetVisits(0);
        for (i = 0; i < Npaths; i++) { // release N individuals
          Animal* pAnimal = new Animal(source.x,source.y,0,0.5);
          pAnimal->set_movement(pr,method,dp,gb,ms,nodatacost);
          pAnimal->set_goal(goaltype,goal.x,goal.y);
          // reset visits counters in the current landscape
          pLandscape->ResetVisits(1);
          move = move_ind(pAnimal,pLandscape,source,startpatch,parameterset,id,maxsteps);
          delete pAnimal;
          if (move == 999) {
            cout<<endl<<"***** ERROR - Unable to open paths.csv output file"<<endl<<endl;
            i = Npaths+1;
            files_ok = 0;
          }
        }
        // write entry to log file
        time1 = time(0) - time0;
        outlog<<id<<","<<landID<<","<<parameterset<<","<<pLandscape->get_cellsize()
          <<","<<method<<","<<pr<<","<<dp<<","<<gb<<","<<ms
          <<","<<start.x<<","<<start.y<<","<<startpatch
          <<","<<goaltype<<","<<Xgoal<<","<<Ygoal<<","<<time1<<endl;
#if WRITE_LANDS
        pLandscape->WriteLandFile(4,parameterset); 
#endif
        // retain current pr and method
        prevpr = pr; prevmethod = method;
        // read next data record
        method = 0; // to ensure valid method is read
        if (files_ok) inparms>>method;
        parameterset++;
//        cout<<"method = "<<method<<endl;
      }
      inparms.close();
    }
  }
  else {
    if (nodatacost < 1) {
      cout<<endl<<"***** ERROR - NoDataCost must be > 0"<<endl<<endl;
    }
    if (maxsteps < 1) {
      cout<<endl<<"***** ERROR - MaxSteps must be > 0"<<endl<<endl;
    }
  }

  // retain details of current ID
  strcpy(prevcost,cost);
  strcpy(prevtarget,target);
  prevnodatacost = nodatacost;
  // read next control ID
  inctrl>>id;
}

cout<<endl;

if (pLandscape != 0) delete pLandscape;

inctrl.close();
outlog.close();
close_path_file();

t1 = time(0);
cout<<endl<<"***** Execution time "<<t1-t0<<" seconds"<<endl<<endl;

cout<<"*****"<<endl;
cout<<"***** Simulation completed - enter any number to terminate program"<<endl;
cout<<"*****"<<endl;
cin>>i;

return 0;

}

//---------------------------------------------------------------------------