/*************************************************************************
 *
 * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "tables.h"
#include "input.h"
#include <string.h>
#include <malloc.h>
#include <stdio.h>

const mstring star_tag="*";

const int PAD=2;
const mstring HELP=
"Commands from record page:\n"
"\n"
"DEL - Delete record\n"
"RET - Edit record\n"
"n   - New record\n"
"s   - Sort by table\n"
"o   - Order by table\n"
"c   - Check for duplicates\n"
"f   - Filename for map\n"
"r   - Remove table\n"
"a   - Add table\n";

Tables::Tables() : 
  from(0),lines(Lines()-1),atline(0),writable(0),
  tab(0),space(10),cols(Columns()),atcol(0),
  lastfrom(-1),lasttab(-1),lastline(0),lastcol(0)
{
  dispcols=cols/space;
}

Tables::~Tables()
{
}

void Tables::Setup(int sp)
{
  space=sp;
  dispcols=cols/space;
  Home();
}

void Tables::Show()
{
  if(db.remap()) {
    lastfrom=-1;
    caption.convert("%d, %d, %d, %d",
                    db.head()->filesize.get(),
                    db.head()->fatal.get(),
                    db.head()->major.get(),
                    db.head()->minor.get());
  }
  if(from!=lastfrom||tab!=lasttab) {
    ClearScreen();
    Bold(1);
    for(int j=tab;j<tab+dispcols&&j<db.Tables();j++) {
      if(j==db.Index()) {
        OutputField(0,space*(j-tab),space-PAD-1,db.Table(j));
        OutputField(0,space*(j-tab)+space-PAD-1,1,star_tag);
      }
      else {
        OutputField(0,space*(j-tab),space-PAD,db.Table(j));
      }
    }
    Bold(0);
    for(int i=from;i<from+lines&&i<=db.size();i++) {
      for(int j=tab;j<tab+dispcols&&j<=db.Tables();j++) {
        sref tmp; if(i<db.size()&&j<db.Tables()) tmp=db(i,j);
        if(i==atline&&j==atcol) Reverse(1); else Reverse(0);
        OutputField(i+1-from,space*(j-tab),space-PAD,tmp);
        if(i==atline&&j==atcol) Reverse(0);
      }
    }
    Reverse(1);
    OutputField(lines+1,1,cols-1,caption);
    Reverse(0);
  }
  else {
    int i=lastline,j=lastcol;
    if(i>=0&&i<=db.size()&&j>=0&&j<=db.Tables()) {
      sref tmp; if(i<db.size()&&j<db.Tables()) tmp=db(i,j);
      OutputField(i+1-from,space*(j-tab),space-PAD,tmp);
    }
    i=atline; j=atcol;
    if(i>=0&&i<=db.size()&&j>=0&&j<=db.Tables()) {
      sref tmp; if(i<db.size()&&j<db.Tables()) tmp=db(i,j);
      Reverse(1);
      OutputField(i+1-from,space*(j-tab),space-PAD,tmp);
      Reverse(0);
    }
  }
  MoveCursor(lines+1,0);
  Refresh();
  lastline=atline;
  lastcol=atcol;
  lastfrom=from;
  lasttab=tab;
}

void Tables::Home()
{
  atline=atcol=from=tab=0;
}

void Tables::Move(int i,int j)
{
  atline+=i;
  if(atline>=db.size()) atline=db.size();
  if(atline<0) atline=0;
  if(atline>=from+lines) from=atline+1-lines;
  if(atline<from) from=atline;
  atcol+=j;
  if(atcol>=db.Tables()) atcol=db.Tables();
  if(atcol<0) atcol=0;
  if(atcol>=tab+dispcols) tab=atcol+1-dispcols;
  if(atcol<tab) tab=atcol;
}

void Tables::Insert()
{
  if(db.remap()) lastfrom=-1;
  if(db.Tables()==0) return;
  mstring tx,key,ttab=db.Table(db.Index());
  tx.convert("%s - insert %s",path.c_str(),ttab.c_str());
  Editor edit(tx,1);
  edit.Paste("");
  edit.Navigate();
  edit.Copy(key);
  int row=-1;
  try {
    spile list(db.Tables());
    list[db.Index()]=key;
    row=db.Insert(list,1);
    if(row>=0) {
      caption.convert("%s - added record",path.c_str());
      Move(row-atline,0);
    }
    else {
      caption.convert("%s - record nonunique - not added",path.c_str());
      Move(0,0);
    }
  }
  catch(const merror_t& e) {
    caption=e.desc;
    Move(0,0);
  }
  lastfrom=-1;
}

void Tables::Delete()
{
  if(db.remap()) lastfrom=-1;
  if(atline<db.size()) {
    db.Rem(atline);
    Move(0,0);
    lastfrom=-1;
  }
}

void Tables::Navigate()
{
  int c;
  while(1) {
    Show();
    switch(c=Input()) {
    case KK_UP:
    case 16:
      Move(-1,0);
      break;
    case KK_DOWN:
    case 14:
      Move(1,0);
      break;
    case KK_LEFT:
    case 2:
      Move(0,-1); break;
    case KK_RIGHT:
    case 6:
    case 9:
      Move(0,1);
      break;
    case KK_NPAGE:
      Move(lines/2,0);
      break;
    case KK_PPAGE:
      Move(-lines/2,0);
      break;
    case KK_HOME:
    case 1:
      Move(0,-db.Tables());
      break;
    case KK_END:
    case 5:
      Move(0,db.Tables());
      break;
    case 127:
    case 4:
      if(writable) Delete();
      break;
    case 13:
      Edit();
      break;
    case 's':
      Sort();
      break;
    case 'o':
      if(writable) Order();
      break;
    case 'c':
      Check();
      break;
    case 'f':
      FileName();
      break;
    case 'r':
      if(writable) RemTable();
      break;
    case 'a':
      if(writable) AddTable();
      break;
    case 'n':
      if(writable) Insert();
      break;
    case 27:
      if(Command()) break;
      else return;
    }

  }
}

int Tables::Command()
{
  mstring tmp=caption;
  caption="q (quit), s (save), h (help)";
  lastfrom=-1;
  Show();
  switch(Input()) {
  case 'q':
    return 0;
  case 's':
    Save();
    break;
  case 'h':
    Help();
    break;
  default:
    caption=tmp;
    break;
  }
  lastfrom=-1;
  return 1;
}

void Tables::Help()
{
  Editor edit("help",0);
  edit.Paste(HELP);
  edit.Navigate();
  lastfrom=-1;
}

void Tables::Edit()
{
  if(db.remap()) lastfrom=-1;
  if(atline<db.size()&&atcol<db.Tables()) {
    mstring tx;
    tx.convert("%s - (%d,%d)",path.c_str(),atline+1,atcol+1);
    Editor edit(tx,writable&&atcol!=db.Index());
    edit.Paste(db(atline,atcol));
    edit.Navigate();
    edit.Copy(tx);
    try {
      if(writable) db.Set(atline,atcol,tx);
      caption=path;
      caption+=sref(" edited.");
    }
    catch(const merror_t& e) {
      caption=e.desc;
    }
    catch(...) {
    }
    Move(0,0);
    lastfrom=-1;
  }
}

void Tables::Sort()
{
  if(db.remap()) lastfrom=-1;
  if(atline<=db.size()&&atcol<db.Tables()) {
    mstring tx=db.Compname();
    Editor edit("compname",1);
    edit.Paste(tx);
    edit.Navigate();
    edit.Copy(tx);
    db.Sort(db.Table(atcol),tx);
    mstring ttab=db.Table(db.Index());
    caption.convert("%s sorted: %s %s",path.c_str(),ttab.c_str(),tx.c_str());
    Move(0,0);
    lastfrom=-1;
  }
}

void Tables::Order()
{
  if(db.remap()) lastfrom=-1;
  if(atline<=db.size()&&atcol<db.Tables()) {
    mstring tx=db.Compname();
    Editor edit("compname",1);
    edit.Paste(tx);
    edit.Navigate();
    edit.Copy(tx);
    db.Order(db.Table(atcol),tx);
    mstring ttab=db.Table(db.Index());
    caption.convert("%s ordered: %s %s",path.c_str(),ttab.c_str(),tx.c_str());
    Move(0,0);
    lastfrom=-1;
  }
}

void Tables::Check()
{
  if(db.remap()) lastfrom=-1;
  int idx=db.Index();
  mswrite mm;
  for(int i=0;i<db.size()-1;i++) {
    if(db(i,idx)==db(i+1,idx)) mm<<db(i,idx)<<" duplicated\n";
  }
  if(mm.str().empty()) mm<<"Nothing duplicated\n";
  Editor edit("check",0);
  edit.Paste(mm.str());
  edit.Navigate();
  lastfrom=-1;
}

void Tables::FileName()
{
  if(db.remap()) lastfrom=-1;
  mstring tx; tx.convert("%s - filename",path.c_str());
  Editor edit(tx,1);
  tx.convert("%s",path.c_str());
  edit.Paste(tx);
  edit.Navigate();
  edit.Copy(tx);
  path=tx;
  lastfrom=-1;
}

void Tables::AddTable()
{
  if(db.remap()) lastfrom=-1;
  mstring tx;
  tx.convert("%s - add table (def: 2nd line)",path.c_str());
  Editor edit(tx,1);
  edit.Paste("");
  edit.Navigate();
  mstring tb;
  edit.Copy(tb);
  sref first,rest=tb;
  Splitln(first,rest);
  mstring name=first;
  Splitln(first,rest);
  int ok=-db.Tables();
  db.InsertTable(atcol,name);
  ok+=db.Tables();
  if(ok) {
    Move(0,0);
    caption.convert("%s - added table",path.c_str());
  }
  else caption.convert("%s - not unique - table not added",path.c_str());
  lastfrom=-1;
}

void Tables::RemTable()
{
  if(db.remap()) lastfrom=-1;
  if(atcol<db.Tables()&&atcol!=db.Index()) {
    db.RemTable(atcol);
    Move(0,0);
    caption.convert("%s - removed table",path.c_str());
  }
  else caption.convert("%s - key table - not removed",path.c_str());
  lastfrom=-1;
}

void Tables::Open(const mstring& s,int ex)
{
  path=s;
  writable=ex;
  db.Open(s,ex);
  if(ex) db.Saveas(path+sref(".bak"));
  caption=s;
  caption+=sref(" loaded");
  if(ex) caption+=sref(" (exclusive)");
  lastfrom=-1;
}

void Tables::Save()
{
  try {
    db.Saveas(path);
    caption=path;
    caption+=sref(" saved");
  }
  catch(const merror_t& e) {
    caption=e.desc;
  }
  lastfrom=-1;
}

void Tables::Close()
{
  if(writable) {
    db.Close();
    caption=path;
    caption+=sref(" closed");
  }
  else {
    caption=path;
    caption+=sref(" readonly - not closed");
  }
  lastfrom=-1;
}