#include "csf.h" 

#include "csfimpl.h" 

#include <errno.h>

#include <string.h>

/* M_PI */

#include <math.h> 

#ifndef M_PI

# define M_PI        ((double)3.14159265358979323846)

#endif

/* 

 * Create a new CSF-Raster-file

 * The Rcreate function

 * creates a new CSF-Raster-file of nrRows by nrCols where each

 * cell is of type cellRepr. If the file already exists its

 * contents is destroyed. The value of

 * the pixels is undefined. MinMaxStatus is MM_KEEPTRACK. The

 * access mode is M_READ_WRITE. 

 * It is not

 * known if a file is created after a NOSPACE message.

 * Returns

 * if the file is created successfully, Rcreate returns

 * a map handle. In case of an error Rcreate returns NULL.

 *

 * Merrno 

 * NOCORE, BAD_CELLREPR, BAD_PROJECTION, OPENFAILED, NOSPACE.

 * CONFL_CELLREPR and BAD_VALUESCALE will generate a failed assertion in DEBUG mode.

 *

 * Example:  

 * .so examples/create2.tr

 *

 */

MAP *Rcreate(

  const char *fileName,  /* name of the file to be created */

  size_t nrRows,          /* the number of rows */

  size_t nrCols,          /* the number of columns */

  CSF_CR cellRepr,       /* the cell representation must be complaint with the data type

                          */

  CSF_VS dataType,      /* a.k.a. the value scale.

                         */

  CSF_PT projection,     /* 

                          */

  REAL8 xUL,              /* x co-ordinate of upper left */

  REAL8 yUL,              /* y co-ordinate of upper left */

  REAL8 angle,           /* counter clockwise rotation angle

                          * of the grid top compared to the

                          * x-axis in radians. Legal value are 

                          * between -0.5 pi and 0.5 pi

                          */

  REAL8 cellSize)        /* cell size of pixel */

{

  MAP    *newMap;

  size_t  fileSize;

  char    crap = 0;

  if (! CsfIsBootedCsfKernel())

    CsfBootCsfKernel();

  newMap = (MAP *)CSF_MALLOC(sizeof(MAP));

  if (newMap == NULL)

  {

    M_ERROR(NOCORE);

    goto errorMapAlloc;

  }

  newMap->fileName = (char *)CSF_MALLOC(strlen(fileName)+1);

  if (newMap->fileName == NULL)

  {

    M_ERROR(NOCORE);

    goto errorNameAlloc;

  }

  if (!(

    cellRepr == CR_INT4 ||

    cellRepr == CR_UINT1 ||

    cellRepr == CR_REAL4 ||

    cellRepr == CR_REAL8 ))

  {

    M_ERROR(BAD_CELLREPR);

    goto error_notOpen;

  }

  switch(dataType) {

   case VS_BOOLEAN: 

   case VS_LDD: 

    if (cellRepr != CR_UINT1)

    {

      PROG_ERROR(CONFL_CELLREPR);

      goto error_notOpen;

    }

    break;

  case VS_NOMINAL: 

  case VS_ORDINAL:

    if (IS_REAL(cellRepr))

    {

      PROG_ERROR(CONFL_CELLREPR);

      goto error_notOpen;

    }

    break;

  case VS_SCALAR:

  case VS_DIRECTION:

    if (!IS_REAL(cellRepr))

    {

      PROG_ERROR(CONFL_CELLREPR);

      goto error_notOpen;

    }

    break;

  default:

    PROG_ERROR(BAD_VALUESCALE);

    goto error_notOpen;

  }

  if (cellSize <= 0.0)

  {

    M_ERROR(ILL_CELLSIZE);

    goto error_notOpen;

  }

  if ((0.5*-M_PI) >= angle || angle >= (0.5*M_PI))

  {

    M_ERROR(BAD_ANGLE);

    goto error_notOpen;

  }

  newMap->fileAccessMode = M_READ_WRITE;

  (void)strcpy(newMap->fileName, fileName);

  newMap->fp = fopen (fileName, S_CREATE);

  if(newMap->fp == NULL)

  { 

     /* we should analyse the errno parameter

      * here to get the reason

      */

    M_ERROR(OPENFAILED);

    goto error_notOpen;

  }

  /*

     fflush(newMap->fp); WHY? 

   */

  (void)memset(&(newMap->main),0, sizeof(CSF_MAIN_HEADER));

  (void)memset(&(newMap->raster),0, sizeof(CSF_RASTER_HEADER));

  /* put defaults values     */

  /* assure signature is padded with 0x0 */

  (void)memset(newMap->main.signature, 0x0, (size_t)CSF_SIG_SPACE);

  (void)strcpy(newMap->main.signature, CSF_SIG);

  newMap->main.version = CSF_VERSION_2;

  newMap->main.gisFileId = 0;

  newMap->main.projection = PROJ_DEC_T2B(projection);

  newMap->main.attrTable = 0; /* initially no attributes */

  newMap->main.mapType = T_RASTER;

  /* write endian mode current machine: */

  newMap->main.byteOrder= ORD_OK;

#ifdef DEBUG

  newMap->read  = (CSF_READ_FUNC)CsfReadPlain;

  newMap->write = (CSF_READ_FUNC)CsfWritePlain;

#else

  newMap->read  = (CSF_READ_FUNC)fread;

  newMap->write = (CSF_READ_FUNC)fwrite;

#endif

  newMap->raster.valueScale = dataType;

  newMap->raster.cellRepr = cellRepr;

  CsfSetVarTypeMV( &(newMap->raster.minVal), cellRepr);

  CsfSetVarTypeMV( &(newMap->raster.maxVal), cellRepr);

  newMap->raster.xUL = xUL;

  newMap->raster.yUL = yUL;

  newMap->raster.nrRows = (UINT4)nrRows;

  newMap->raster.nrCols = (UINT4)nrCols;

  newMap->raster.cellSize = cellSize;

  newMap->raster.cellSizeDupl = cellSize;

  newMap->raster.angle = angle;

  CsfFinishMapInit(newMap);

  /*  set types to value cellRepr 

  newMap->types[STORED_AS]= (UINT1)newMap->raster.cellRepr;

  newMap->types[READ_AS]  = (UINT1)newMap->raster.cellRepr;

  */

  newMap->appCR  = (UINT1)newMap->raster.cellRepr;

  newMap->app2file = CsfDummyConversion;

  newMap->file2app = CsfDummyConversion;

  /*  make file the size of the header and data */

  fileSize   = nrRows*nrCols;

  fileSize <<= LOG_CELLSIZE(cellRepr);

  fileSize  += ADDR_DATA;

  /* enlarge the file to the length needed by seeking and writing

  one byte of crap */

  if ( csf_fseek(newMap->fp, fileSize-1, SEEK_SET) || /* fsetpos() is better */

      newMap->write(&crap, (size_t)1, (size_t)1, newMap->fp) != 1 )

  {

    M_ERROR(NOSPACE);

    goto error_open;

  }

  (void)fflush(newMap->fp);

  if ( csf_ftell(newMap->fp) != (CSF_FADDR)fileSize)

  {

    M_ERROR(NOSPACE);

    goto error_open;

  }

  newMap->minMaxStatus = MM_KEEPTRACK;

  CsfRegisterMap(newMap);

  return(newMap);

error_open: 

  (void)fclose(newMap->fp);

error_notOpen: 

  CSF_FREE(newMap->fileName);

errorNameAlloc:

        CSF_FREE(newMap);

errorMapAlloc:

  return(NULL);

}