#include <text.h>
#include <fstream.h>
#include <ctype.h>

static char mytmpstr[257];

class _HotSpot : public TObject
{
  public:
//      TArray _spots;  // tokenstrings
  char _bg, _fg;

    _HotSpot (char fg, char bg)
  {
    _fg = fg;
    _bg = bg;
  }
  virtual ~ _HotSpot ()
  {
  }
};

void TTextfile::set_hotspots (char fg, char bg)
{
  _HotSpot *hp = new _HotSpot (fg, bg);
  _hotspots.add (hp);
}

style TTextfile::_trans_style (char ch)
{
  switch (ch)
    {
    case 'r':
      return normal;
      break;
    case 'i':
      return italic;
      break;
    case 'b':
      return bold;
      break;
    case 'u':
      return underlined;
      break;
    case 'o':
      return overstrike;
      break;
    case 'k':
      return smallcaps;
      break;
    default:
      return normal;
      break;
    }
}

void TTextfile::_read_page (long n)
{
  switch (_direction)
    {
    case down:
      _page_start = n;
      break;
    case up:
      _page_start = n + _page_size;
      break;
    case updown:
      _page_start = n - (_page_size / 2l);
      break;
    }

  if (_page_start < 0l)
    _page_start = 0l;
  if ((_page_start + _page_size) > _lines)
    _page_end = _lines - 1;
  else
    _page_end = _page_start + _page_size - 1;

  // zap hotspots
  _spots.destroy ();

  long l = 0l;
  fseek (_index, _page_start * (long) sizeof (long), SEEK_SET);
  if (_page_start != 0l)
    fread (&l, sizeof (long), 1, _index);
  fseek (_instr, l, SEEK_SET);

  for (long i = _page_start; i <= _page_end; i++)
    {
      if (feof (_instr))
        break;
      fgets (mytmpstr, sizeof (mytmpstr), _instr);
      mytmpstr[strlen (mytmpstr) - 1] = '\0';
      TString & ts = (TString &) _page[(int) (i - _page_start)];
      ts = mytmpstr;
      TString hcol (6);
      // find hotspots and compile list                           

      int len = 0;
      const char *cp;
      read_line (i, 0, FALSE);
      while (cp = piece ())
        {
          for (int z = 0; z < _hotspots.items (); z++)
            {
              _HotSpot & hs = (_HotSpot &) _hotspots[z];
              if (hs._fg == get_foreground () && hs._bg == get_background ())
                {
                  TToken_string *tts = new TToken_string (50);
                  tts->add (i); // line number                        

                  tts->add (len);
                  tts->add (len + (int) strlen (cp));
                  tts->add (cp);
                  tts->add (z);
                  _spots.add (tts);
                  break;
                }
            }
          len += strlen (cp);
        }
    }
}

void TTextfile::read_line (long n, long pos, bool pg)
{
  CHECK (_isopen, "Attempt operation on closed file");
  CHECKD (n >= 0 && n < _lines, "Line not present", n);

  if (pg && !_in_page (n))
    _read_page (n);

  TString *tp = (TString *) _page.objptr (int (n - _page_start));
  if (tp == NULL)
    return;

  const char *sp = (const char *) (*tp);
  _item = 0;
  _line = "";
  int ndx = 0, p = 0;
  bool first = TRUE;
  _cur_line = n;
  char ch;

  int col = ((int) 'w' << 8) | (int) 'n';
  long stl = (long) col << 16;

  while (ch = *sp++)
    {
      if (ch == '@' || (ch == '$' && *(sp) == '['))
	{
	  if (!first && p >= pos)
	    {
	      _styles[_item++] = stl;
	      mytmpstr[ndx] = '\0';
	      _line.add (mytmpstr);
	      ndx = 0;
	    }
	  while (ch && (ch == '@' || (ch == '$' && *sp == '[')))
	    {
	      if (ch == '@')	// font style change ? 

		{
		  style sss = _trans_style (*sp++);
		  if (sss == normal)
		    stl = (long) col << 16;
		  else
		    stl |= (long) sss;
		}
	      else if (ch == '$' && *sp == '[')		// color change

		{
		  ++sp;		// eat '['

		  col = *sp++;
		  ++sp;		// eat ','                        

		  col |= ((int) (*sp++) << 8);
		  ++sp;		// eat ']'

		  stl = (stl & 0x0000ffff) | ((long) col << 16);
		}
	      ch = *sp++;
	    }			// while

	}
      if (ch && p >= pos)
	{
	  first = FALSE;
	  mytmpstr[ndx++] = ch;
	}
      p++;
    }
  _styles[_item++] = stl;
  mytmpstr[ndx] = '\0';
  _line.add (mytmpstr);
  _item = 0;
}

const char *TTextfile::line (long j, long pos)
{
  if (_cur_line != j)
    read_line (j);
  *mytmpstr = '\0';
  _line.restart ();
  for (int i = 0; i < _line.items (); i++)
    strcat (mytmpstr, (const char *) _line.get ());
  return strlen (mytmpstr) > (word) pos ? &(mytmpstr[pos]) : "";
}

long TTextfile::get_attribute (int pos)
{
  long stl = 0;
  if (pos == -1)
    {
      CHECK (_item > 0, "must execute piece() before style()!");
      stl = _styles[_item - 1];
    }
  else
    {
      int x = 0, nd = 0;
      const char *c;
      _line.restart ();
      while (c = _line.get ())
	{
	  x += strlen (c);
	  stl = _styles[nd++];
	  if ((x - 1) >= pos)
	    break;
	}
    }
  return stl;
}

int TTextfile::get_style (int pos)
{
  long x = get_attribute (pos);
  return (int) (x & 0x0000ffff);
}

char TTextfile::get_background (int pos)
{
  long x = get_attribute (pos);
  return (char) (x >> 24);
}

char TTextfile::get_foreground (int pos)
{
  long x = get_attribute (pos);
  return (char) ((x >> 16) & 0x000000ff);
}

const char *TTextfile::piece ()
{
  if (_item >= _line.items ())
    return NULL;
  return strcpy (mytmpstr, (const char *) _line.get (_item++));
}

const char *TTextfile::word_at (long x, long y)
{
  CHECK (_isopen, "Attempt operation on closed file");
  TString s (line (y));
  int x2 = 0;

  if (x < s.len ())
    {
      while (isspace (s[(int) x]))
	{
	  if (x == (s.len () - 1) && y < (_lines - 1l))
	    {
	      s = line (++y);
	      x = 0l;
	    }
	  else if (x < (s.len () - 1))
	    x++;
	  else
	    break;
	}
      while (isalnum (s[(int) x]))
	mytmpstr[x2++] = s[(int) x++];
    }
  mytmpstr[x2] = '\0';
  return mytmpstr;
}

bool TTextfile::append (const char *l)
{
  CHECK (_isopen, "Attempt operation on closed file");

  if (!_accept)
    return FALSE;

  fseek (_instr, 0l, SEEK_END);
  fseek (_index, 0l, SEEK_END);
  long cpos = ftell (_instr);
  fprintf (_instr, "%s\n", l);
  fwrite (&cpos, sizeof (long), 1, _index);
  if (ferror (_index) || ferror (_instr))
    {
      error_box ("Errore di scrittura file temporaneo: scrittura interrotta");
      freeze ();
    }
  fflush (_index);
  fflush (_instr);

  _lines++;
  _dirty = TRUE;

  if ((_lines) < (_page_start + _page_size))
    {
      TString *ll = new TString (l);
      _page.add (ll);
      _page_end++;

      int len = 0;
      const char *cp;
      read_line (_lines - 1);
      while (cp = piece ())
	{
	  for (int z = 0; z < _hotspots.items (); z++)
	    {
	      _HotSpot & hs = (_HotSpot &) _hotspots[z];
	      if (hs._fg == get_foreground () && hs._bg == get_background ())
		{
		  TToken_string *tts = new TToken_string (50);
		  tts->add (_lines - 1l);	// line number
		  // 

		  tts->add (len);
		  tts->add (len + (int) strlen (cp));
		  tts->add (cp);
		  tts->add (z);
		  _spots.add (tts);
		  break;
		}
	    }
	  len += strlen (cp);
	}
      return TRUE;
    }
  return FALSE;
}

void TTextfile::close ()
{
  CHECK (_isopen, "Attempt operation on closed file");
  fclose (_instr);
  fclose (_index);
  _instr = _index = NULL;
  _isopen = FALSE;
}

void TTextfile::print ()
{
  CHECK (_isopen, "Attempt operation on closed file");
  warning_box ("Funzione non ancora implementata");
  // TBI istanzia una printer inibendo la scelta di video
  // add all lines (maybe new method: print_txt)
  // print
}

bool TTextfile::write (const char *path, TPoint * from, TPoint * to)
{
  bool ok = FALSE;
  FILE *fp;
  if ((fp = fopen (path, "w")) != NULL)
    {
      ok = TRUE;
      TString256 s;
      long starty = from == NULL ? 0l : from->y;
      int startx = from == NULL ? 0 : (int) from->x;
      long endy = to == NULL ? _lines - 1l : to->y;
      int endx = to == NULL ? -1 : (int) to->x;
      for (long j = starty; j <= endy; j++)
	{
	  s = line (j);
	  if (j == endy && endx == -1)
	    endx = s.len ();

	  if (j == starty && j == endy)
	    s = s.sub (startx, endx);
	  else if (j == starty)
	    s = s.mid (startx);
	  else if (j == endy)
	    s = s.left (endx);

	  fprintf (fp, "%s\n", (const char *) s);
	}
      fclose (fp);
    }
  else
    warning_box ("Impossibile scrivere il file %s; scrittura fallita", path);
  return ok;
}

void TTextfile::destroy ()
{
  CHECK (_istemp, "destroy() chiamata su testo permanente!");
  if (_page.items () > 0)
    {
      if (_index)
	fclose (_index);
      if (_instr)
	fclose (_instr);
      remove ((const char *) _filename);
      remove ((const char *) _indname);
      _page_start = _lines = 0l;
      _page_end = _cur_line = -1l;
      _accept = TRUE;
      _instr = fopen (_filename, "a+");
      _indname.temp ();
      _index = fopen (_indname, "w+b");
      if (_index == NULL || _instr == NULL)
	{
	  error_box ("Impossibile aprire files temporanei");
	  freeze ();
	}
      _isopen = TRUE;
      _page.destroy ();
      _spots.destroy ();
    }
}

TTextfile ::TTextfile (const char *file, int pagesize, direction preferred):
  _page_size (pagesize), _page (pagesize), _filename (file), _lines (0l),
  _index (NULL), _page_start (0l), _page_end (-1l), _direction (preferred),
  _dirty (FALSE), _istemp (FALSE), _item (0), _line (256), _cur_line (-1),
  _hotspots (4), _accept (TRUE)
{
  // open file & build index
  if (file == NULL)
    {
      _filename.temp ();
      _istemp = TRUE;
    }

  _instr = fopen (_filename, "a+");
  _indname.temp ();
  _index = fopen (_indname, "w+b");

  if (_index == NULL || _instr == NULL)
    {
      error_box ("Impossibile aprire files temporanei");
      freeze ();
    }
  if (file != NULL)
    while (!feof (_instr))
      {
	const long l = ftell (_instr);
	fwrite (&l, sizeof (long), 1, _index);
	if (ferror (_index) || ferror (_instr))
	  {
	    error_box ("Errore di scrittura file temporaneo: scrittura interrotta");
	    freeze ();
	  }
	fgets (mytmpstr, sizeof (mytmpstr), _instr);
	_lines++;
      }
  _isopen = TRUE;
}

TTextfile::~TTextfile ()
{
  if (_index)
    fclose (_index);
  if (_instr)
    fclose (_instr);
  if (_istemp)
    remove ((const char *) _filename);
  remove ((const char *) _indname);
}