//C-  -*- C++ -*-

//C- -------------------------------------------------------------------

//C- DjVuLibre-3.5

//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.

//C- Copyright (c) 2001  AT&T

//C-

//C- This software is subject to, and may be distributed under, the

//C- GNU General Public License, either Version 2 of the license,

//C- or (at your option) any later version. The license should have

//C- accompanied the software or you may obtain a copy of the license

//C- from the Free Software Foundation at http://www.fsf.org .

//C-

//C- This program is distributed in the hope that it will be useful,

//C- but WITHOUT ANY WARRANTY; without even the implied warranty of

//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//C- GNU General Public License for more details.

//C- 

//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):

//C-

//C-  ------------------------------------------------------------------

//C- | DjVu (r) Reference Library (v. 3.5)

//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.

//C- | The DjVu Reference Library is protected by U.S. Pat. No.

//C- | 6,058,214 and patents pending.

//C- |

//C- | This software is subject to, and may be distributed under, the

//C- | GNU General Public License, either Version 2 of the license,

//C- | or (at your option) any later version. The license should have

//C- | accompanied the software or you may obtain a copy of the license

//C- | from the Free Software Foundation at http://www.fsf.org .

//C- |

//C- | The computer code originally released by LizardTech under this

//C- | license and unmodified by other parties is deemed "the LIZARDTECH

//C- | ORIGINAL CODE."  Subject to any third party intellectual property

//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 

//C- | non-exclusive license to make, use, sell, or otherwise dispose of 

//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 

//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 

//C- | General Public License.   This grant only confers the right to 

//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 

//C- | the extent such infringement is reasonably necessary to enable 

//C- | recipient to make, have made, practice, sell, or otherwise dispose 

//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 

//C- | any greater extent that may be necessary to utilize further 

//C- | modifications or combinations.

//C- |

//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY

//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF

//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

//C- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "GIFFManager.h"

#include "GException.h"

#include "debug.h"

#ifdef HAVE_NAMESPACES

namespace DJVU {

# ifdef NOT_DEFINED // Just to fool emacs c++ mode

}

#endif

#endif

GIFFChunk::~GIFFChunk(void) {}

GIFFManager::~GIFFManager(void) {}

GP<GIFFManager> 

GIFFManager::create(void)

{

  GIFFManager *iff=new GIFFManager();

  GP<GIFFManager> retval=iff;

  iff->init();

  return retval;

}

GP<GIFFManager> 

GIFFManager::create(const GUTF8String &name)

{

  GIFFManager *iff=new GIFFManager();

  GP<GIFFManager> retval=iff;

  iff->init(name);

  return retval;

}

void

GIFFChunk::set_name(GUTF8String name)

{

  DEBUG_MSG("GIFFChunk::set_name(): name='" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  const int colon=name.search(':');

  if(colon>=0)

  {

    type=name.substr(0,colon);

    name=name.substr(colon+1,(unsigned int)-1);

    if(name.search(':')>=0)

      G_THROW( ERR_MSG("GIFFManager.one_colon") );

  }

  DEBUG_MSG("auto-setting type to '" << type << "'\n");

  if (name.contains(".[]")>=0)

    G_THROW( ERR_MSG("GIFFManager.bad_char") );

  strncpy(GIFFChunk::name, (const char *)name, 4);

  GIFFChunk::name[4]=0;

  for(int i=strlen(GIFFChunk::name);i<4;i++)

    GIFFChunk::name[i]=' ';

}

bool

GIFFChunk::check_name(GUTF8String name)

{

  GUTF8String type;

  const int colon=name.search(':');

  if(colon>=0)

    {

      type=name.substr(0,colon);

      name=name.substr(colon+1,(unsigned int)-1);

    }

  const GUTF8String sname=(name.substr(0,4)+"    ").substr(0,4);

  DEBUG_MSG("GIFFChunk::check_name(): type='" << type << "' name='" << sname << "'\n");

  return (type==GIFFChunk::type || (!type.length() && GIFFChunk::type=="FORM"))

    && sname==GIFFChunk::name;

}

void

GIFFChunk::save(IFFByteStream & istr, bool use_trick)

{

  DEBUG_MSG("GIFFChunk::save(): saving chunk '" << get_full_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (is_container())

  {

    istr.put_chunk(get_full_name(), use_trick);

    if (chunks.size())

    {

      GPosition pos;

      for(pos=chunks;pos;++pos)

        if (chunks[pos]->get_type()=="PROP")

          chunks[pos]->save(istr);

      for(pos=chunks;pos;++pos)

        if (chunks[pos]->get_type()!="PROP")

          chunks[pos]->save(istr);

    } else

    {

      DEBUG_MSG("but it's empty => saving empty container.\n");

    }

    istr.close_chunk();

  } else

  {

    istr.put_chunk(get_name(), use_trick);

    istr.get_bytestream()->writall((const char *) data, data.size());

    istr.close_chunk();

  }

}

void

GIFFChunk::add_chunk(const GP<GIFFChunk> & chunk, int position)

{

  DEBUG_MSG("GIFFChunk::add_chunk(): Adding chunk to '" << get_name() <<

     "' @ position=" << position << "\n");

  DEBUG_MAKE_INDENT(3);

  if (!type.length())

  {

    DEBUG_MSG("Converting the parent to FORM\n");

    type="FORM";

  }

  if (chunk->get_type()=="PROP")

  {

    DEBUG_MSG("Converting the parent to LIST\n");

    type="LIST";

  }

  GPosition pos;

  if (position>=0 && chunks.nth(position, pos))

  {

    chunks.insert_before(pos, chunk);

  }else

  {

    chunks.append(chunk);

  }

}

GUTF8String 

GIFFChunk::decode_name(const GUTF8String &name, int &number)

{

  DEBUG_MSG("GIFFChunk::decode_name(): Checking brackets in name '" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (name.search('.')>=0)

    G_THROW( ERR_MSG("GIFFManager.no_dots") );

  number=0;

  const int obracket=name.search('[');

  GUTF8String short_name;

  if (obracket >= 0)

  {

    const int cbracket=name.search(']',obracket+1);

    if (cbracket < 0)

      G_THROW( ERR_MSG("GIFFManager.unmatched") );

    if (name.length() > (unsigned int)(cbracket+1))

      G_THROW( ERR_MSG("GIFFManager.garbage") );

//    number =atoi((const char *)name.substr(obracket+1,cbracket-obracket-1));

    number= name.substr(obracket+1,cbracket-obracket-1).toInt(); 

    short_name=name.substr(0,obracket);

  }else

  {

    short_name=name;

  }

  const int colon=short_name.search(':');

  if (colon>=0)

    short_name=short_name.substr(colon+1,(unsigned int)-1);

  for(int i=short_name.length();i<4;i++)

    short_name.setat(i, ' ');

  DEBUG_MSG("short_name='" << short_name << "'\n");

  DEBUG_MSG("number=" << number << "\n");

  return short_name;

}

void

GIFFChunk::del_chunk(const GUTF8String &name)

   // The name may contain brackets to specify the chunk number

{

  DEBUG_MSG("GIFFChunk::del_chunk(): Deleting chunk '" << name <<

     "' from '" << get_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  int number;

  const GUTF8String short_name=decode_name(name,number);

  GPosition pos=chunks;

  for(int num=0;pos;++pos)

  {

    if ((chunks[pos]->get_name()==short_name)&&(num++ == number))

    {

      chunks.del(pos);

      break;

    }

  }

  if(! pos)

  {

    G_THROW( ERR_MSG("GIFFManager.no_chunk") "\t"+short_name+"\t"+GUTF8String(number)+"\t"+get_name());

  }

}

GP<GIFFChunk>

GIFFChunk::get_chunk(const GUTF8String &name, int * pos_ptr)

   // The name may contain brackets to specify the chunk number

{

  DEBUG_MSG("GIFFChunk::get_chunk(): Returning chunk '" << name <<

     "' from '" << get_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  int number;

  const GUTF8String short_name=decode_name(name,number);

  int num=0;

  int pos_num;

  GP<GIFFChunk> retval;

  GPosition pos;

  for(pos=chunks, pos_num=0;pos;++pos, pos_num++)

  {

    if (chunks[pos]->get_name()==short_name && num++==number)

    {

      if (pos_ptr)

        *pos_ptr=pos_num;

      retval=chunks[pos];

      break;

    }

  }

  return retval;

}

int

GIFFChunk::get_chunks_number(void)

{

  DEBUG_MSG("GIFFChunk::get_chunks_number(): Returning number of chunks '" << name <<

     "' in '" << get_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  return chunks.size();

}

int

GIFFChunk::get_chunks_number(const GUTF8String &name)

{

  DEBUG_MSG("GIFFChunk::get_chunks_number(): Returning number of chunks '" << name <<

     "' in '" << get_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (name.contains("[]")>=0)

    G_THROW( ERR_MSG("GIFFManager.no_brackets") );

  int number; 

  GUTF8String short_name=decode_name(name,number);

  int num=0;

  for(GPosition pos=chunks;pos;++pos)

     num+=(chunks[pos]->get_name()==short_name);

  return num;

}

//************************************************************************

void

GIFFManager::add_chunk(GUTF8String parent_name, const GP<GIFFChunk> & chunk,

		       int pos)

      // parent_name is the fully qualified name of the PARENT

      //             IT MAY BE EMPTY

      // All the required chunks will be created

      // pos=-1 means to append the chunk

{

  DEBUG_MSG("GIFFManager::add_chunk(): Adding chunk to name='" << parent_name << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (!top_level->get_name().length())

  {

    if ((!parent_name.length())||(parent_name[0]!='.'))

      G_THROW( ERR_MSG("GIFFManager.no_top_name") );

    if (parent_name.length() < 2)

    {

      // 'chunk' is actually the new top-level chunk

      DEBUG_MSG("since parent_name=='.', making the chunk top-level\n");

      if (!chunk->is_container())

        G_THROW( ERR_MSG("GIFFManager.no_top_cont") );

      top_level=chunk;

      return;

    }

    DEBUG_MSG("Setting the name of the top-level chunk\n");

    const int next_dot=parent_name.search('.',1);

    if(next_dot>=0)

    {

      top_level->set_name(parent_name.substr(1,next_dot-1));

    }else

    {

      top_level->set_name(parent_name.substr(1,(unsigned int)-1));

    }

  }

  DEBUG_MSG("top level chunk name='" << top_level->get_name() << "'\n");

  if (parent_name.length() && parent_name[0] == '.')

  {

    int next_dot=parent_name.search('.',1);

    if(next_dot<0)

    {

      next_dot=parent_name.length();

    }

    GUTF8String top_name=parent_name.substr(1,next_dot-1);

    if (!top_level->check_name(top_name))

      G_THROW( ERR_MSG("GIFFManager.wrong_name") "\t"+top_name);

    parent_name=parent_name.substr(next_dot,(unsigned int)-1);

  }

  GP<GIFFChunk> cur_sec=top_level;

  const char * start, * end=(const char *)parent_name-1;

  do

  {

    for(start=++end;*end&&(*end!='.');end++)

      EMPTY_LOOP;

    if (end>start)

    {

      GUTF8String name(start,end-start);

      GUTF8String short_name;

      int number=0;

      const int obracket=name.search('[');

      if (obracket >= 0)

      {

        const int cbracket=name.search(']',obracket+1);

        if (cbracket < 0)

          G_THROW( ERR_MSG("GIFFManager.unmatched") );

//        number=atoi((const char *)name.substr(obracket+1,cbracket-obracket-1));

        number = name.substr(obracket+1,cbracket-obracket-1).toInt();

        short_name=name.substr(0,obracket);

      }else

      {

        short_name=name;

      }

      for(int i=cur_sec->get_chunks_number(short_name);i

        cur_sec->add_chunk(GIFFChunk::create(short_name));

      cur_sec=cur_sec->get_chunk(name);

      if (!cur_sec)

        G_THROW( ERR_MSG("GIFFManager.unknown") "\t"+name);

    }

  } while(*end);

  cur_sec->add_chunk(chunk, pos);

}

void

GIFFManager::add_chunk(GUTF8String name, const TArray<char> & data)

      // name is fully qualified name of the chunk TO BE INSERTED.

      //      it may contain brackets at the end to set the position

      // All the required chunks will be created

{

  DEBUG_MSG("GIFFManager::add_chunk(): adding plain chunk with name='" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  GUTF8String chunk_name;

  const int lastdot=name.rsearch('.');

  if(lastdot < 0)

  {

    chunk_name=name;

    name=name.substr(0,lastdot);

  }else

  {

    chunk_name=name.substr(lastdot+1,(unsigned int)-1);

  }

  int pos=-1;

  const int obracket=chunk_name.search('[');

  if (obracket >= 0)

  {

    const int cbracket=chunk_name.search(']',obracket+1);

    if (cbracket < 0)

      G_THROW( ERR_MSG("GIFFManager.unmatched") );

    if (name.length() > (unsigned int)(cbracket+1))

      G_THROW( ERR_MSG("GIFFManager.garbage") );

//    pos=atoi((const char *)chunk_name.substr(obracket+1,cbracket-obracket-1));

    pos = chunk_name.substr(obracket+1,cbracket-obracket-1).toInt();

    chunk_name=chunk_name.substr(0,obracket);

  }

  DEBUG_MSG("Creating new chunk with name " << chunk_name << "\n");

  GP<GIFFChunk> chunk;

  chunk=GIFFChunk::create(chunk_name, data);

  add_chunk(name, chunk, pos);

}

void

GIFFManager::del_chunk(void)

{

  DEBUG_MSG("GIFFManager::del_chunk(): Deleting chunk\n");

  DEBUG_MAKE_INDENT(3);

  G_THROW( ERR_MSG("GIFFManager.del_empty") );

}

void

GIFFManager::del_chunk(GUTF8String name)

      // "name" should be fully qualified, that is contain dots.

      // It may also end with [] to set the chunk order number

{

  DEBUG_MSG("GIFFManager::del_chunk(): Deleting chunk '" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (!name.length())

    G_THROW( ERR_MSG("GIFFManager.del_empty") );

  if (name[0]=='.')

  {

    const int next_dot=name.search('.',1);

    if (next_dot < 0)

    {

      if (top_level->check_name(name.substr(1,(unsigned int)-1)))

      {

        DEBUG_MSG("Removing top level chunk..\n");

        top_level=GIFFChunk::create();

        return;

      }

      G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+name.substr(1,(unsigned int)-1));

    }

    const GUTF8String top_name=name.substr(1,next_dot-1);

    if (!top_level->check_name(top_name))

      G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+top_name);

    name=name.substr(next_dot+1,(unsigned int)-1);

  }

  GP<GIFFChunk> cur_sec=top_level;

  const char * start, * end=(const char *)name-1;

  do

  {

    for(start=++end;*end&&(*end!='.');end++)

      EMPTY_LOOP;

    if (end>start && *end=='.')

      cur_sec=cur_sec->get_chunk(GUTF8String(start, end-start));

    if (!cur_sec)

      G_THROW( ERR_MSG("GIFFManager.cant_find") "\t"+GUTF8String(name));

  } while(*end);

  if (!start[0])

  {

    G_THROW(GUTF8String( ERR_MSG("GIFFManager.malformed") "\t")+name);

  }

  cur_sec->del_chunk(start);

}

GP<GIFFChunk>

GIFFManager::get_chunk(GUTF8String name, int * pos_num)

      // "name" should be fully qualified, that is contain dots.

      // It may also end with [] to set the chunk order number

{

  DEBUG_MSG("GIFFManager::get_chunk(): Returning chunk '" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (!name.length())

    G_THROW( ERR_MSG("GIFFManager.get_empty") );

  if (name[0]=='.')

  {

    const int next_dot=name.search('.',1);

    if (next_dot < 0)

    {

      if (top_level->check_name(name.substr(1,(unsigned int)-1)))

      {

        DEBUG_MSG("Removing top level chunk..\n");

        return top_level;

      }

      G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+name.substr(1,(unsigned int)-1));

    }

    const GUTF8String top_name=name.substr(1,next_dot-1);

    if (!top_level->check_name(top_name))

      G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+top_name);

    name=name.substr(next_dot+1,(unsigned int)-1);

  }

  GP<GIFFChunk> cur_sec=top_level;

  const char * start, * end=(const char *) name-1;

  do

  {

    for(start=++end;*end&&(*end!='.');end++)

      EMPTY_LOOP;

    if (end>start)

      cur_sec=cur_sec->get_chunk(GUTF8String(start, end-start), pos_num);

    if (!cur_sec)

      break;

  } while(*end);

  return cur_sec;

}

int

GIFFManager::get_chunks_number(void)

{

  DEBUG_MSG("GIFFManager::get_chunks_number()\n");

  DEBUG_MAKE_INDENT(3);

  return top_level->get_chunks_number();

}

int

GIFFManager::get_chunks_number(const GUTF8String &name)

   // Returns the number of chunks with given fully qualified name

{

  DEBUG_MSG("GIFFManager::get_chunks_number(): name='" << name << "'\n");

  DEBUG_MAKE_INDENT(3);

  int retval;

  const int last_dot=name.rsearch('.');

  if (last_dot<0)

  {

    retval=top_level->get_chunks_number(name);

  }else if(!last_dot)

  {

    retval=(top_level->get_name()==name.substr(1,(unsigned int)-1))?1:0;

  }else

  {

    GP<GIFFChunk> chunk=get_chunk(name.substr(0,last_dot));

    retval=( chunk

      ?(chunk->get_chunks_number(name.substr(last_dot+1,(unsigned int)-1)))

      :0 );

  }

  return retval;

}

void

GIFFManager::load_chunk(IFFByteStream & istr, GP<GIFFChunk> chunk)

{

  DEBUG_MSG("GIFFManager::load_chunk(): loading contents of chunk '" <<

    chunk->get_name() << "'\n");

  DEBUG_MAKE_INDENT(3);

  int chunk_size;

  GUTF8String chunk_id;

  while ((chunk_size=istr.get_chunk(chunk_id)))

  {

    if (istr.check_id(chunk_id))

    {

      GP<GIFFChunk> ch=GIFFChunk::create(chunk_id);

      load_chunk(istr, ch);

      chunk->add_chunk(ch);

    } else

    {

      TArray<char> data(chunk_size-1);

      istr.get_bytestream()->readall( (char*)data, data.size());

      GP<GIFFChunk> ch=GIFFChunk::create(chunk_id, data);

      chunk->add_chunk(ch);

    }

    istr.close_chunk();

  }

}

void

GIFFManager::load_file(const TArray<char> & data)

{

  GP<ByteStream> str=ByteStream::create((const char *)data, data.size());

  load_file(str);

}

void

GIFFManager::load_file(GP<ByteStream> str)

{

  DEBUG_MSG("GIFFManager::load_file(): Loading IFF file.\n");

  DEBUG_MAKE_INDENT(3);

  GP<IFFByteStream> gistr=IFFByteStream::create(str);

  IFFByteStream &istr=*gistr;

  GUTF8String chunk_id;

  if (istr.get_chunk(chunk_id))

  {

    if (chunk_id.substr(0,5) != "FORM:")

      G_THROW( ERR_MSG("GIFFManager.cant_find2") );

    set_name(chunk_id);

    load_chunk(istr, top_level);

    istr.close_chunk();

  }

}

void

GIFFManager::save_file(TArray<char> & data)

{

  GP<ByteStream> gstr=ByteStream::create();

  save_file(gstr);

  data=gstr->get_data();

}

void

GIFFManager::save_file(GP<ByteStream> str)

{

  GP<IFFByteStream> istr=IFFByteStream::create(str);

  top_level->save(*istr, 1);

}

#ifdef HAVE_NAMESPACES

}

# ifndef NOT_USING_DJVU_NAMESPACE

using namespace DJVU;

# endif

#endif