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

#pragma hdrstop

#include "Landscape.h"

#if CODEGEAR
string itos(int i) {	// convert int to string
	stringstream s; s << i; return s.str();
}
#endif

int Landscape::LandCounter = 0;

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

#pragma package(smart_init)

//------------------------------------------------------------------------------
//FUNCTION:   Square::Square
//ARGUMENTS:  none
//RETURNS:    none
//NOTES:      Square class default Constructor
//------------------------------------------------------------------------------

Square::Square(int x, int y)
{
sq.x = x; sq.y = y; visits = 0;
cost = -99; target = -99;
#if READSOURCE
source = -99;
#endif
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    effcost.cell[i][j] = -1.0; // initialise retained effective costs
  }
}
}

//------------------------------------------------------------------------------
//FUNCTION:   Square::various
//ARGUMENTS:  none
//RETURNS:    various
//NOTES:      Square functions to return individual attributes
//------------------------------------------------------------------------------

locn Square::get_locn(void) { return sq; }
int Square::get_cost(void) { return cost; }
#if READSOURCE
int Square::get_source(void) { return source; }
#endif
int Square::get_target(void) { return target; }
int Square::get_visits(void) {
if (visits < 0) visits = -visits;
return visits;
}

array3x3d Square::get_effcosts(void) {
array3x3d effcosts;
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    effcosts.cell[i][j] = effcost.cell[i][j];
  }
}
return effcosts;
}

//------------------------------------------------------------------------------
//FUNCTION:   Square::set_attributes
//ARGUMENTS:
//RETURNS:    none
//NOTES:      Square functions to set landscape attributes
//------------------------------------------------------------------------------

void Square::set_cost(int c) { cost = c; }
void Square::set_attributes(int c, int s, int t) {
cost = c;
#if READSOURCE
source = s;
#endif
target = t;
}

void Square::inc_visits(void) {
if (visits > -1) { visits++; visits = -visits; }
}

void Square::reset_visits(int option) {
if (option == 0) visits = 0;
else { // reset to positive
  if (visits < 0) { visits = -visits; }
}
}

void Square::set_effcosts(array3x3d a) {
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    effcost.cell[i][j] = a.cell[i][j];
  }
}
}

//------------------------------------------------------------------------------
//FUNCTION: Landscape::Landscape
//ARGUMENTS: None
//RETURNS: None
//NOTES: Landscape class constructor
//------------------------------------------------------------------------------

Landscape::Landscape()
{
id = LandCounter; LandCounter++; //Unique identifier for each landscape
}

//------------------------------------------------------------------------------
//FUNCTION: Landscape::~Landscape
//ARGUMENTS: None
//RETURNS: None
//NOTES: Landscape class destructor
//------------------------------------------------------------------------------

Landscape::~Landscape()
{

#if !VCL
#if BATCH
cout<<endl<<"~Landscape: Deleting landscape no. "<<LandCounter<<endl<<endl;
#endif
#endif

for (int i = 0; i < Squares.size(); i++) {
  if (Squares[i] != 0) delete Squares[i];
}
Squares.clear();

}

//------------------------------------------------------------------------------
//FUNCTION:   Landscape::ReadLandscape
//ARGUMENTS:  None
//RETURNS:    Maximum cost value (integer)
//NOTES:      Reads landscape data from text files
//------------------------------------------------------------------------------

int Landscape::ReadLandscape(char* pCosts, char* pTarget, char* pSource)
{
#if !VCL
#if BATCH
cout<<"ReadLandscape: Costs "<<pCosts<<" Target "<<pTarget<<" Source "<<pSource<<endl;
#endif
#endif
int i,x,y,cost,source,target;
float fcost,fsource,ftarget;
int max = 0;
char txt[99];
bool read_source = 0;

// open and check landscape input files
ifstream incost (pCosts);
if (!incost.is_open()) {
  cout<<endl<<"***** Unable to open costs file "<<pCosts<<endl;
  max = -999;
}
ifstream intarget (pTarget);
if (!intarget.is_open()) {
  cout<<endl<<"***** Unable to open target file "<<pTarget<<endl;
  max = -998;
}
ifstream insource (pSource);
if (insource.is_open()) {
  read_source = 1;
}
else {
  if (strcmp(pSource,"null")) {
    cout<<endl<<"***** Unable to open source file "<<pSource<<endl;
    max = -997;
  }
}
if (max < 0) return max;

// Read header records
source = 0;
for (i = 0; i < 6; i++) {
	incost>>txt>>fcost; cost = (int)fcost;
	intarget>>txt>>ftarget; target = (int)ftarget;
	if (i < 5 && target != cost) { max = -990; i = 99; }
	if (read_source) {
		insource>>txt>>fsource; source = (int)fsource;
		if (i < 5 && source != cost) { max = -990; i = 99; }
  }
  else source = 0;
  if (i == 0) xmax = cost;
  if (i == 1) ymax = cost;
  if (i == 2) Xorigin = cost;
  if (i == 3) Yorigin = cost;
  if (i == 4) cellsize = cost;
#if !VCL
#if BATCH
  cout<<i<<" "<<txt<<" "<<cost<<" "<<source<<" "<<target<<endl;
#endif
#endif
}
if (max < 0) {
  cout<<endl<<"***** Mis-match in landscape file header records"<<endl;
  return max;
}

for (y = ymax-1; y > -1; y--) {
  for (x = 0; x < xmax; x++) {
    incost>>cost;
    intarget>>target;
    if (read_source) insource>>source; else source = 0;
    if (cost < 0) { // NODATA square - record a zero pointer
      Squares.push_back(0);
    }
    else { // square with data - set up square in heap memory and store costs
      Squares.push_back(new Square(x,y));
      Squares.back()->set_attributes(cost,source,target);
      // add cost value to colour table if not already present
      i = 0;
      while (i < costs.size()) {
        if (cost == costs[i]) i = 999999; // cost is already present
        else i++;
      }
      if (i != 999999) { // add cost to table
        costs.push_back(cost);
      }
    }
    if (cost>max) max = cost;
  }
}

// sort costs in colour table into ascending order and assign colour scores
// in the range 0-255, approx. equally spaced
sort (costs.begin(), costs.end());
for (i = 0; i < costs.size(); i++) {
  if (costs.size() > 1) {
    colours.push_back(255 * i / (costs.size()-1));
  }
}

#if !VCL
#if BATCH
cout<<"Finished reading landscape attributes, xmax = "<<xmax
  <<" ymax = "<<ymax<<endl<<endl;
#endif
#endif
return max;
}

//------------------------------------------------------------------------------
//FUNCTION:   Landscape::WriteLandFile
//ARGUMENTS:  None
//RETURNS:    None
//NOTES:      Writes visits to each square to a text file
//------------------------------------------------------------------------------

void Landscape::WriteLandFile(int ftype, int fnum)
{

// Writes a landscape specified by 'ftype' to text file:
// 1 = costs, 2 = source cell, 3 = target cells, 4 = visits

int i,x,y,length;
char fname[100];
#if CODEGEAR
const char* lnum;
const char* tnum;
#else
char lnum[10];
char tnum[10];
#endif

// convert leandscape number to string for file name
#if CODEGEAR
string ss = itos(id); lnum = ss.c_str();
#else
_itoa(id,lnum,10);
#endif

strcpy(&fname[0],"land");
strcpy(&fname[4],lnum);
switch(ftype) {
	case 1: strcpy(&fname[4+strlen(lnum)],"costs");  length = 5; break;
	case 2: strcpy(&fname[4+strlen(lnum)],"source"); length = 6; break;
	case 3:
    {
		strcpy(&fname[4+strlen(lnum)],"target"); length = 6;
#if CODEGEAR
		string st = itos(fnum); tnum = st.c_str();
#else
		_itoa(fnum,tnum,10);
#endif
		strcpy(&fname[4+strlen(lnum)+length],tnum); length += strlen(tnum);
    }
		break;
	case 4:
    {
		strcpy(&fname[4+strlen(lnum)],"visits"); length = 6;
#if CODEGEAR
		string st = itos(fnum); tnum = st.c_str();
#else
		_itoa(fnum,tnum,10);
#endif
		strcpy(&fname[4+strlen(lnum)+length],tnum); length += strlen(tnum);
    }
		break;
}
strcpy(&fname[4+strlen(lnum)+length],".txt");
ofstream landscp (fname);

// write header records
landscp<<"ncols "<<xmax<<endl; landscp<<"nrows "<<ymax<<endl;
landscp<<"xllcorner "<<Xorigin<<endl;  landscp<<"yllcorner "<<Yorigin<<endl;
landscp<<"cellsize "<<cellsize<<endl;  landscp<<"NODATA_value  -99"<<endl;

// write landscape cells
i = 0;
for (y = ymax-1; y > -1; y--) {
  for (x = 0; x < xmax; x++) {
    if (Squares[i] != 0) {
		  if (ftype == 1) landscp<<Squares[i]->get_cost()<<" ";
		  if (ftype == 2) {
#if READSOURCE
        landscp<<Squares[i]->get_source()<<" ";
#else
        landscp<<"-99 ";
#endif
      }
		  if (ftype == 3) landscp<<Squares[i]->get_cost()<<" ";
		  if (ftype == 4) landscp<<Squares[i]->get_visits()<<" ";
    }
    else // write NODATA value
      landscp<<"-99 ";
    i++;
	}
	landscp<<endl;
}

}


//------------------------------------------------------------------------------
//FUNCTION: Landscape::locate_square
//ARGUMENTS: x,y
//RETURNS: Pointer to required square
//NOTES: Locates a Square object within the landscape given its co-ordinates
//------------------------------------------------------------------------------

Square* Landscape::locate_square(int x,int y)
{
return Squares[(ymax-1-y)*xmax + x];
}

//------------------------------------------------------------------------------
//FUNCTION: Landscape::get_bounds
//ARGUMENTS: none
//RETURNS: location
//NOTES: returns maximum X and Y of the landscape
//------------------------------------------------------------------------------

locn Landscape::get_bounds(void) { locn l; l.x = xmax; l.y = ymax; return l; }
locn Landscape::get_origin(void) { locn l; l.x = Xorigin; l.y = Yorigin; return l; }
locn Landscape::get_XYmax(void) {
locn l; l.x = Xorigin + cellsize*xmax; l.y = Yorigin + cellsize*ymax;
return l;
}

int Landscape::get_id(void) { return id; }
int Landscape::get_cellsize(void) { return cellsize; }

//------------------------------------------------------------------------------
//FUNCTION: Landscape::ResetEffCosts
//ARGUMENTS: none
//RETURNS: none
//NOTES: resets effective costs of all squares to no data value
//------------------------------------------------------------------------------

void Landscape::ResetEffCosts(void)
{
int i,j;
array3x3d null;
for (i = 0; i < 3; i++) {
  for (j = 0; j < 3; j++) {
    null.cell[i][j] = -1.0;
  }
}
i = 0;
for (int y = ymax-1; y > -1; y--) {
  for (int x = 0; x < xmax; x++) {
    if (Squares[i] != 0) {
      Squares[i]->set_effcosts(null);
    }
    i++;
  }
}
}

//------------------------------------------------------------------------------
//FUNCTION: Landscape::ResetVisits
//ARGUMENTS: none
//RETURNS: none
//NOTES: resets visits of all squares to positive if negative
//------------------------------------------------------------------------------

void Landscape::ResetVisits(int option)
{
int i;
i = 0;
for (int y = ymax-1; y > -1; y--) {
  for (int x = 0; x < xmax; x++) {
    if (Squares[i] != 0) {
      Squares[i]->reset_visits(option);
    }
    i++;
  }
}
}

int Landscape::get_costcolour(int s) {
// returns a colour code (0-255) in which to draw the square
int c,i,cost;
if (s < 0 || s >= Squares.size()) { // error - return zero
  return 0;
}
else {
  c = i = 0;
  cost = Squares[s]->get_cost();
  while (i < costs.size()) {
    if (cost == costs[i]) c = colours[i];
    i++;
  }
}

return c;
}


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