// BriefcaseModel.java. 11/4/2023.

		//c.setProgressBarMaximum(1);
		//c.setProgressBarVisible(true);
		//c.setProgressBarString("Folder Paths: " + c.getStrFolderName());
		//c.setProgressBarValue(0);

package testbriefcasemcv;

import java.io.File;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Vector;

import fwgeneral.DateTimeAux;
import fwgeneral.FileObjectRead;
import fwgeneral.FileObjectWrite;
import fwgeneral.FileUtility;
import fwgeneral.swing.JWindowUtility;

public class BriefcaseModel {
	
	BriefcaseController c;
	
	Vector<String> vecCreateFolders = new Vector<String>();
	Vector<String> vecDeleteFolders = new Vector<String>();
	Vector<String[]> vecDeleteFiles = new Vector<String[]>();
	Vector<String[]> vecCopyFiles = new Vector<String[]>();
	
	String strFromRootFolderPath = "";
	String[] strFromFolderNames = new String[0];
	String[][] strFromFileNameExts = new String[0][];
	long[][] lFromFileTimes = new long[0][];
	
	String strToRootFolderPath = "";
	String[] strToFolderNames = new String[0];
	String[][] strToFileNameExts = new String[0][];
	long[][] lToFileTimes = new long[0][];
	
	boolean bUpdateBriefcaseFolderInfoOK = true;
	
	int iProgressBarMax = 0;
	int iProgressBarValue = 0;

	public BriefcaseModel(BriefcaseController c) {
		this.c = c;
	}
	
	protected void checkForFolderRootDirectory() {
		String strBriefcaseRootDirectory = c.getBriefcaseRootFolderPath();
		if (!FileUtility.isDirectory(strBriefcaseRootDirectory)) {
			FileUtility.createDirectory(strBriefcaseRootDirectory);
			return;
		}
	}
	
	protected void createNewBriefcaseFolder() {
		// Called from Selected File Paths in View via Model
		// (in the seledtedFilePaths method)
		c.setbFromHardDrive(true);
		String strNewHardDriveFolderPath = c.constructHardDriveSubFolderPath();
		
		// Check to be certain file is on the hard drive
		if (!FileUtility.isDirectory(strNewHardDriveFolderPath)) {
			JWindowUtility.reportMessage("createNewBriefcaseFolder", strNewHardDriveFolderPath + " is NOT a directory.");
			strNewHardDriveFolderPath = null;
			return;
		}
		
		getHDInfo();
		getUSBInfo();
		c.setProgressBarMaximum(strFromFileNameExts.length);

		constructFolderAndFileVectors();
		
	}
	
	protected void removeExistingBriefcaseFolder() {
		// Called from buttonRemoveFolderFired() in View via Model
		
		getUSBInfo();
		
		// Set up progress bar
		c.setProgressBarVisible(true);

		c.setupScreen();
		c.initializeButtons();
		
	}
	
	// Not needed
	//protected void setupUpdate() {
	//	readAndSetFileInfo();
	//	constructFolderAndFileVectors();
	//}

	protected void readAndSetFileInfo() {
		// Called from View via Controller
		getHDInfo();
		getUSBInfo();
	}
	
	private void getHDInfo() {
		// Called from readAndSetFileInfo

		// Hard drive info: Get all folders names on HardDrive
		DirectoryTree folderTree = new DirectoryTree();
		String[] strHardDriveFolderNames = folderTree.getFolderNames(c.constructHardDriveSubFolderPath());
		String strFolderPath = FileUtility.constructDirectory(FileUtility.getDocumentsPath(),
				strHardDriveFolderNames[0]);
		
		c.setProgressBarMaximum(strHardDriveFolderNames.length);
		int iProgressBar = 0;
		c.setProgressBarVisible(true);


		// Hard drive info: Get all folders names on HardDrive
		folderTree = new DirectoryTree();
		strHardDriveFolderNames = folderTree.getFolderNames(c.constructHardDriveSubFolderPath());
		// Alphabetize the HardDrive folder names
		replace(strHardDriveFolderNames);
		sortArray(strHardDriveFolderNames);

		// Initialize subfolder file names.exts and dates
		String[][] strHardDriveFileNameExts = new String[strHardDriveFolderNames.length][];
		long[][] lHardDriveFileTimes = new long[strHardDriveFolderNames.length][];

		for (int i = 0; i < strHardDriveFolderNames.length; i++) {
			// Construct directory path to strHardDriveFolderNames[i]
			//if(strHardDriveFolderNames[i].endsWith(File.separator)) {
			//	strHardDriveFolderNames[i] =
			//			strHardDriveFolderNames[i].substring(0, strHardDriveFolderNames[i].length() -1);
			//}
			strFolderPath = FileUtility.constructDirectory(FileUtility.getDocumentsPath(), strHardDriveFolderNames[i]);

			// Get all files.extensions in HardDrive folder i
			String[] strFileNameExts = FileUtility.getListOfFiles(strFolderPath);

			strFileNameExts = eliminateDotUnderScoreFiles(strFileNameExts);

			if (strFileNameExts.length > 0) {
				strHardDriveFileNameExts[i] = strFileNameExts;
			} else {
				strHardDriveFileNameExts[i] = new String[0];
			}

			// Alphabetize strHardDriveFileNameExts[i]
			sortArray(strHardDriveFileNameExts[i]);

			// Initialize lHardDriveFileTimes[i]
			lHardDriveFileTimes[i] = new long[strHardDriveFileNameExts[i].length];
			// Get the last modified date for all files in strHardDriveFileNameExts[i]
			for (int j = 0; j < strHardDriveFileNameExts[i].length; j++) {
				sortArray(strHardDriveFileNameExts[i]);
				String strFilePath = FileUtility.constructFilePath(strFolderPath, strHardDriveFileNameExts[i][j]);
				lHardDriveFileTimes[i][j] = FileUtility.lastModified(strFilePath);
			}
			
			iProgressBar++;
			c.setProgressBarValue(iProgressBar);

		}
		
		c.setProgressBarVisible(false);
		
		// Set from and to directories, file name.exts, and file dates
		if(c.isbFromHardDrive()) {
			strFromRootFolderPath = c.getHardDriveRootFolderPath();
			strFromFolderNames = strHardDriveFolderNames;
			strFromFileNameExts = strHardDriveFileNameExts;
			lFromFileTimes = lHardDriveFileTimes;
		} else {
			strToRootFolderPath = c.getHardDriveRootFolderPath();
			strToFolderNames = strHardDriveFolderNames;
			strToFileNameExts = strHardDriveFileNameExts;
			lToFileTimes = lHardDriveFileTimes;
		}


	}
	
	private String[] eliminateDotUnderScoreFiles(String[] strFileNameExts) {
		// Called from getHDInfo to fix a Windows problem
		Vector<String> vecTemp = new Vector<String>(0);
		for(int i=0; i<strFileNameExts.length;i++) {
			if(!strFileNameExts[i].startsWith("._")) {
				vecTemp.addElement(strFileNameExts[i]);
			}
		}
		
		String[] strTemp = new String[vecTemp.size()];
		for(int i=0; i<vecTemp.size(); i++) {
			strTemp[i] = vecTemp.elementAt(i);
		}
		
		return strTemp;
	}
	
	private void getUSBInfo() {
		// Called from createNewBriefcaseFolder amd removeExistingBriefcaseFolder
		
		// Construct path to the Briefcase info file
		String strBriefcaseInfoFilePath = FileUtility.constructFilePath(c.constructBriefcaseSubFolderPath(),
				c.getBriefcaseFolderInfoFileNameExt());

		// Read BriefInfo file first line containing folder names (both main and sub
		// folders)
		// Initialize Briefcase Info folders
		String[] strBriefcaseFolderNames = new String[0];
		String[][] strBriefcaseFileNameExts = new String[3][0];
		long[][] lBriefcaseFileTimes = new long[3][0];

		if (FileUtility.isFile(strBriefcaseInfoFilePath)) {
			try {
				FileObjectRead fileRead = new FileObjectRead(strBriefcaseInfoFilePath);

				strBriefcaseFolderNames = (String[]) fileRead.readObject();
				replace(strBriefcaseFolderNames);

				strBriefcaseFileNameExts = new String[strBriefcaseFolderNames.length][];
				lBriefcaseFileTimes = new long[strBriefcaseFolderNames.length][];
				for (int i = 0; i < strBriefcaseFolderNames.length; i++) {
					strBriefcaseFileNameExts[i] = (String[]) fileRead.readObject();
					lBriefcaseFileTimes[i] = (long[]) fileRead.readObject();
				}
				fileRead.close();
			} catch (Exception e) {
				JWindowUtility.reportException("BriefcaseInfo.getBriefcaseInfo(...)", e);
			}
		}
		
		// Set To directories, file name.exts, and file dates
		//**** Is this needed because it was done in getHDInfo; that is, is it redundant
		if(c.isbFromHardDrive()) {
			strToRootFolderPath = c.getBriefcaseRootFolderPath();
			strToFolderNames = strBriefcaseFolderNames;
			strToFileNameExts = strBriefcaseFileNameExts;
			lToFileTimes = lBriefcaseFileTimes;
		} else {
			strFromRootFolderPath = c.getBriefcaseRootFolderPath();
			strFromFolderNames = strBriefcaseFolderNames;
			strFromFileNameExts = strBriefcaseFileNameExts;
			lFromFileTimes = lBriefcaseFileTimes;
		}

	}

	protected void constructFolderAndFileVectors() {
		// Called from Selected File Paths in View via Model
		// (in the seledtedFilePaths method)
		
		if(c.getStrFolderName() != null) {
			c.writeDirInfoToTextArea("Briefcase", c.getStrFolderName());
			constructFolderVectors();
		}

	}
	
	private void constructFolderVectors() {
		// Called from constructFolder and FileVectors
		
		// There are three possibilities:
		//		Folder in both From and To Briefcases: Check files in From and To Briefcases
		//			by calling constructFileVectors(int iFromFolder, int iToFolder)
		//		Folder only in From folder: Create From folder in To Briefcase
		//			and copy From folder files to To briefcase
		//		Folder only in To folder: Delete To folder in To Briefcase
		//		Folder only in From folder: Create From folder in To Briefcase
		//			and delete To folder files in To briefcase
		
		boolean[] bToFilesInFromBriefcase = new boolean[strToFolderNames.length];

		// Loop over From folders in From briefcase
		loopOverFromFolders: for (int iFromFolder = 0; iFromFolder < strFromFolderNames.length; iFromFolder++) {

			// Loop over To folders in To briefcase
			for (int iToFolder = 0; iToFolder < strToFolderNames.length; iToFolder++) {
				// Update number of observations and progress bar
				iProgressBarValue++;
				c.setProgressBarValue(iProgressBarValue);
				
				if (strFromFolderNames[iFromFolder].equals(strToFolderNames[iToFolder])) {
					// Folder found both Briefcases
					bToFilesInFromBriefcase[iToFolder] = true;
					
					// Check files in both From and To folders
					constructFileVectors(iFromFolder, iToFolder);
					
					// Loop to next From folder
					continue loopOverFromFolders;
				}
				
			}
			// From folder found - To folder not found: Create From folder
			c.writeDirInfoToTextArea("Create", strFromFolderNames[iFromFolder]);
			this.vecCreateFolders.addElement(strFromFolderNames[iFromFolder]);

			//    Copy From folder files
			for (int iFromFile = 0; iFromFile < strFromFileNameExts[iFromFolder].length; iFromFile++) {
				c.writeFileInfoToTextArea("Copy", strFromFolderNames[iFromFolder],
						strFromFileNameExts[iFromFolder][iFromFile], lFromFileTimes[iFromFolder][iFromFile]);
				String[] strFolderFile = { strFromFolderNames[iFromFolder],
						strFromFileNameExts[iFromFolder][iFromFile] };
				vecCopyFiles.addElement(strFolderFile);
			}
		}

		for(int iToFolder=0; iToFolder<bToFilesInFromBriefcase.length; iToFolder++) {
			if(!bToFilesInFromBriefcase[iToFolder]) {
				// Folder only in To briefcase: Delete To folder and its files only in To briefcase
				c.writeDirInfoToTextArea("Delete", strToFolderNames[iToFolder]);
				vecDeleteFolders.addElement(strToFolderNames[iToFolder]);
				
				// Delete all files only in To folder
				for(int iToFile= 0; iToFile<strToFileNameExts[iToFolder].length; iToFile++) {
					c.writeFileInfoToTextArea("Delete", strToFolderNames[iToFolder], strToFileNameExts[iToFolder][iToFile],
							lToFileTimes[iToFolder][iToFile]);
					String[] strFolderFile = {strToFolderNames[iToFolder], strToFileNameExts[iToFolder][iToFile]};
					vecDeleteFiles.addElement(strFolderFile);
				}
			}
		}
		
		/*
		int NbrOfTotalOperations = vecDeleteFolders.size() + vecDeleteFiles.size() +
				vecCreateFolders.size() + vecCopyFiles.size();
		c.setiNbrOfTotalOperations(NbrOfTotalOperations);
		*/

	}
	
	private void constructFileVectors(int iFromFolder, int iToFolder) {
		// Called from constructFolderVectors
		boolean[] bToFilesInFromBriefcase = new boolean[strToFileNameExts[iToFolder].length];
		
		// Loop over files in From folder
		loopNextFromFile: for(int iFromFile=0; iFromFile<strFromFileNameExts[iFromFolder].length; iFromFile++) {

			// Loop over files in To folder
			for(int iToFile=0; iToFile<strToFileNameExts[iToFolder].length; iToFile++) {
				// Update number of observations and progress bar
				iProgressBarValue++;
				c.setProgressBarValue(iProgressBarValue);
				
				// Calculate new progress bar maximum for the Update method
				iProgressBarMax += strFromFileNameExts[iFromFolder].length;
				
				if(strFromFileNameExts[iFromFolder][iFromFile].equals(strToFileNameExts[iToFolder][iToFile]) ) {
					// To file in From folder
					bToFilesInFromBriefcase[iToFile] = true;
					
					// Check To files times
					if(lFromFileTimes[iFromFolder][iFromFile] != lToFileTimes[iToFolder][iToFile]) {
						// Files have different times
						c.writeFileInfoToTextArea(
								"Update", strFromFolderNames[iFromFolder], strFromFileNameExts[iFromFolder][iFromFile],
								lFromFileTimes[iFromFolder][iFromFile], lToFileTimes[iToFolder][iToFile]);
						String[] strFolderFile = {strFromFolderNames[iFromFolder], strFromFileNameExts[iFromFolder][iFromFile]};
						// Copy file from From folder to To folder
						vecCopyFiles.addElement(strFolderFile);
					}
					
					// Loop to next From file
					continue loopNextFromFile;
				}
			}
			
			// File only in From folder: Copy From file to To folder
			c.writeFileInfoToTextArea(
					"Copy", strFromFolderNames[iFromFolder], strFromFileNameExts[iFromFolder][iFromFile],
					lFromFileTimes[iFromFolder][iFromFile]);
			String[] strFolderFile = {strFromFolderNames[iFromFolder], strFromFileNameExts[iFromFolder][iFromFile]};
			vecCopyFiles.addElement(strFolderFile);
		}
		
		// Check files in To folder
		for(int iToFile=0; iToFile<bToFilesInFromBriefcase.length; iToFile++) {
			if(!bToFilesInFromBriefcase[iToFile]) {
				// File in To folder but not From folder: Delete file in To folder
				c.writeFileInfoToTextArea("Delete", strToFolderNames[iToFolder], 
						strToFileNameExts[iToFolder][iToFile], lToFileTimes[iToFolder][iToFile]);
				String[] strFolderFile = {strToFolderNames[iToFolder], strToFileNameExts[iToFolder][iToFile]};
				vecDeleteFiles.addElement(strFolderFile);
			}
		}
	}

	// The updateFolder() method does the actual work: Copying and deleting.
	protected void updateFoldersAndFiles() {
		// Called from View via Controller
		
		int iProgressBarMax = vecDeleteFolders.size() + vecDeleteFiles.size() +
				vecCreateFolders.size() + vecCopyFiles.size();
		if(iProgressBarMax == 0) {
			return;
		}
		
		// Initialize progress bar max for files
		c.setProgressBarMaximum(iProgressBarMax);
		iProgressBarValue = 0;
		c.setProgressBarVisible(true);
		
		// Delete files.
		String strBriefcaseRootFolderPath = c.getBriefcaseRootFolderPath();
			
		for (int i = 0; i < vecDeleteFiles.size(); i++) {
			String[] strFolderFile = vecDeleteFiles.elementAt(i);
			String strFolderSubPath = strFolderFile[0];
			String strFileNameExt = strFolderFile[1];
			
			String strToFolderPath = FileUtility.constructDirectory(strBriefcaseRootFolderPath, strFolderSubPath);
			String strToFilePath = FileUtility.constructFilePath(strToFolderPath, strFileNameExt);
			
			// File already deleted if its directory was deleted
			if(FileUtility.isFile(strToFilePath)) {
				FileUtility.deleteFile(strToFilePath);
			}
			
			// Update progress bar
			iProgressBarValue++;
			c.setProgressBarValue(iProgressBarValue);
		}

		// Delete directories; this is done in "reverse order"
		for (int i = vecDeleteFolders.size() - 1; i >= 0; i--) {
			String strSubFolderPath = vecDeleteFolders.elementAt(i);
			String strFolderPath = FileUtility.constructDirectory(strBriefcaseRootFolderPath, strSubFolderPath);
			FileUtility.deleteDirectory(strFolderPath);
			
			// Update progress bar
			iProgressBarValue++;
			c.setProgressBarValue(iProgressBarValue);
		}

		// Create directories
		// NB: vecCreateFolders.elementAt(0) is already created
		for (int i = 0; i < vecCreateFolders.size(); i++) {
			String strSubFolderPath = vecCreateFolders.elementAt(i);
			String strFolderPath = FileUtility.constructDirectory(strToRootFolderPath, strSubFolderPath);
			FileUtility.createDirectory(strFolderPath);
			
			// Update progress bar
			iProgressBarValue++;
			c.setProgressBarValue(iProgressBarValue);

		}

		// Copy files
		for (int i = 0; i < vecCopyFiles.size(); i++) {
			String[] strFolderFile = vecCopyFiles.elementAt(i);
			String strFolderSubPath = strFolderFile[0];
			String strFileNameExt = strFolderFile[1];
			
			String strFromFolderPath = FileUtility.constructDirectory(strFromRootFolderPath, strFolderSubPath);
			String strToFolderPath = FileUtility.constructDirectory(strToRootFolderPath, strFolderSubPath);
			
			String strFromFilePath = FileUtility.constructFilePath(strFromFolderPath, strFileNameExt);
			String strToFilePath = FileUtility.constructFilePath(strToFolderPath, strFileNameExt);
			try {
				FileUtility.copyFile(strFromFilePath, strToFilePath);
			} catch (Exception e) {
				JWindowUtility.reportException("updateFoldersAndFiles()", e);
				e.printStackTrace();
			}
			
			// Update progress bar
			// Update progress bar
			iProgressBarValue++;
			c.setProgressBarValue(iProgressBarValue);
		}

		if (bUpdateBriefcaseFolderInfoOK) {
			if (c.isbFromHardDrive()) {
				c.setProgressBarValue(iProgressBarValue);
			}
		} else {
			JWindowUtility.reportMessage("updateFolder()",
					"As a consequence of the encountered error(s), this update was aborted.");
			bUpdateBriefcaseFolderInfoOK = true;
		}
		
		// If To directory is the USB is being update, copy From information to To folder
		if(c.isbFromHardDrive()) {
			// Create from folder or subfolder information file path
			String strBriefcaseSubFolderPath = c.constructBriefcaseSubFolderPath();
			updateBriefcaseFolderInfoFile(strBriefcaseSubFolderPath);
		}
		
		// Set subfolders to the current time: Needed to initial From and To buttons
		long lCurrentTime = DateTimeAux.getTime();
		String strHardDrivesubFolderPath = c.constructHardDriveSubFolderPath();
		FileUtility.setLastModified(strHardDrivesubFolderPath, lCurrentTime);
		String strSubFolderPath = c.constructBriefcaseSubFolderPath();
		FileUtility.setLastModified(strSubFolderPath, lCurrentTime);
		
		// Hide progress bar
		c.setProgressBarVisible(false);
		
		// Clear vectors
		vecDeleteFolders.clear();
		vecDeleteFiles.clear();
		vecCreateFolders.clear();
		vecCopyFiles.clear();
	}
	
	protected void checkFolderTimes() {
		// Called from View via Controller
		
		// Needed to initialize From and To folder buttons
		String strBriefcaseName = c.constructBriefcaseSubFolderPath();
		String strHardDriveName = c.constructHardDriveSubFolderPath();

		long lBriefcaseTime = FileUtility.lastModified(strBriefcaseName);
		long lHardDriveTime = FileUtility.lastModified(strHardDriveName);
		
		if(lHardDriveTime >= lBriefcaseTime) {
			c.setbFromHardDriveMoreRecent(true);
			c.setbFromHardDrive(true);
		} else {
			c.setbFromHardDriveMoreRecent(false);
			c.setbFromHardDrive(false);
		}
	}
	
	// Alphabetizes 
	private void sortArray(String[] strArray) {
		char cBackSlash = '\\';
		char cSlash = '/';
		
		// Replace separation char with slash
		for(int i=0; i<strArray.length; i++) {
				strArray[i] = strArray[i].replace(cBackSlash, cSlash);
		}
		
		// Alphabetize sortArray
	    List<String> list = Arrays.asList(strArray);
	    Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

	    // Replace slash with separation char
		for(int i=0; i<strArray.length; i++) {
				strArray[i] = strArray[i].replace(cSlash, File.separatorChar);
		}
	}
	
	private void replace(String[] strArray) {
		char cBackSlash = '\\';
		char cSlash = '/';

		for(int i=0; i<strArray.length; i++) {
			strArray[i] = strArray[i].replace(cBackSlash,  cSlash);
			strArray[i] = strArray[i].replace(cSlash,  File.separatorChar);
		}
	}
	
	// Update the folder information files
	private void updateBriefcaseFolderInfoFile(String strBriefcaseSubFolderPath) {
		// Called from updateFoldersAndFiles
		
		if(strFromFolderNames.length == 0) {
			// (All) folders being removed
			return;
		}
		
		String strBriefcaseFolderInfoFilePath =
				FileUtility.constructFilePath(
						strBriefcaseSubFolderPath, c.getBriefcaseFolderInfoFileNameExt());
		try {
			// Only update folder info file if writing to file
			if (c.isbFromHardDrive()) {
				FileObjectWrite filewrite = new FileObjectWrite(strBriefcaseFolderInfoFilePath);

				String strNewHardDriveFolder =
						FileUtility.constructDirectory(c.getHardDriveRootFolderPath(), c.getStrFolderName());
				
				// Write folder and subfolders
				// DirectoryTree,... is called here because strHardDriveFolderNames is not a global
				DirectoryTree directoryTree = new DirectoryTree();
				String[] strHardDriveFolderNames = directoryTree.getFolderNames(strNewHardDriveFolder);
				sortArray(strHardDriveFolderNames);
				for(int i=0; i<strHardDriveFolderNames.length; i++) {
					if(strHardDriveFolderNames[i].endsWith(File.separator)) {
						strHardDriveFolderNames[i] =
								strHardDriveFolderNames[i].substring(0, strHardDriveFolderNames[i].length() -1);
					}
				}
				filewrite.writeObject(strHardDriveFolderNames);
				
				//long[] lHardDriveFolderTimes = new long[strHardDriveFolderNames.length];
				//for(int i=0; i<lHardDriveFolderTimes.length; i++) {
				//	String strFolderPath = FileUtility.constructDirectory(
				//			strNewHardDriveFolder, strHardDriveFolderNames[i]);
					//lHardDriveFolderTimes[i] = FileUtility.lastModified(strFolderPath);
				//}
				//filewrite.writeObject(lHardDriveFolderTimes);
				
				// Write file name.exts and file dates
				for (int i = 0; i < strHardDriveFolderNames.length; i++) {
					sortArray(strFromFileNameExts[i]);
					filewrite.writeObject(strFromFileNameExts[i]);
					filewrite.writeObject(lFromFileTimes[i]);
				}
				
				filewrite.flush();
				filewrite.close();
				
			}
		} catch (Exception ex) {
			JWindowUtility.reportException("setBriefcaseFolderInfo", ex);
		}

	}
	
	// Needed by BriefcaseView to display folder names in BriefcaseView.
	protected String[] getBriefcaseFolderNames() {
		// Called from setupScreen and buttonCheckAllFired via Controller
		
		String strBriefcaseMasterInfoFileFolder = c.getBriefcaseRootFolderPath();
		
		//String strBriefcaseMasterInfoFileFolder =
		//		FileUtility.constructDirectory(c.getBriefcaseVolumePath(), c.getBriefcaseRootFolderName());
		String[] strBriefcaseFileNames = FileUtility.getListOfDirectories(strBriefcaseMasterInfoFileFolder);
		for(int i=0; i<strBriefcaseFileNames.length; i++) {
			strBriefcaseFileNames[i] = File.separator + strBriefcaseFileNames[i] + File.separator;
		}
		
		return strBriefcaseFileNames;

	}

}

class DirectoryTree {
	// Called by 
	String strMainFolderPath;
	Vector<String> vectorFolderPaths = new Vector<String>(0);
	
	public String[] getFolderNames(String strMainFolderPath) {
		// Call by getHDInfo in Model (this file)
		String[] strFolderPaths = getFolderPaths(strMainFolderPath);
		
		String[] strFolderNames = new String[strFolderPaths.length];
		for(int i=0; i<strFolderNames.length; i++) {
			strFolderNames[i] = strFolderPaths[i].substring(FileUtility.getDocumentsPath().length());
		}
		
		return strFolderNames;
	}
	
	private String[] getFolderPaths(String strMainFolderPath) {
		vectorFolderPaths.clear();
		
		vectorFolderPaths.addElement(strMainFolderPath.substring(0, strMainFolderPath.length() - 1));

		addSubDirectoriesToVector(strMainFolderPath);
		
		String[] strFolderPaths = new String[vectorFolderPaths.size()];
		for(int i=0; i<vectorFolderPaths.size(); i++) {
			strFolderPaths[i] = vectorFolderPaths.elementAt(i);
		}
		
		return strFolderPaths;
	}
	
	
	private void addSubDirectoriesToVector(String strMainDirectory) {
		// Add all subdirectories in strMainDirectory to 

		// Create main directory file object
		File fileMainSubDirectories = new File(strMainDirectory);

		if (fileMainSubDirectories.exists() && fileMainSubDirectories.isDirectory()) {
			// Call recursive method
			recursiveDirectories(fileMainSubDirectories.listFiles(), 0, 0);
		}

	}
	
	private void recursiveDirectories(File[] fileDirectoryArray, int iIndex, int iLevel) {
		if (iIndex != fileDirectoryArray.length) {
			
			// Subdirectories
			if (fileDirectoryArray[iIndex].isDirectory()) {
				vectorFolderPaths.addElement(fileDirectoryArray[iIndex].getPath());

				// Recursion to include all subdirectories
				recursiveDirectories(fileDirectoryArray[iIndex].listFiles(), 0, iLevel + 1);
			}

			// Recursion for main directory
			recursiveDirectories(fileDirectoryArray, ++iIndex, iLevel);
		}
	}
	
}