#include <iostream.h>
#include <fstream.h>
#include <strstream.h>
#include "CPstring.h"
#include "pixmap.h"
#include <ctype.h>            // for tolower
#include <stdlib.h>           // for atoi
#include "directory.h"
#include "vector.h"
#include <unistd.h>


// skeleton driver program for bitmap program
// Owen Astrachan for CPS 08
// written: 11/3/93
// revised: 11/28/94
// revised: 04/13/95
//
// rewritten for CPS 100E, fall 1995
// revised: 9/25/1995 (matrix and vector classes used)
//          temporary file used to drive system call of xv
//

enum Operation {invert,vertical,horizontal,expand,enhance};

// prototypes for Do functions

void DoLoad(Pixmap &);
void DoSave(const Pixmap &);
void DoCompress(const Pixmap &);
void DoOperation(Pixmap &, Operation);
void DoDisplay(const Pixmap &);
void DoQuit();

// array of choices/operations
// these should match up so that Choices[k] is character for Operations[k]
// numOps is the number of entries in Choices (and in Operations)

char Choices [] = {
    'l','s','c','d','i','v','h','e','x','?','q'
};

string Operations [] = {
    "(l)oad an image (bitmap/grayscale/compressed)",
    "(s)ave an image (bitmap/grayscale)",
    "(c)ompress and save (run-length encoding)",
    "(d)isplay current image (using xv)",
    "(i)nvert image",
    "(v)ertical reflect (along vertical axis)",
    "(h)orizontal reflect (horizontal axis)",
    "(e)nhance (median filter)",
    "e(x)pand and image",
    "(?) help (print menu)",
    "(q)uit program"
};

const int numOps = sizeof(Choices)/sizeof(char);
const int QUIT_CHAR = 'q';

void
PrintMenu()
{
    int k;
    for(k=0; k < numOps; k++)
    {
	cout << " " << Operations[k] << endl;
    }
}

main()
{
    string s;
    char ch = '?';      // initialize to something
    Pixmap pix;
    
    do
    {
	PrintMenu();
	cout << endl << "enter choice ";
	getline(cin,s);
	if (s != "")              // something read
	{
	    ch = tolower(s[0]);	  // first char of command
	}
	switch(ch)
	{
	  case 'l': DoLoad(pix);
		    break;
       case 's': DoSave(pix);
		    break;
	  case 'c': DoCompress(pix);
		    break;
	  case 'i': DoOperation(pix,invert);
		    break;
	  case 'v': DoOperation(pix,vertical);
		    break;
	  case 'h': DoOperation(pix,horizontal);
		    break;
	  case 'e': DoOperation(pix,enhance);
		    break;
	  case 'x': DoOperation(pix,expand);
		    break;		    
	  case '?': PrintMenu();
		    break;
          case 'd': DoDisplay(pix);
		    break;
	  case 'q': DoQuit();
		    break;
	  default:
	    cout << "unknown option: " << ch << ", re-enter" << endl;
	    break;
	}
    } while (ch != QUIT_CHAR);
}


bool IsBitmapFile(const string & name)
// postcondition: returns true if name contains a legal image suffix
//                e.g., pbm, pgm cbm ...
{
   //legal suffixes
   static string suffixTable[] = {".pbm", ".pgm", ".cbm"};
   const int MAX_TABLE = sizeof suffixTable / sizeof suffixTable[0];
   int k;

   for (k=0; k<MAX_TABLE;k++)
   {
       // if the "suffix is contained in the file name return true
       if (name.Contains(suffixTable[k]))
       {
	   return true;
       }
   }
   return false;
}
		   
	  


void LoadDirectory (const string & base,
		    Vector<string> & files, int & numFiles, int startIndex)
//
// precondition: store new elments in files starting with index startIndex     
// Postconditions: numFiles contains the number of file entries added to
//                 the Vector of strings (files)
//                 files[startIndex]...files[startIndex+numFiles-1] have
//                 been added

{
    DirStream dir;		//Directory stream
    DirEntry entry;		//Directory entry
    int nIndex = startIndex;	//current index in vector
    string name;		//name of current file
    
    numFiles = 0;
    dir.open(base);
    
    if (! dir)
    {
	cerr << "could not open directory " << base << endl;	
	return;
    }
    
    for(dir.First(); !dir.IsDone(); dir.Next())
    {
	if (! dir.Current().IsDir())
	{
	    name = dir.Current().Name();
	    if (IsBitmapFile(name))
	    {
		if (nIndex >= files.Length())
		{
		    files.SetSize(files.Length()*2); // grow the vector
		}
		files[nIndex] = name;
		numFiles++;  
		nIndex++;
	    }
	}
    }
}


void DoLoad(Pixmap & pix)
// postcondition: pix loaded from user-specified file
{
    string s;
    const string base = "/u/o/l/ola/data/images";  // images directory
    const string curr = ".";       // current directory
    
    int numBase = 0;		//# of files in images directory
    int numCurr = 0;		//# of files in current directory
    int numFiles = 0;
    Vector<string> files(20);
    
    LoadDirectory(base, files, numBase, 0);
    LoadDirectory(curr, files, numCurr, numBase);
    numFiles = numBase + numCurr;
    
    cout << " ****** files *****" << endl << endl;
    int k;
    for(k=0; k < numFiles; k++)
    {
	cout << "(" << k << ") " << files[k] << endl;
    }
    
    cout << endl << "enter choice> ";
    getline(cin,s);
    
    k = atoi(s);
    
    if (0 <= k && k < numFiles)
    {
	string filename;
	if (k<numBase)
	{
	    filename = base + "/" + files[k];
	}
	else
	{
	    filename = curr + "/" + files[k];
	}
	ifstream input(filename);	// open an input stream
	if (! input.fail())
	{
	    pix.Read(input);
	}
	else
	{
	    cerr << "could not open file " << filename << endl;
	}
    }
    else
    {
	cerr << "illegal choice: " << k << endl;
    }
}

void DoSave(const Pixmap & pix)
// postcondition: pix saved to user-specified file
{
    string s;
    cout << "name of file ";
    getline(cin,s);
    
    ofstream output(s);		// open output file stream
    
    if (output.good() )
    {
	pix.Write(output);	    
    }
    else
    {
	cerr << "cannot create file " << s << endl;
    }
}

void DoCompress(const Pixmap & pix)
{
    cout << "not implemented " << endl;
}

void DoEnhance(Pixmap & pix)
{
    string enhance;
    cout << "enhance how much ";
    getline(cin,enhance);
    pix.Enhance(atoi(enhance));
}

void DoExpand(Pixmap & pix)
{
    string row,col;
    cout << "expand rows by (2--5) ";
    getline(cin,row);
    cout << "epxand cols by (2--5) ";
    getline(cin,col);
    pix.Expand(atoi(row),atoi(col));
}

void DoOperation(Pixmap & pix, Operation op)
{
    switch (op)
    {
      case invert:
	pix.Invert();
	break;
      case vertical:
	pix.VertReflect();
	break;
      case horizontal:
	pix.HorizReflect();
	break;
      case enhance:
	DoEnhance(pix);
	break;
      case expand:
	DoExpand(pix);
	break;
      default:
	cerr << "bad value to DoOperation: " << op << endl;
    }
}

void DoQuit()
{
    cout << "thanks for graphing" << endl;
}


void DoDisplay(const Pixmap & pix)
{
    
    string tempName = "/tmp/pixTemp" + itoa(getpid()); // temporary name
    
    string runxv = "xv " + tempName; // use xv on tempfile
    ofstream output;
    output.open(tempName);
    if (! output)
    {
	cout << "could not open temp. file, Display terminated" << endl;
	return;
    }
    cout << endl << "press 'q' with the mouse cursor in the image" << endl;
    cout << "to get back to usepix" << endl;
    pix.Write(output);		// write temp file
    system(runxv);		// use xv
    output.close();		// close filestream
    system("/bin/rm -f " + tempName); // remove temp file
    
    cout << endl;
}