/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    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 3 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, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.activity.main;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.EnumMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.Callable;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.I18n;
  import sk.baka.ambient.R;
  import sk.baka.ambient.ZoomEnum;
  import sk.baka.ambient.collection.CategoryEnum;
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.local.MediaStoreCollection;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.library.LibraryUtils;
  import sk.baka.ambient.playlist.Parsers;
  import sk.baka.ambient.views.ViewUtils;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  import android.content.DialogInterface;
  import android.util.Log;
  import android.view.View;
  import android.widget.TextView;
  
  /***
   * The file browser.
   * 
   * @author Martin Vysny
   */
  public final class FileBrowserController extends AbstractListController {
  
  	/***
  	 * The actions to display on the Task switcher.
  	 */
  	private final List<ActionsEnum> actions = Collections
  			.unmodifiableList(Arrays.asList(ActionsEnum.Back,
  					ActionsEnum.GoToRoot, ActionsEnum.Refresh, ActionsEnum.DeleteSelected));
  
  	/***
  	 * @param mainActivity
  	 * @param playlistView
  	 *            the playlist view.
  	 */
  	public FileBrowserController(final MainActivity mainActivity,
  			final GesturesListView playlistView) {
  		super(R.id.filebrowser, R.id.filebrowserView, mainActivity);
  		// register the drag'n'drop target.
  		listView.dragDropViews.clear();
  		listView.dragDropViews.add(playlistView);
  		update(Interval.EMPTY);
  		initButtonBar(R.id.filebrowserButtons, actions);
  	}
  
  	@Override
  	public void destroy() {
  		listView.dragDropViews.clear();
  		super.destroy();
  	}
  
  	@Override
  	protected void onAction(ActionsEnum action) {
  		if (action == ActionsEnum.Back) {
  			goBack();
  		}
  		if (action == ActionsEnum.DeleteSelected) {
  			deleteSelected();
  		}
  		if (action == ActionsEnum.GoToRoot) {
  			currentDirectory = new File("/");
  			update(Interval.EMPTY);
  		}
  		super.onAction(action);
  	}
 
 	private void deleteSelected() {
 		if (!currentDirectory.getAbsolutePath().startsWith("/sdcard")) {
 			return;
 		}
 		final Interval highlight = listView.getHighlight();
 		if (highlight.isEmpty()) {
 			return;
 		}
 		final File[] filesToDelete = new File[highlight.length];
 		System.arraycopy(currentDirectoryContents, highlight.start,
 				filesToDelete, 0, highlight.length);
 		final String name = app.getString(R.string.deleteSelectedFiles);
 		final Callable<Void> del = new Callable<Void>() {
 			public Void call() throws IOException {
 				try {
 					delete(filesToDelete, true);
 				} finally {
 					AmbientApplication.getHandler().post(new Runnable() {
 						public void run() {
 							update(Interval.EMPTY);
 						}
 					});
 				}
 				return null;
 			}
 
 			private void delete(File[] toDelete, final boolean topLevel)
 					throws IOException {
 				if (toDelete == null) {
 					return;
 				}
 				int progress = 0;
 				for (File f : toDelete) {
 					if (topLevel) {
 						app.getBackgroundTasks().backgroundTask(0, name,
 								progress++, toDelete.length);
 					}
 					if (f.isDirectory()) {
 						delete(f.listFiles(), false);
 					}
 					if (!f.delete()) {
 						throw new IOException("Cannot delete: "
 								+ f.getAbsolutePath());
 					}
 				}
 			}
 		};
 		// ask for permission to delete files
 		final int[] count = countFiles(filesToDelete, null);
 		ViewUtils.showYesNoDialog(mainActivity, MiscUtils.format(
 				R.string.deleteXFiles, I18n.newDir(count[0]), I18n
 						.newFiles(count[1])),
 				new DialogInterface.OnClickListener() {
 					public void onClick(DialogInterface dialog, int which) {
 						app.getBackgroundTasks().schedule(del, del.getClass(),
 								false, name);
 					}
 				});
 	}
 
 	public void itemActivated(final int index, final Object model) {
 		activateFile(index);
 	}
 
 	@Override
 	public void removeItems(Interval remove) {
 		goBack();
 	}
 
 	private void goBack() {
 		final String currentDir = currentDirectory.getName();
 		currentDirectory = currentDirectory.getParentFile();
 		if (currentDirectory == null) {
 			currentDirectory = new File("/");
 		}
 		update(Interval.EMPTY);
 		// try to scroll to the directory we just left.
 		final int currentDirIndex = listView.getModel().getModel().indexOf(
 				"[" + currentDir + "]");
 		if (currentDirIndex >= 0) {
 			this.listView.setSelection(currentDirIndex);
 		}
 	}
 
 	/***
 	 * Activates given file - either enters the directory or appends music file
 	 * to the playlist.
 	 * 
 	 * @param index
 	 *            the index of the file to activate, indexes
 	 *            {@link #currentDirectoryContents}.
 	 */
 	private void activateFile(int index) {
 		final File file = currentDirectoryContents[index];
 		if (file.isDirectory()) {
 			currentDirectory = file;
 			update(Interval.EMPTY);
 		} else {
 			final TrackMetadataBean track = LibraryUtils.getTag(file
 					.getAbsolutePath());
 			app.getPlaylist().add(track);
 		}
 	}
 
 	/***
 	 * The directory being displayed.
 	 */
 	private File currentDirectory;
 	{
 		currentDirectory = new File("/sdcard");
 		if (!currentDirectory.exists()) {
 			currentDirectory = new File("/");
 		}
 	}
 
 	/***
 	 * Current directory contents.
 	 */
 	private File[] currentDirectoryContents;
 
 	@Override
 	protected void recomputeListItems() {
 		// update the directory panel
 		final TextView dir = (TextView) mainView
 				.findViewById(R.id.filebrowserPath);
 		dir.setText(currentDirectory.getAbsolutePath());
 		// update the file list
 		currentDirectoryContents = currentDirectory
 				.listFiles(LibraryUtils.MUSIC_FILTER);
 		if (currentDirectoryContents == null) {
 			currentDirectoryContents = new File[0];
 		}
 		Arrays.sort(currentDirectoryContents, fileSort);
 		listView.getModel().getModel().clear();
 		for (int i = 0; i < currentDirectoryContents.length; i++) {
 			String name = currentDirectoryContents[i].getName();
 			if (currentDirectoryContents[i].isDirectory()) {
 				name = "[" + name + "]";
 			}
 			listView.getModel().getModel().add(name);
 		}
 	}
 
 	public void update(GesturesListView listView, View itemView, int index,
 			Object model) {
 		final TextView view = (TextView) itemView;
 		if (listView.getHighlight().contains(index)) {
 			view.setBackgroundColor(highlightColor);
 		} else {
 			view.setBackgroundColor(0);
 		}
 		view.setText((String) model);
 	}
 
 	/***
 	 * Sorts files: directories first, then sorts files by the file name.
 	 */
 	private final static Comparator<File> fileSort = new Comparator<File>() {
 		public int compare(File object1, File object2) {
 			final boolean bothFilesOrDirs = (object1.isDirectory() == object2
 					.isDirectory());
 			if (!bothFilesOrDirs) {
 				return object1.isDirectory() ? -1 : 1;
 			}
 			return object1.getName().compareTo(object2.getName());
 		}
 	};
 
 	@Override
 	public synchronized List<TrackMetadataBean> computeTracks(Interval highlight) {
 		final File[] filesToAdd = new File[highlight.length];
 		System.arraycopy(currentDirectoryContents, highlight.start, filesToAdd,
 				0, highlight.length);
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 		scan(filesToAdd, result);
 		if (Thread.currentThread().isInterrupted()) {
 			return null;
 		}
 		return result;
 	}
 
 	/***
 	 * Scans given directories/files recursively for music files.
 	 * 
 	 * @param dirs
 	 *            the directories/files to scan.
 	 * @param result
 	 *            put all track meta here.
 	 */
 	private void scan(final File[] dirs, List<TrackMetadataBean> result) {
 		if (dirs == null)
 			return;
 		for (final File file : dirs) {
 			Thread.yield();
 			if (Thread.currentThread().isInterrupted())
 				return;
 			if (file.isDirectory()) {
 				final File[] children = file
 						.listFiles(LibraryUtils.MUSIC_FILTER);
 				Arrays.sort(children, fileSort);
 				scan(children, result);
 			} else {
 				addFile(result, file);
 			}
 		}
 	}
 
 	private void addFile(List<TrackMetadataBean> result, final File file) {
 		if (LibraryUtils.PLAYLIST_FILTER.accept(file)) {
 			try {
 				final List<TrackMetadataBean> playlist = Parsers.parse(file);
 				if (Parsers.hasMetadata(file.getName())) {
 					findInCollection(playlist);
 				}
 				result.addAll(playlist);
 			} catch (final Exception ex) {
 				app.error(getClass(), true, mainActivity
 						.getString(R.string.failedToParsePlaylist), ex);
 			}
 		} else {
 			final TrackMetadataBean tag = LibraryUtils.getTag(file
 					.getAbsolutePath());
 			result.add(tag);
 		}
 	}
 
 	/***
 	 * Finds tracks in given playlist in the collection and fixes locations.
 	 * 
 	 * @param playlist
 	 *            the playlist to post-process.
 	 */
 	private void findInCollection(List<TrackMetadataBean> playlist) {
 		final ICollection coll = new MediaStoreCollection(mainActivity
 				.getContentResolver());
 		for (int i = 0; i < playlist.size(); i++) {
 			final TrackMetadataBean track = playlist.get(i);
 			if (track.isLocal() && new File(track.getLocation()).exists()) {
 				continue;
 			}
 			if (MiscUtils.isEmptyOrWhitespace(track.getAlbum())
 					|| MiscUtils.isEmptyOrWhitespace(track.getTitle())) {
 				continue;
 			}
 			// find the track in the collection
 			final Map<CategoryEnum, String> criteria = new EnumMap<CategoryEnum, String>(
 					CategoryEnum.class);
 			criteria.put(CategoryEnum.Album, track.getAlbum().trim());
 			criteria.put(CategoryEnum.Title, track.getTitle().trim());
 			try {
 				final List<TrackMetadataBean> tracks = coll
 						.findTracks(criteria);
 				if (tracks.size() != 1) {
 					continue;
 				}
 				playlist.set(i, tracks.get(0));
 			} catch (final Exception e) {
 				Log.e(FileBrowserController.class.getSimpleName(),
 						"Failed to find a track", e);
 			}
 		}
 	}
 
 	@Override
 	public boolean isComputeTracksLong(Interval interval) {
 		return true;
 	}
 
 	@Override
 	public boolean isComputeTracksOnlineOp(Interval interval) {
 		return false;
 	}
 
 	/***
 	 * Counts files and directories.
 	 * 
 	 * @param f
 	 *            the file list
 	 * @param interval
 	 *            optional interval. If <code>null</code> then entire list is
 	 *            searched.
 	 * @return a pair in format of [directories, files]
 	 */
 	private static int[] countFiles(final File[] f, Interval interval) {
 		int files = 0;
 		int dirs = 0;
 		final Interval _int = interval == null ? new Interval(0, f.length)
 				: interval;
 		for (int i = _int.start; i <= _int.end; i++) {
 			final File file = f[i];
 			if (file.isDirectory()) {
 				dirs++;
 			}
 			if (file.isFile()) {
 				files++;
 			}
 		}
 		return new int[] { dirs, files };
 	}
 	
 	@Override
 	public String getHint(Interval highlight) {
 		final int[] count = countFiles(currentDirectoryContents, highlight);
 		return listView.getResources().getString(R.string.numFiles,
 				I18n.newDir(count[0]), I18n.newFiles(count[1]));
 	}
 
 	@Override
 	public boolean isReadOnly() {
 		return true;
 	}
 
 	@Override
 	public boolean canComputeItems() {
 		return true;
 	}
 
 	@Override
 	protected void performZoom(Map<ZoomEnum, Integer> zoom) {
 		super.performZoom(zoom);
 		initButtonBar(R.id.filebrowserButtons, actions);
 	}
 
 	public String toString(Object model) {
 		// shouldn't be called as strings are shown
 		throw new Error();
 	}
 }