/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

/*
 * This code is based on the original source code of Lord Avalot d'Argent version 1.3.
 * Copyright (c) 1994-1995 Mike, Mark and Thomas Thurman.
 */

#include "graph.h"
/*#include "Dos.h"*/
/*#include "Crt.h"*/
/*#include "Tommys.h"*/
#include "lucerna.h"

/*$V-*/

namespace Avalanche {

struct windowtype {
              integer x1,y1,x2,y2;
              varying_string<20> title;
};

 struct ednahead { /* Edna header */
           /* This header starts at byte offset 177 in the .ASG file. */
           array<1,9,char> id;     /* signature */
           word revision; /* EDNA revision, here 2 (1=dna256) */
           varying_string<50> game; /* Long name, eg Lord Avalot D'Argent */
           varying_string<15> shortname; /* Short name, eg Avalot */
           word number; /* Game's code number, here 2 */
           word ver; /* Version number as integer (eg 1.00 = 100) */
           varying_string<5> verstr; /* Vernum as string (eg 1.00 = "1.00" */
           varying_string<12> filename; /* Filename, eg AVALOT.EXE */
           byte osbyte; /* Saving OS (here 1=DOS. See below for others.*/
           varying_string<5> os; /* Saving OS (here 1=DOS. See below for others.*/

           /* Info on this particular game */

           varying_string<8> fn; /* Filename (not extension ('cos that's .ASG)) */
           byte d,m; /* D, M, Y are the Day, Month & Year this game was... */
           word y;  /* ...saved on. */
           varying_string<40> desc; /* Description of game (same as in Avaricius!) */
           word len; /* Length of DNA (it's not going to be above 65535!) */

           /* Quick reference & miscellaneous */

           word saves; /* no. of times this game has been saved */
           integer cash; /* contents of your wallet in numerical form */
           varying_string<20> money; /* ditto in string form (eg 5/-, or 1 denarius)*/
           word points; /* your score */

           /* DNA values follow, then footer (which is ignored) */
 };

const integer border = 1; /* size of border on shadowboxes */

const array<1,4,varying_string<7> > buttons = {{"Okay","Wipe","Cancel","Info..."}};

const integer files = 3;
const integer dirs = 4;

const integer drlen = 15; /* no. of drives on one line */

const array<1,4,windowtype> threewins = 
 {{{155, 12, 630, 22, "Name"},
  {15, 25, 410, 70, "Drives"},
  {15, 83, 480, 179, "Files (*.ASG)"},
  {490, 83, 630, 179, "Subdirectories"}}};

const integer name_win = 1;
const integer drive_win = 2;
const integer file_win = 3;
const integer subdir_win = 4;

matrix<3,4,1,77,varying_string<12> > lists;
array<1,77,varying_string<40> > descs;
array<3,4,byte> nums,where,top;
searchrec s;
boolean loading;
varying_string<26> drives;
pathstr current;
byte nowwin;
varying_string<17> doing;

pathstr filename;
boolean filefound;

void shadow(integer x1,integer y1,integer x2,integer y2, byte hc,byte sc)
{
    byte fv;
;
 for( fv=0; fv <= border; fv ++)
 {;
  setfillstyle(1,hc);
  bar(x1+fv,y1+fv,x1+fv,y2-fv);
  bar(x1+fv,y1+fv,x2-fv,y1+fv);

  setfillstyle(1,sc);
  bar(x2-fv,y1+fv,x2-fv,y2-fv);
  bar(x1+fv,y2-fv,x2-fv,y2-fv);
 }
}

void shbox(integer x1,integer y1,integer x2,integer y2, string t)
{
      const integer fc = 7;
;
 shadow(x1,y1,x2,y2,15,8);
 setfillstyle(1,fc);
 bar(x1+border+1,y1+border+1,x2-border-1,y2-border-1);
 setcolor(1); x1=(x2-x1) / 2+x1; y1=(y2-y1) / 2+y1;
 outtextxy(x1,y1,t);
 if (length(t)>1) 
 {;
  fillchar(t[2],length(t)-1,'\40'); t[1]='_';
  outtextxy(x1-1,y1+1,t);
 }
}

void show_drives()
{
    byte fv;
;
 settextjustify(1,1);
 for( fv=0; fv <= length(drives)-1; fv ++)
  shbox((fv % drlen)*25+25,(fv / drlen)*19+31,
   (fv % drlen)*25+40,45+(fv / drlen)*19,drives[fv+1]);
 setcolor(11);
 settextjustify(0,2);
}

void box(integer x1,integer y1,integer x2,integer y2, string z)
{;
 rectangle(x1,y1,x2,y2);
 outtextxy(x1+1,y1-10,z+':');
 outtextxy(x1,y1-9,"_");
}

string lowstr(string x)
{
    byte fv;
string lowstr_result;
;
 for( fv=1; fv <= length(x); fv ++)
  if (set::of(range('A','Z'), eos).has(x[fv]))  x[fv] += 32;
 lowstr_result=x;
return lowstr_result;
}

char lowchar(char x)
{
 char lowchar_result;
 if (set::of(range('A','Z'), eos).has(x))  x -= 32;
 lowchar_result=x;
 return lowchar_result;
}

void getcurrent()
{;
 current=lowstr(fexpand("*.asg"));
}

void setup()
{
 integer gd,gm;
 registers r;
 byte floppies;
;
 gd=3; gm=0; initgraph(gd,gm,"c:\\bp\\bgi");
 dusk();
 setfillstyle(1,1); bar(2,2,637,197); shadow(0,0,639,199,15,7);

 if (loading)  doing="LOAD"; else doing="SAV";
 doing=doing+"ING a file...";

 /* Now... find all drives that exist. */
 drives="";
 intr(0x11,r); floppies=(((cardinal)r.ax >> 6) & 0x3)+1; /* useful bit of code! */
 for( gm=1; gm <= floppies; gm ++) drives=drives+chr(64+gm);
 /* Winchesters, etc., can be found the easy way... */
 for( gd=3; gd <= 26; gd ++) /* C: to Z: */
  if (disksize(gd)>-1)  drives=drives+chr(64+gd);

 fillchar(where,sizeof(where),'\1');
 fillchar(top,sizeof(top),'\1');

 settextstyle(0,0,0);
 settextjustify(1,1);
 for( gd=1; gd <= 2; gd ++)
  for( gm=0; gm <= 1; gm ++)
   shbox(420+gm*110,gd*25,520+gm*110,gd*25+20,buttons[gm*2+gd]);
 shbox(15,182,350,196,"Help... (press f1)");
 settextjustify(0,2); setcolor(11);
 setcolor(15); outtextxy(15,5,"The Avvy Filer...");
 setcolor(11); outtextxy(317,3,string('(')+doing+')');
 outtextxy(357,185,"Copyright (c) 1993, Thomas Thurman.");

 /* Draw the boxes and names */
 setcolor(3);
 for( gm=1; gm <= 4; gm ++)
  { windowtype& with = threewins[gm]; 
   box(with.x1,with.y1,with.x2,with.y2,with.title);}
 nowwin=1; getcurrent();
}

void quicksort(byte whichlist, integer lo, integer hi);


static void sort(integer l, integer r, byte& whichlist)
{
  integer i, j;
  varying_string<12> x, y;

  i = l; j = r; x = lists[whichlist][(l+r) / 2];
  do {
    while (lists[whichlist][i] < x)  i = i + 1;
    while (x < lists[whichlist][j])  j = j - 1;
    if (i <= j) 
    {
      y = lists[whichlist][i];
      lists[whichlist][i] = lists[whichlist][j];
      lists[whichlist][j] = y;
      i = i + 1; j = j - 1;
    }
  } while (!(i > j));
  if (l < j)  sort(l, j, whichlist);
  if (i < r)  sort(i, r, whichlist);
}

void quicksort(byte whichlist, integer lo, integer hi)

{     /*QuickSort*/;
  sort(lo,hi, whichlist);
}

void scandir()
{
 pathstr nix;
 namestr name;
 untyped_file f;
 ednahead eh;
 array<1,4,char> dna_type;

;
 nums[files]=0;
 findfirst("*.asg",archive+hidden+readonly,s);

 while (doserror==0) 
 {;
  fsplit(s.name,nix,name,nix);
  nums[files] += 1;
  lists[files][nums[files]]=lowstr(name);

  assign(f,s.name);
  reset(f,1);
  seek(f,11);
  blockread(f,dna_type,4);

  if (dna_type=="Avvy") 
  {;     /* A DNA256 file. */
   descs[nums[files]]="* Saved by Avaricius!";
  } else
  {;     /* EDNA-based files. */
   if (dna_type=="EDNA") 
   {;
    seek(f,177);
    blockread(f,eh,sizeof(eh));

     if (eh.revision!=2) 
      descs[nums[files]]="* Unknown EDNA type!";
     else
     {;

      if (eh.number!=2) 
       descs[nums[files]]=string("* Saved by ")+eh.shortname+'!';
      else
      {;     /* Well... everything seems to have gone OK! */
       descs[nums[files]]=eh.desc;
      }
     }
   } else
    descs[nums[files]]="* Not an Avvy saved game!";
  }
  close(f);
  findnext(s);
 }
 nums[dirs]=0; findfirst("*.*",directory,s);
 while (doserror==0) 
 {;
  if (((s.attr & directory)>0) && ((length(s.name))>1)) 
  {;
   nums[dirs] += 1;
   lists[dirs][nums[dirs]]=lowstr(s.name);
  }
  findnext(s);
 }

 /* Now sort 'em! */

 quicksort ( dirs,1,nums[ dirs]);
 quicksort (files,1,nums[files]);

 where[dirs]=1; where[files]=1;
   top[dirs]=1; top[files]=1;
}

void show_file(integer x,integer y, byte which)
{
 varying_string<58> z;
;
 fillchar(z[1],13,'\40');
 z=lists[files][which]+".asg";
 z[0]='\15'; z=z+descs[which];

 if (descs[which][1]=='*')  /* Can't load these! */
  setcolor(red);
 else
  setcolor(lightcyan);

 outtextxy(x,y,z);
}

void showfiles()
{
    byte fv;
;
 if (loading)  setcolor(11); else setcolor(3);
 if (nums[3]==0) 
 {;
  outtextxy(22,86,"(None here!)");
  return;
 }
 for( fv=0; fv <= 8; fv ++)
  if (where[3]+fv<=nums[3]) 
   show_file(19,87+fv*10,where[3]+fv);
}

void showdirs()
{
    byte fv;
;
 setcolor(11);
 for( fv=0; fv <= 8; fv ++)
  if (where[4]+fv<=nums[4]) 
   outtextxy(497,87+fv*10,string('[')+lists[dirs][fv+where[4]]+']');
}

void show()
{
 byte fv;
 dirstr d; namestr n; extstr e;
;
 setfillstyle(1,1);
 for( fv=1; fv <= 4; fv ++)
  if (fv!=2) 
   { windowtype& with = threewins[fv]; 
    bar(with.x1+1,with.y1+1,with.x2-1,with.y2-1);}
 showfiles();
 showdirs();
 setcolor(7); outtextxy(159,14,current);
}

void blip()
{;
 sound(177); delay(77); nosound;
}

void invert(integer x1,integer y1,integer x2,integer y2)
{
    pointer p,restore; word s;
;
 s=imagesize(x1,y1,x2,y2);
 mark(restore); getmem(p,s);
 getimage(x1,y1,x2,y2,p);
 putimage(x1,y1,p,notput);
 release(restore);
}

void changedrive(char drive)
{
    byte fv;
;
 fv=pos(drive,drives);
 if (fv==0)  {; blip(); return; }
 fv -= 1;
 shadow((fv % drlen)*25+25,(fv / drlen)*19+31,
   (fv % drlen)*25+40,45+(fv / drlen)*19,8,7);
 chdir(string(drive)+':');
 getcurrent(); scandir(); show();
 shadow((fv % drlen)*25+25,(fv / drlen)*19+31,
   (fv % drlen)*25+40,45+(fv / drlen)*19,15,8);
}

void highlight(byte win,byte line)
{;
 switch (win) {
  case 3: invert(16,75+line*10,479,85+line*10); break;
  case 4: invert(491,75+line*10,619,85+line*10); break;
 }
}

void repaint(byte whichwindow)
{
 setfillstyle(1,1);
 { windowtype& with = threewins[whichwindow]; 
  bar(with.x1+1,with.y1+1,with.x2-1,with.y2-1);}
 switch (whichwindow) {
  case file_win: showfiles(); break;
  case subdir_win: showdirs(); break;
 }
 highlight(whichwindow,1);
 top[whichwindow]=where[whichwindow];
}

void fileblit(word xpos,word xlen,word y1,word y2, shortint dir, word ylen)
{
    word fv; byte bit;
;
 for( bit=0; bit <= 3; bit ++)
 {;
  fv=0;
  while (fv<ylen) 
  {;
   port[0x3c4]=2; port[0x3ce]=4; port[0x3c5]=1 << bit; port[0x3cf]=bit;
   move(mem[0xa000*(y1+fv*dir)*80+xpos],mem[0xa000*(y2+fv*dir)*80+xpos],xlen);
   fv += 1;
  }
 }
 bit=getpixel(0,0);
}

void seekthrough(byte whichlist, byte& wherenow, char whatfor)
{
    byte startedat;

 startedat=wherenow;
 do {
  wherenow += 1;
  if (wherenow>nums[whichlist])  wherenow=1;
 } while (!((startedat==wherenow) || (lists[whichlist][wherenow][1]==whatfor)));
 repaint(whichlist);
}

void gotohome(byte whichlist)
{
 where[whichlist]=1;
 repaint(whichlist);
}

void gotoend(byte whichlist)
{
 where[whichlist]=nums[whichlist];
 repaint(whichlist);
}

void pageup(byte whichlist)
{
 if (where[whichlist]>9) 
 {
  where[whichlist] -= 9;
  repaint(whichlist);
 }
}

void pagedown(byte whichlist)
{
 if (where[whichlist]<nums[whichlist]-9) 
 {
  where[whichlist] += 9;
  repaint(whichlist);
 }
}

void subdirparse(string r);

static void movehl(byte which, shortint howmuch)
{;
 highlight(4,where[4]-top[4]+1);
 if (((where[which]+howmuch)>0) && ((where[which]+howmuch)<=(unsigned char)nums[4]))
       where[which]=where[which]+howmuch;
 highlight(4,where[4]-top[4]+1);
}



static void change_dir()
{;
 dusk();
 /*$I-*/ chdir(lists[4][where[4]]);
 /*$I+*/
 if (ioresult!=0)  {; dawn(); blip(); return; }
 where[4]=1; top[4]=1;
 getcurrent(); scandir(); show();
 highlight(4,1);
 dawn();
}

void subdirparse(string r)

{;
 switch (r[1]) {
  case creturn: change_dir(); break;

  case '\0': switch (r[2]) {
       case cup: if (where[4]-top[4]>0)  /* Up */
             movehl(4,-1); /* Within range */
            else if (top[4]>1) 
            {;     /* Outside range- must scroll */
             highlight(4,1);
             top[4] -= 1; where[4] -= 1;
             fileblit(61,18,166,176,-1,80);
             setfillstyle(1,1); bar(490,85,630,95); setcolor(11);
             outtextxy(497,87,string('[')+lists[dirs][where[4]]+']');
             highlight(4,1);
            }
            break;
       case cdown:
            if (where[4]-top[4]<8)    /* Down */
             movehl(4,1);
            else if (top[4]+8<nums[4]) 
            {;
             highlight(4,9);
             top[4] += 1; where[4] += 1;
             fileblit(60,18,97,87,1,80);
             setfillstyle(1,1); bar(490,165,630,175); setcolor(11);
             outtextxy(497,167,string('[')+lists[dirs][where[4]]+']');
             highlight(4,9);
            }
            break;
       case chome: gotohome(4); break;
       case cend: gotoend(4); break;
       case cpgup: pageup(4); break;
       case cpgdn: pagedown(4); break;
       case c_ao: change_dir(); break;
      }
      break;
   default: seekthrough(4,where[4],lowchar(r[1]));
 }
}

void fileinfo(byte which);


static void display(integer y, string left,string right)
{;
 y=17+y*12;
 settextjustify(2,1); setcolor(11); outtextxy(315,y,left);
 settextjustify(0,1); setcolor(15); outtextxy(325,y,right);
}

void fileinfo(byte which)
 /* This gives information on the file whose name is in lists[files,which]. */
{
 ednahead eh;
 untyped_file f;
 varying_string<4> os;
 char r;

;

 /* Firstly, we must check whether or not it's an Avalot file. This is easily
   done, since the descriptions of all others always begin with a star. */

 if ((descs[which][1]=='*') || (descs[which][1]=='(')) 
 {;     /* it is. */
  blip(); /* Naaaarghh! */
  return;
 }

 /* Anyway... it wasn't. */

 assign(f,lists[files][which]+".asg");
 reset(f,1);
 seek(f,177);
 blockread(f,eh,sizeof(eh));
 close(f);

 /* We now hold its EDNA record. */

 setfillstyle(1,1); bar(2,2,637,197); /* Interesting information coming up! */

 {;
  display(2,"Saved by:", eh.game);
  display(3,"version:", eh.verstr);

/*  display(4,'under', os);*/

  display(6,"Saved on ",strf(eh.d)+'-'+strf(eh.m)+'-'+strf(eh.y));

  display(9,"No. of times saved:",strf(eh.saves));

  display(11,"Money:",eh.money);
  display(12,"Score:",strf(eh.points));
 }

 shbox(500,177,650,200,"Press any key...");
 r=readkey();

 setfillstyle(1,1); bar(2,2,637,197);
}

void filer_help()
 /* This gives general help. */
{
 char r;
;
 outtextxy(100,100,"Just general help here.");
 shbox(500,177,650,200,"Press any key...");
 r=readkey();

 setfillstyle(1,1); bar(2,2,637,197);
}

void wipe()
 /* This allows you to delete files. */
{
 char r;
;
 outtextxy(100,100,"Are you sure you want to delete \"foo.bar\"?");
 shbox(500,177,650,200,"[Y/N]");
 r=readkey();

 setfillstyle(1,1); bar(2,2,637,197);
}

void filesparse(string r);

static void movehl1(byte which, shortint howmuch)
{;
 highlight(3,where[3]-top[3]+1);
 if (((where[which]+howmuch)>0) && ((where[which]+howmuch)<=(unsigned char)nums[3]))
       where[which]=where[which]+howmuch;
 highlight(3,where[3]-top[3]+1);
}



static boolean selected_file()
{boolean selected_file_result;
;
 if (descs[where[file_win]][1]=='*') 
 {
  blip();
  selected_file_result=false;
 } else
 {
  filename=lists[file_win][where[file_win]];
  filefound=true;
  selected_file_result=true;
 }
return selected_file_result;
}

void filesparse(string r)

{;
 switch (r[1]) {
  case creturn: if (selected_file())  return; break;
  case '\0': switch (r[2]) {
       case cup: if (where[3]-top[3]>0)  /* Up */
             movehl1(3,-1); /* Within range */
            else if (top[3]>1) 
            {;     /* Outside range- must scroll */
             highlight(3,1);
             top[3] -= 1; where[3] -= 1;
             fileblit(1,59,166,176,-1,80);
             setfillstyle(1,1); bar( 15,85,480,95);
             show_file( 19,87,where[3]);
             highlight(3,1);
            }
            break;
       case cdown: if (where[3]-top[3]<8)  /* Down */
             movehl1(3,1);
            else if (top[3]+8<nums[3]) 
            {;
             highlight(3,9);
             top[3] += 1; where[3] += 1;
             fileblit(1,59,97,87,1,80);
             setfillstyle(1,1); bar( 15,165,480,175);
             show_file( 19,167,where[3]);
             highlight(3,9);
            }
            break;
       case c_ai: fileinfo(where[3]); break; /* alt-I: information. */
       case c_ah:case c_f1: filer_help(); break; /* alt-I: information. */
       case chome: gotohome(3); break;
       case cend: gotoend(3); break;
       case cpgup: pageup(3); break;
       case cpgdn: pagedown(3); break;
       case c_ao: if (selected_file())  return; break;
      }
      break;
  default: seekthrough(3,where[3],lowchar(r[1]));
 }
}

string playaround();

static void changewin(byte i)
{;
 switch (nowwin) {
  case 3:case 4: highlight(nowwin,where[nowwin]-top[nowwin]+1); break;
 }
 setcolor(3); { windowtype& with = threewins[nowwin];  box(with.x1,with.y1,with.x2,with.y2,with.title);}
 nowwin=i;
 if (nowwin<1)  nowwin=4; if (nowwin>4)  nowwin=1;
 switch (nowwin) {
  case 3:case 4: highlight(nowwin,where[nowwin]-top[nowwin]+1); break;
 }
}

string playaround()
{
    char r,r2;
string playaround_result;
;
 filefound=false; dawn();

 do {
  setcolor(14); { windowtype& with = threewins[nowwin];  box(with.x1,with.y1,with.x2,with.y2,with.title);}
  r=readkey();
  switch (r) {
   case ctab: changewin(nowwin+1); break;
   case cescape: {;
             playaround_result="";
             return playaround_result;
            }
            break;
   case '\0': {; /* parse extd keystroke */
        r2=readkey();
        switch (r2) {
         case cs_tab: changewin(nowwin-1); break;
         case c_an: changewin(1); break;
         case c_ad: changewin(2); break;
         case c_af: changewin(3); break;
         case c_as: changewin(4); break;
         case c_ac: {;
                playaround_result="";
                return playaround_result;
               }
               break;
         default:
          switch (nowwin) {
           case 3: filesparse(string('\0')+r2); break;
           case 4: subdirparse(string('\0')+r2); break;
          }
         }
        }
        break;
  default:
   {;     /* Pass keystroke to current window */
    switch (nowwin) {
     case 2: changedrive(upcase(r)); break;
     case 4: subdirparse(r); break;
     case 3: filesparse(r); break;
     default: blip();
    }
   }

  }

  if (filefound) 
  {;
   dusk();
   playaround_result=filename;
   return playaround_result;
  }
 } while (!false);
return playaround_result;
}

void do_filer()
{
    pathstr p;
void do_filer_result;
;
 loading=true;
 setup();
 scandir();
 show(); show_drives();
 p=playaround();
 if (p!="")  p=fexpand(p+".ASG");
 do_filer_result=p;
return do_filer_result;
}

int main(int argc, const char* argv[])
{pio_initialize(argc, argv);
;
 filename=do_filer();
 closegraph();
 if (filename=="") 
  output << "*** CANCELLED! ***" << NL;
 else
  output << "Selected: " << filename << NL;
 input >> NL;
return EXIT_SUCCESS;
}

} // End of namespace Avalanche.