/*       ETAK Inc.  Dec 1995      */
/* #ident  "%W% :%P% %G% %U%" */

/*       ETAK Inc.  Dec 1995      */
/* #ident  "@(#)nraread.c	1.1 :/tmp_mnt/vol/consrc/nra/nraread/s.nraread.c 1/25/95 18:29:07" */

/*       ETAK Inc.  Mar 1993      */
/* #ident  "@(#)nraread.c	1.1 :/tmp_mnt/vol/consrc/nra/ktree/s.nraread.c 3/17/93 18:28:12" */

#include <stdio.h>
#include <stdlib.h>
#include "stdtype.h"
#include "index.h"
#include "ktree.h"
#include "dprm_ca.h"
#include "cur_idx.h"

#define  IMD_MIN     0  
#define  IMD_SEC    40 
#define  IMD_FRAME   0
#if 0
#define IDX_DEBUG 1
#endif
FILE     *llog;
extern unsigned char * do_search (nraHandle, int, long, long, int, unsigned char *, struct idx_info *);
extern unsigned char * next_rec(int, int, struct idx_info *);


int fontStr ()  { }
int dump_sony=1;

#ifdef X  
/*------------------------------------------------------------------------*/
int get_tree (pIdx, index, offset, pbuf, put)
nraHandle       pIdx;
int             index;
long            offset;
char            *pbuf;
int             put;
{
long            node_cnt;
int             key_siz;

nraNodeCell     cell;
int             i=0;

   key_siz = pIdx->tree[index].treeD.cellSize - 8;
#ifdef IDX_DEBUG
   printf ("Root node: \n");
#endif

   if (fseek (pIdx->fd, pIdx->tree[index].treeD.rootOff + offset, 0))
	      return (xErr (-1, "Seeking node failed\n"));

   if (fread (pbuf, pIdx->tree[index].treeD.nodeSize, 1, pIdx->fd) != 1)
	       return (xErr (-1, "Reading node failed\n"));

   while (! get_node_cell (-1, pbuf, key_siz, i++, &cell, put))
   {
       pbuf +=  pIdx->tree[index].treeD.cellSize;
   }

} 

/*---------------------------------------------------------------------*/
get_node_cell (pIdx, pbuf, key_siz, i, pcell, put)
nraHandle     pIdx;
nraNodeCell   *pbuf;
int           key_siz;
int           i;
nraNodeCell   *pcell;
int           put;
{
   memcpy (&pcell->lowKeyNode, pbuf,   4);
   memcpy (&pcell->recordOff,  pbuf+4, 4);

   if (put)
   {
      printf ((pcell->key[0] == (char)-1) ? 
        "   Dummy %d  lowerKeyNode  %ld  parent %ld\n":
        "   Cell  %d  higherKeyNode %ld  record %ld\n",i, pcell->lowKeyNode, pcell->recordOff); 

     if (pcell->key[0] != (char) -1)
     {
	 if (pIdx->nra_file)
	     put_jis_name (pIdx, key_siz, pcell->key);
	 else
	     printf ("   Key  %s\n", pcell->key);
	 return (0);
     }
     printf ( "\n");
  }

return (-1);
}
#endif
/*---------------------------------------------------------------------*/
int reqTree (pIdx, msf1, prec_off, ptree_off, tnum)
nraHandle    pIdx;
U24_SA3      msf1;
int          *prec_off;
int          *ptree_off, tnum;
{
U24_SA3        msf2;
unsigned int   old_frame;
unsigned int   new_frame;
int            index;
int            i = 0;
long           sa2off ();

	index = tnum;
	if (pIdx->nra_file)
	{
		msf2 = pIdx->tree[index].treeD.treeAdrMSF;
		*ptree_off = sa2off (msf2.min, msf2.sec, msf2.frame);

		msf2 = pIdx->tree[index].tableD.recAdrMSF;

		*prec_off = sa2off (msf2.min, msf2.sec, msf2.frame);
		pIdx->fd_tree = pIdx->fd;  /* nra is 1 file */
	}
	else
	{
		old_frame= msf1.min*75*60 + msf1.sec*75 + msf1.frame;

		msf2       = pIdx->tree[index].treeD.treeAdrMSF;

		new_frame  = msf2.min *75*60 + msf2.sec*75 + msf2.frame;
		new_frame -= old_frame;
		*ptree_off = 2048 * new_frame;

		msf2 = pIdx->tree[index].tableD.recAdrMSF;
		new_frame  = msf2.min *75*60 + msf2.sec*75 + msf2.frame;
		new_frame -= old_frame;
		*prec_off  = 2048 * new_frame;
	}

put_tree_desc (pIdx,  &pIdx->tree[index].treeD);
put_tbl_desc (pIdx, &pIdx->tree[index].tableD);

return (index);
}

/*---------------------------------------------------------------------*/
unsigned char* start_search (tnum, fnum, src, cur_info, next_rec_flag)
int     	tnum, fnum;
unsigned char	*src;
struct idx_info *cur_info;
int next_rec_flag;
{
struct nra_env idx;
char       *hdr;
unsigned char	*dest;
long       offset=0;
int        index;
long       tree_off, rec_off;
int        i=0, n;
U24_SA3    msf1;
U24_SA3    msf2;


memset (&idx, 0, sizeof (struct nra_env));
idx.log = llog = stdout;

idx.nra_file = strcmp("nra.dat", "index") ? 0 : 1;

if (!(idx.tree = (treeDef *)malloc (sizeof (treeDef) * MAXTREES)))
{
	perror ("malloc");
	exit (0);
}


if ( hdr = (char *) malloc (2048 * 32))
{
    if (idx.nra_file)
    {
	if (!(idx.jis_fd  = fopen ("nra.jis", "a")))
		 xErr (-1, "ERROR opening 'nra.jis'\n");
    }
    else
    {
       if (!(idx.fd_tree = fopen ("index.rec", "r")))
       {
	   perror ("fopen index.rec");
	   exit (0);
       }
    }

    if (idx.fd = fopen ("index.imd", "rb"))
    {
	if (idx.nra_file)
	      get_disk_offsets (&idx);

	if (fseek (idx.fd, idx.IMD_offset, 0))
		xErr (-1, "Failed to read tree desc\n");

	n = fread(hdr, 2048, 32, idx.fd);
	if (n < 1)
		xErr (-1, "Failed to read tree desc\n");

	while (offset = get_tree_desc (&idx, i, offset, hdr, 0/*put*/))
	{
	    if (i==0)
	    {
	       msf1 = idx.tree[0].treeD.treeAdrMSF;
	       msf2 = idx.tree[0].tableD.recAdrMSF;

	       if (msf1.min == msf2.min)
	       {
                   if   (msf2.sec == msf1.sec)
                   {
                         if (msf2.frame < msf1.frame)
			     msf1 = msf2;
		   }
                   else  
		      if (msf2.sec < msf1.sec)
			 msf1 = msf2;
	       }
	       else if (msf2.min < msf1.min)
			msf1 = msf2;
	    }

	    i++;
	    if (offset == 0xffff)
			break;
	}
	idx.tree_cnt = i;

#ifdef IDX_DEBUG
	printf("debug cur_info->tnum:%d\n",cur_info->tnum);
#endif
		if ((index = reqTree (&idx, msf1, &rec_off, &tree_off, cur_info->tnum)) < 0)
			exit(0);

		if (dump_sony && idx.nra_file)
		{
		    tree_off = 165367808;
                    dumpSony (&idx, index, tree_off, rec_off); 
			exit(0);
		}
		if (!next_rec_flag)
			dest = do_search (&idx, index, tree_off, rec_off, fnum, src, cur_info);
		else 
			dest = next_rec(tnum, fnum, cur_info);


    }   /* index opened */
}
else
	printf ("Failed to malloc hdr buffers.\n");

if (idx.tree)
	free (idx.tree);
if (hdr)
	free (hdr);

if (!idx.fd)
       printf ("Failed to open index.imd'\n");
 else
       fclose (idx.fd);

if (idx.fd_tree)
     fclose (idx.fd_tree);
if (idx.jis_fd)
	fclose (idx.jis_fd);
return(dest);
}