/************************************************************************/
/*									*/
/*	A package of routines to read and write masks (bitmaps)		*/
/*	These are used by MIRIAD for data flagging and blanking.	*/
/*									*/
/*	Masks are implemented as integer data items. The 32nd		*/
/*	bit in the integer is not used, as this could cause		*/
/*	portability problems. As it is, this software assumes that	*/
/*	the host integer is at least 32 bits long.			*/
/*									*/
/*  History:								*/
/*    rjs  Dark-ages Original version.					*/
/*    rjs   6nov89   Does not abort if the mask file is missing.	*/
/*    rjs   3mar93   Make mkflush a user-callable routine.		*/
/*    rjs  23dec93   Do not open in read/write mode unless necessary.	*/
/*    rjs   6nov94   Change item handle to an integer.			*/
/*    rjs  19apr97   Handle FORTRAN LOGICALs better. Some tidying.      */
/************************************************************************/

#include <Python.h>

#define BUG(sev,a)   bug_c(sev,a)
#define ERROR(sev,a) bug_c(sev,((void)sprintf a,message))
#define CHECK(x) if(x) bugno_c('f',x)
#define private static

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "miriad.h"


static char message[128];

#define BITS_PER_INT 31

static int bits[BITS_PER_INT] = {
		0x00000001,0x00000002,0x00000004,0x00000008,
		0x00000010,0x00000020,0x00000040,0x00000080,
		0x00000100,0x00000200,0x00000400,0x00000800,
		0x00001000,0x00002000,0x00004000,0x00008000,
		0x00010000,0x00020000,0x00040000,0x00080000,
		0x00100000,0x00200000,0x00400000,0x00800000,
		0x01000000,0x02000000,0x04000000,0x08000000,
		0x10000000,0x20000000,0x40000000};

static int masks[BITS_PER_INT+1]={
		0x00000000,0x00000001,0x00000003,0x00000007,0x0000000F,
			   0x0000001F,0x0000003F,0x0000007F,0x000000FF,
			   0x000001FF,0x000003FF,0x000007FF,0x00000FFF,
			   0x00001FFF,0x00003FFF,0x00007FFF,0x0000FFFF,
			   0x0001FFFF,0x0003FFFF,0x0007FFFF,0x000FFFFF,
			   0x001FFFFF,0x003FFFFF,0x007FFFFF,0x00FFFFFF,
			   0x01FFFFFF,0x03FFFFFF,0x07FFFFFF,0x0FFFFFFF,
			   0x1FFFFFFF,0x3FFFFFFF,0x7FFFFFFF};

#include "io.h"

#define MK_FLAGS 1
#define MK_RUNS 2
#define BUFFERSIZE 128
#define OFFSET (((ITEM_HDR_SIZE-1)/H_INT_SIZE + 1)*BITS_PER_INT)
typedef struct {
  int item;
  int buf[BUFFERSIZE],modified,rdonly,tno;
  off64_t offset, length, size;
  char name[32];
} MASK_INFO;


private void mkfill(MASK_INFO *mask,off64_t offset);

/************************************************************************/
char *mkopen_c(int tno,char *name,char *status)
/*
  This opens a mask item, and readies it for access.

  Inputs:
    tno		The handle of the data set containing the item.
    name	Name of the item (something like "mask" or "flags").
    status	"old" or "new".

  Output:
    mkopen_c	This is a handle used in subsequent calls to the maskio
		routines. A NULL indicates that an error was encountered.

------------------------------------------------------------------------*/
{
  MASK_INFO *mask;
  int iostat;
  char s[ITEM_HDR_SIZE];

  mask = (MASK_INFO *)malloc((unsigned int)sizeof(MASK_INFO));

/* The case of an old mask file. Perform a number of checks to make sure
   the file looks OK. */

  if(!strcmp("old",status)) {
    haccess_c(tno,&(mask->item),name,"read",&iostat);
    if(iostat) { free((char *)mask); return(NULL); }
    mask->size = hsize_c(mask->item);
    if(mask->size <= H_INT_SIZE * (OFFSET/BITS_PER_INT))
      ERROR('f',(message,"Mask file %s appears bad",name));
    hreadb_c(mask->item,s,0,ITEM_HDR_SIZE,&iostat);		CHECK(iostat);
    if(memcmp(s,int_item,ITEM_HDR_SIZE)) 
      ERROR('f',(message,"Mask file %s is not integer valued",name));
    mask->rdonly   = TRUE;

/* The case of a new masl file. Create it and make it look nice. */

  } else if(!strcmp("new",status)) {
    haccess_c(tno,&(mask->item),name,"write",&iostat);		CHECK(iostat);
    hwriteb_c(mask->item,int_item,0,ITEM_HDR_SIZE,&iostat);	CHECK(iostat);
    mask->size = OFFSET/BITS_PER_INT * H_INT_SIZE;
    mask->rdonly   = FALSE;
  } else ERROR('f',(message,"Unrecognised status %s in MKOPEN",status));

/* Common to both old and new mask files. Initialise the structure
   describing the file. */

  mask->size = (mask->size/H_INT_SIZE) * BITS_PER_INT;
  mask->offset = -BUFFERSIZE*BITS_PER_INT;
  mask->length = 0;
  mask->modified = FALSE;
  mask->tno = tno;
  strcpy(mask->name,name);

  return((char *)mask);
}
/************************************************************************/
void mkclose_c(char *handle)
/*
  This writes out any stuff that we have buffered up, and then closes
  the mask file.

  Inputs:
    handle	Pointer to the structure describing the massk file.
------------------------------------------------------------------------*/
{
  MASK_INFO *mask;
  int iostat;

  mask = (MASK_INFO *)handle;
  if(mask->modified) mkflush_c(handle);
  hdaccess_c(mask->item,&iostat);				CHECK(iostat);
  free((char *)mask);
}
/************************************************************************/
int mkread_c(char *handle,int mode,int *flags,off64_t offset,int n,int nsize)
/*
------------------------------------------------------------------------*/
{
#define SWITCH_STATE *flags++ = runs + (state ? 0 : 1 ); \
		     t = state; state = otherstate; otherstate = t

  MASK_INFO *mask;
  int i,len,blen,bitmask,*buf,iostat,t,state,otherstate,runs;
  off64_t boff;
  int *flags0;

  flags0 = flags;
  mask = (MASK_INFO *)handle;
  offset += OFFSET;
  state = 0;
  otherstate = 0x7FFFFFFF;
  runs = 0;


/* Get a buffer full of information if we need it. */

  while(n > 0){
    if(offset < mask->offset || offset >= mask->offset + mask->length) {
      if(mask->modified)mkflush_c(handle);
      mask->offset = (offset/BITS_PER_INT)*BITS_PER_INT;
      mask->length = min(mask->size - mask->offset,BUFFERSIZE*BITS_PER_INT);
      mask->modified = FALSE;
      if(mask->length == 0) BUG('f',"Read past end of mask file");
      hreadi_c(mask->item,mask->buf,
		(mask->offset/BITS_PER_INT)*H_INT_SIZE,
		(mask->length/BITS_PER_INT)*H_INT_SIZE,
					&iostat);	CHECK(iostat);
    }

/* Copy the flags to the output buffer. Use special sections of code
   to deal with all bits being set of clear. */

    boff = offset - mask->offset;
    t = boff/BITS_PER_INT;
    buf = mask->buf + t;
    len = min(mask->length - boff,n);
    boff -= t*BITS_PER_INT;

    n -= len;
    offset += len;

/* Copy to the output, in "flags" format. */

    if(mode == MK_FLAGS){
      while( len > 0){
	blen = min( BITS_PER_INT - boff,len);
	bitmask = *buf++;
	if(bitmask == 0x7FFFFFFF) for(i=0; i<blen; i++) *flags++ = FORT_TRUE;
	else if(bitmask == 0)     for(i=0; i<blen; i++) *flags++ = FORT_FALSE;
	else{
	  for(i=boff; i<boff+blen; i++)
	    *flags++ = ( bits[i] & bitmask ? FORT_TRUE : FORT_FALSE );
	}
	len -= blen;
	boff = 0;
      }

/* Copy to the output, in "runs" format. */

    } else {
      while( len > 0){
	blen = min( BITS_PER_INT - boff,len);
	bitmask = *buf++;
	if(bitmask == state ) runs += blen;
        else if(bitmask == otherstate ) { SWITCH_STATE; runs += blen; }
	else {
	  for(i=boff; i<boff+blen; i++){
	    if((bits[i] & bitmask) != (bits[i] & state)) { SWITCH_STATE; }
	    runs++;
	  }
	}
	len -= blen;
	boff = 0;
      }
    }
  }
  if(state) *flags++ = runs;
  nsize -= (flags - flags0);
  if(nsize < 0) bug_c('f',"Buffer overflow in MKREAD");
  return(flags - flags0);
}
/************************************************************************/
void mkwrite_c(char *handle,int mode,int *flags,off64_t offset,int n,int nsize)
/*
------------------------------------------------------------------------*/
{
  MASK_INFO *mask;
  int i,len,blen,bitmask,*buf,t;
  off64_t boff;
  int run,curr,state,iostat;

  curr = 0;
  state = 1;
  run = 0;

  mask = (MASK_INFO *)handle;
  offset += OFFSET;

/* If the mask is currently read-only, close it and reopen it as read/write. */

  if(mask->rdonly){
    hdaccess_c(mask->item,&iostat);
    haccess_c(mask->tno,&(mask->item),mask->name,"append",&iostat);
    if(iostat){
      bug_c('w',"Error opening mask/flagging file in read/write mode\n");
      bugno_c('f',iostat);
    }
    mask->rdonly = FALSE;
  }

/* Check if we have the right buffer. Flush if not. */

  while(n > 0){
    if(offset < mask->offset || offset >= mask->offset + BUFFERSIZE*BITS_PER_INT) {
      if(mask->modified)mkflush_c(handle);
      mask->offset = (offset/BITS_PER_INT)*BITS_PER_INT;
      mask->length = 0;
      mask->modified = FALSE;
    }

/* See if we have to read in any stuff to fill in between the last write
   and the current write. */

  if(offset > mask->offset + mask->length)mkfill(mask,offset);

/* Copy the flags to the output buffer. */

    boff = offset - mask->offset;
    t = boff/BITS_PER_INT;
    buf = mask->buf + t;
    len = min(BITS_PER_INT*BUFFERSIZE - boff,n);
    boff -= t*BITS_PER_INT;

    mask->length = max(mask->length,offset - mask->offset + len);
    mask->modified = TRUE;

    n -= len;
    offset += len;

/* Write to the file, assuming the input is in FLAGS format. */

    if(mode == MK_FLAGS){
      while( len > 0){
        blen = min( BITS_PER_INT - boff,len);
        bitmask = *buf;
        for(i=boff; i<boff+blen; i++){
	  if(FORT_LOGICAL(*flags)) bitmask |=  bits[i];
	  else			       bitmask &= ~bits[i];
	  flags++;
        }
        *buf++ = bitmask;
        len -= blen;
        boff = 0;
      }

/* Write to the file, assuming the input is in RUNS format. */

    } else {
      while( len > 0 ){
	while(run == 0){
	  if(nsize == 0) run = n + len;
	  else{
	    t = *flags++ - (state ? 1 : 0);
	    run = t - curr;
	    curr = t;
	    nsize --;
	  }
	  state ^= 1;
	}
	blen = min(run, min( BITS_PER_INT - boff, len));
	bitmask = masks[boff+blen] ^ masks[boff];
	if(state) *buf |=  bitmask;	/* Set the bits. */
	else	  *buf &= ~bitmask;	/* Clear the bits. */
	run -= blen;
	len -= blen;
	boff = (boff + blen) % BITS_PER_INT;
	if(!boff) buf++;
      }
    }
  }
}
/************************************************************************/
void mkflush_c(char *handle)
/*
  Flush out the data in the buffer. A complication is that the last
  integer in the buffer may not be completely filled. In this case we
  have to read in the value of this integer, and copy the old bits to
  the output.

  Input:
    mask	Pointer to the mask structure.
------------------------------------------------------------------------*/
{
  MASK_INFO *mask;
  int i,t,*buf,iostat;
  off64_t offset;

  mask = (MASK_INFO *)handle;

/* If we are writing at the end of the file, make sure the number we
   write is a multiple of BITS_PER_INT. Also update the size of the
   file. */

  if( mask->offset + mask->length >= mask->size) {
    mask->length = ((mask->length-1)/BITS_PER_INT + 1)*BITS_PER_INT;
    mask->size = mask->offset + mask->length;

/* If the last word is only partially filled, read in the rest of the
   word and transfer the bits. */

  } else if((mask->length % BITS_PER_INT) != 0) {
    offset = (mask->offset + mask->length) / BITS_PER_INT * H_INT_SIZE;
    hreadi_c(mask->item,&t,offset,H_INT_SIZE,&iostat);		CHECK(iostat);
    buf = mask->buf + mask->length/BITS_PER_INT;
    i = mask->length % BITS_PER_INT;
    *buf = ( t & ~masks[i] ) | (*buf & masks[i]);
    mask->length = ((mask->length-1)/BITS_PER_INT + 1)*BITS_PER_INT;
  }

/* Write out the stuff at last. */

  hwritei_c(mask->item,mask->buf,
		mask->offset/BITS_PER_INT*H_INT_SIZE,
		mask->length/BITS_PER_INT*H_INT_SIZE,&iostat);	CHECK(iostat);
  mask->modified = FALSE;
}
/************************************************************************/
private void mkfill(MASK_INFO *mask,off64_t offset)
/*
  We have to fill in some bits in the current buffer.

  Inputs:
    mask	Pointer to the mask structure.
    offset	The first location that we want to write at.
------------------------------------------------------------------------*/
{
  int off,len,t,*buf,iostat,i;

  if(mask->offset+mask->length < mask->size) {
    buf = mask->buf + mask->length/BITS_PER_INT;
    t = *buf;
    off = (mask->offset + mask->length)/BITS_PER_INT;
    len = min(offset/BITS_PER_INT + 1,mask->size/BITS_PER_INT) - off;
    hreadi_c(mask->item,buf,
		off*H_INT_SIZE,len*H_INT_SIZE,&iostat);		CHECK(iostat);
    i = mask->length % BITS_PER_INT;
    *buf = ( t & masks[i] ) | (*buf & ~masks[i]);
    mask->length = (off + len)*BITS_PER_INT - mask->offset;
  }
}