import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.util.Scanner;

/**

* A text based version of the IHuffViewer. Used as an alternative to the

* GUIHuffViewer. All functionality from the GUI version of the viewer is

* replicated here.

*

* @author Mike Scott

*/

public class TextHuffViewer implements IHuffViewer {

private IHuffProcessor myModel;

private File myInputFile;

private boolean myForce;

private int myHeaderFormat;

private final Scanner KEY;

private static String HUFF_SUFFIX = ".hf";

private static String UNHUFF_SUFFIX = ".unhf";

/**

* Create a text based interface Huffman viewer. After this constructor is

* called the setModel method must be called and then the start method must

* be called to allow a user to interact with the viewer.

*/

public TextHuffViewer() {

myHeaderFormat = IHuffConstants.STORE_COUNTS;

KEY = new Scanner(System.in);

}

/**

* Associates this view with the given model. The GUI (or other View) will

* attach itself to the model so that communication between the view and the

* model as well as <em>vice versa</em> is supported.

*

* @param model is the model for this view

*/

public void setModel(IHuffProcessor model) {

myModel = model;

myModel.setViewer(this);

}

/**

* To be called by model/client code to display strings in the View.

* Displays string on a single line. Call multiple times show several

* strings.

*

* @param s is string to be displayed

*/

public void update(String s) {

System.out.println(s);

}

/**

* Display a text message in the view. Messages are informational in

* purpose.

*

* @param s is the message displayed

*/

public void showMessage(String s) {

System.out.println("MESSAGE");

System.out.println(s);

System.out.println();

}

/**

* Show a message indicating an error. The user must respond with a return

* before proceeding.

*

* @param s is the error-message displayed

*/

public void showError(String s) {

System.out.println("ERROR");

System.out.println(s);

System.out.println();

System.out.println("Presss enter to continue: ");

KEY.nextLine();

System.out.println();

}

// The menu main choices for the user.

private static enum MenuChoices {

UNUSED, FILE_OP, FLIP_COMPRESSION_STATUS, FLIP_HEADER_CHOICE;

}

/**

* Start processing Huffman operation requests. Do so until the user stops.

*/

public void start() {

int choice = 1;

while (keepGoing(choice)) {

System.out.println("STATUS");

System.out.print("Current Header format for compressing: ");

if (this.myHeaderFormat == IHuffConstants.STORE_COUNTS) {

System.out.println("Standard COUNT Format");

} else {

System.out.println("Standard TREE Format");

}

System.out.println("Current force compression status: " + this.myForce);

System.out.println();

System.out.println("OPTIONS");

System.out.println("1. File operations. ");

System.out.println("2. Flip Force Compression status.");

System.out.println("3. Flip Header format.");

System.out.println("4. Quit (or any value other than 1, 2, or 3)");

System.out.println();

choice = processChoice();

}

System.out.println("Ending program.");

}

/*

* Return true if the choice is options 1 (file operation), 2 (flip force

* status), or 3 (flip header choice). False for anything else.

*/

private boolean keepGoing(int choice) {

return MenuChoices.FILE_OP.ordinal() <= choice

&& choice <= MenuChoices.FLIP_HEADER_CHOICE.ordinal();

}

/*

* Get the next choice from the user and process it.

*/

private int processChoice() {

System.out.print("Enter menu option: ");

String input = KEY.nextLine();

System.out.println();

if (input.length() == 0) {

input = "4";

}

int firstCharValue = input.charAt(0) - '0';

// If it is 1, 2, or 3 and process choice

if (keepGoing(firstCharValue)) {

if (firstCharValue == MenuChoices.FILE_OP.ordinal()) {

processFileRequest();

} else if (firstCharValue == MenuChoices.FLIP_COMPRESSION_STATUS.ordinal()) {

myForce = !myForce;

} else {

// must be a 3, flip the header format

myHeaderFormat =

(myHeaderFormat == IHuffConstants.STORE_COUNTS) ? IHuffConstants.STORE_TREE

: IHuffConstants.STORE_COUNTS;

}

}

return firstCharValue;

}

/*

* Process a file request. These are the important operations for the

* program.

*/

private void processFileRequest() {

// We assume the user shall enter a valid int for the menu choice.

// Future work will be to make this more robust.

System.out.println("FILE OPERATION");

System.out.println("1. Preprocess a file to determine if compression is possible.");

System.out.println("2. Compress a file. Results in a call to preprocessing as well.");

System.out.println("3. Uncompress a file.");

System.out.println();

System.out.print("Enter file operation option: ");

int choice = KEY.nextInt();

KEY.nextLine();

System.out.println();

if (choice == 1) {

setMyFile("preprocess only"); // Gross! An array for choices?

preprocess();

} else if (choice == 2) {

setMyFile("compress");

compress();

} else {

setMyFile("decompress");

uncompress();

}

}

/*

* Process a file to determine the amount of bits saved if it were to be

* compressed.

*/

private void preprocess() {

showMessage("Begining preprocessing of " + myInputFile + ".");

ByteArrayInputStream inputStream = getFastByteReader(myInputFile);

try {

int saved = myModel.preprocessCompress(inputStream, myHeaderFormat);

showMessage("save(d): " + saved + " bits");

} catch (IOException e) {

showError("Error / Exception while reading file for preprocessing.");

e.printStackTrace();

}

}

// Compress a file based on user input.

private void compress() {

preprocess();

String newName = myInputFile.getName() + HUFF_SUFFIX;

newName = setNewFileName("compressed", newName);

if (newName == null) {

showError("Trouble with file setting path of output file. Exiting compress.");

} else {

try {

FileOutputStream out = new FileOutputStream(new File(newName));

ByteArrayInputStream inputStream = getFastByteReader(myInputFile);

myModel.compress(inputStream, out, myForce);

} catch (IOException e) {

showError("Problem while trying to compress file.");

e.printStackTrace();

}

}

myInputFile = null; // must enter new file after this.

}

/*

* Set the name of the output file. This can be for

* a compressed or uncompressed file. The parameter

* type specifies if the output file is for compression

* or uncompression. Allow the user to alter the name

* of the output file if they wish.

*/

private String setNewFileName(String type, String newName) {

System.out.println("Proposed name for " + type + " file: " + newName);

System.out.print("Enter c to change " + type + " file name. "

+ "Anything else to keep proposed name: ");

String response = KEY.nextLine();

System.out.println();

if (response.length() == 1 && response.charAt(0) == 'c') {

System.out.print("Enter name for " + type + " file: ");

newName = KEY.nextLine();

System.out.println();

}

newName = setFullPath(newName);

if (newName == null) {

showError("Trouble with file setting path of output file.");

}

return newName;

}

/*

* Set the newName to have the full path of the original file.

* In other words, the compressed file will be placed in the same

* directory as the file we are compressing.

* Return the resulting path or null if a an IOException occurs

* while determining the canonical path of the input file.

*/

private String setFullPath(String newName) {

String result = null;

try {

String path = myInputFile.getCanonicalPath();

int pos = path.lastIndexOf(myInputFile.getName());

result = path.substring(0, pos) + newName;

} catch (IOException e) {

showError("Problem in trying to obtain Canoical Path of file " + newName);

e.printStackTrace();

}

return result;

}

/*

* Uncompress a file. Ask the user for the input file

* and the name for the uncompressed output file.

* Then uncompress the file using the current processor.

*/

private void uncompress() {

showMessage("Uncompressing file based on user choice.");

String name = myInputFile.getName();

String uncompressedName = name;

if (name.endsWith(HUFF_SUFFIX)) {

uncompressedName =

name.substring(0, name.length() - HUFF_SUFFIX.length()) + UNHUFF_SUFFIX;

} else {

uncompressedName = name + UNHUFF_SUFFIX;

}

uncompressedName = setNewFileName("compressed", uncompressedName);

try {

FileOutputStream out = new FileOutputStream(new File(uncompressedName));

ByteArrayInputStream inputStream = getFastByteReader(myInputFile);

myModel.uncompress(inputStream, out);

} catch (IOException e) {

showError("Problem while trying to uncompress file.");

e.printStackTrace();

}

}

// Set myFile based on user input.

private void setMyFile(String prompt) {

System.out.print("Enter name (full or relative path) of file to " + prompt + ": ");

String path = KEY.nextLine();

System.out.println();

myInputFile = new File(path);

}

// Get a ByteArrayInputStream to read from the given file.

private ByteArrayInputStream getFastByteReader(File f) {

try {

FileChannel channel = new FileInputStream(f).getChannel();

ByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

byte[] barray = new byte[buffer.limit()];

if (barray.length != channel.size()) {

showError(String.format("Reading %s error: lengths differ %d %ld\n", f.getName(),

barray.length, channel.size()));

}

buffer.get(barray);

return new ByteArrayInputStream(barray);

} catch (IOException e) {

e.printStackTrace();

}

return null;

}

}