/***
    *     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.collection.ampache;
  
  import java.io.IOException;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.xml.sax.SAXException;
  
  import sk.baka.ambient.activity.AmpacheClientBean;
  import sk.baka.ambient.collection.CategoryEnum;
  import sk.baka.ambient.collection.CategoryItem;
  import sk.baka.ambient.collection.CollectionException;
  import sk.baka.ambient.collection.CollectionUtils;
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.IDynamicPlaylistTrackProvider;
  import sk.baka.ambient.collection.Statistics;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.playlist.Random;
  
  /***
   * Wraps Ampache as a collection.
   * 
   * @author Martin Vysny
   */
  public final class AmpacheCollection implements ICollection {
  	public List<TrackMetadataBean> findTracks(Map<CategoryEnum, String> criteria) throws CollectionException {
  		if (criteria.isEmpty()) {
  			throw new IllegalArgumentException("Empty criteria");
  		}
  		final String firstValue = criteria.values().iterator().next();
  		try {
  			connect();
  			// temporary implementation until the new Ampache API is
  			// implemented.
  			return client.searchTracks(firstValue);
  		} catch (Exception e) {
  			throw new CollectionException(e);
  		}
  	}
  
  	private volatile AmpacheClient client;
  	/***
  	 * The user, may be <code>null</code>
  	 */
  	private volatile String user;
  	/***
  	 * Password.
  	 */
  	private volatile String password;
  
  	/***
  	 * Creates new wrapper.
  	 * 
  	 * @param client
  	 *            client instance, may not be connected.
  	 * @param user
  	 *            The user, may be <code>null</code>
  	 * @param password
  	 *            password.
  	 */
  	public AmpacheCollection(final AmpacheClient client, final String user,
  			final String password) {
  		this.client = client;
  		this.user = user;
  		this.password = password;
  	}
  
  	/***
  	 * Reinitializes this object with new username and password. Connection is
  	 * performed lazily. Reset is performed only when host, user or password was
  	 * changed.
  	 * 
  	 * @param bean
  	 *            the client data.
  	 */
  	public void reset(final AmpacheClientBean bean) {
  		final String url = bean.getURL();
  		if ((client == null) || !MiscUtils.nullEquals(url, client.serverURL)) {
 			client = new AmpacheClient(url);
 			connected = false;
 		}
 		if (!MiscUtils.nullEquals(this.password, bean.password)
 				|| !MiscUtils.nullEquals(this.user, bean.username)) {
 			this.user = bean.username;
 			this.password = bean.password;
 			connected = false;
 		}
 	}
 
 	/***
 	 * If <code>true</code> then the client is connected.
 	 */
 	private volatile boolean connected = false;
 
 	private AmpacheInfo connect() throws AmpacheException, IOException,
 			SAXException {
 		if (!connected) {
 			final AmpacheInfo result = client.connect(user, password);
 			connected = true;
 			return result;
 		}
 		return client.getInfo();
 	}
 
 	@SuppressWarnings("incomplete-switch")
 	public List<CategoryItem> getCategoryList(final CategoryEnum request,
 			final CategoryItem context, final String substring,
 			final boolean sortByYear) throws CollectionException {
 		try {
 			connect();
 			final String id = context == null ? null : (String) context.id;
 			List<CategoryItem> result = null;
 			switch (request) {
 			case Album: {
 				if (context == null) {
 					result = client.getAlbums(substring);
 				} else if (context.category == CategoryEnum.Genre) {
 					result = client.getGenreAlbums(id, substring);
 				} else if (context.category == CategoryEnum.Artist) {
 					result = client.getArtistAlbums(id, substring);
 				}
 			}
 				break;
 			case Artist: {
 				if (context == null) {
 					result = client.getArtists(substring);
 				} else if (context.category == CategoryEnum.Genre) {
 					result = client.getGenreArtists(id, substring);
 				}
 			}
 				break;
 			case Genre: {
 				if (context == null) {
 					result = client.getGenres(substring);
 				}
 			}
 				break;
 			}
 			if (result == null) {
 				throw new IllegalArgumentException(
 						"Unsupported category search from "
 								+ (context == null ? "null" : context.category)
 								+ " to " + request);
 			}
 			if (sortByYear) {
 				CollectionUtils.sortByYearKey(result);
 			} else {
 				CollectionUtils.sortByKey(result);
 			}
 			return result;
 		} catch (Exception ex) {
 			throw new CollectionException(ex);
 		}
 	}
 
 	public boolean isLocal() {
 		return false;
 	}
 
 	public List<TrackMetadataBean> getTracks(CategoryItem context)
 			throws CollectionException {
 		final List<TrackMetadataBean> result;
 		try {
 			connect();
 			switch (context.category) {
 			case Genre:
 				result = client.getGenreSongs((String) context.id);
 				break;
 			case Album:
 				result = client.getAlbumSongs((String) context.id);
 				break;
 			case Artist:
 				result = client.getArtistSongs((String) context.id);
 				break;
 			default:
 				throw new IllegalArgumentException("Cannot return tracks for "
 						+ context.category);
 			}
 		} catch (Exception ex) {
 			throw new CollectionException(ex);
 		}
 		return result;
 	}
 
 	public List<TrackMetadataBean> findTracks(String substring)
 			throws CollectionException {
 		try {
 			connect();
 			return client.searchTracks(substring);
 		} catch (Exception ex) {
 			throw new CollectionException(ex);
 		}
 	}
 
 	public String getName() {
 		return "Ampache";
 	}
 
 	public Statistics getStatistics() throws CollectionException {
 		try {
 			connect();
 		} catch (Exception e) {
 			throw new CollectionException(e);
 		}
 		final Statistics result = new Statistics();
 		result.albums = client.getInfo().albums;
 		result.artists = client.getInfo().artists;
 		result.tracks = client.getInfo().songs;
 		return result;
 	}
 
 	public CategoryItem deserializeItem(String serializedItem) {
 		return new CategoryItem(serializedItem, null, null,
 				CategoryEnum.Origin, -1, -1);
 	}
 
 	public String serializeItem(CategoryItem item) {
 		return (String) item.id;
 	}
 
 	public IDynamicPlaylistTrackProvider newTrackProvider(final Random random) {
 		return null;
 	}
 
 	public Map<String, String> fixLocations(Collection<String> locations)
 			throws CollectionException {
 		if (locations.isEmpty()) {
 			throw new IllegalArgumentException("locations is empty");
 		}
 		// try to reconnect and obtain a new token
 		final String token;
 		try {
 			connected = false;
 			token = connect().token;
 		} catch (Exception e) {
 			throw new CollectionException("Failed to connect: "
 					+ e.getMessage(), e);
 		}
 		// okay. replace all ?sid= (or ?auth= in case of our embedded server)
 		final Map<String, String> result = new HashMap<String, String>();
 		for (final String loc : locations) {
 			final String fixedLoc = fixLoc(loc, token);
 			result.put(loc, fixedLoc);
 		}
 		return result;
 	}
 
 	private String fixLoc(String loc, String token) {
 		int oldTokenStart = loc.indexOf("?sid=");
 		if (oldTokenStart >= 0) {
 			oldTokenStart += "?sid=".length();
 		} else {
 			oldTokenStart = loc.indexOf("?auth=");
 			if (oldTokenStart >= 0) {
 				oldTokenStart += "?auth=".length();
 			}
 		}
 		if (oldTokenStart < 0) {
 			return loc;
 		}
 		int oldTokenEnd = oldTokenStart;
 		for (; oldTokenEnd < loc.length(); oldTokenEnd++) {
 			if (loc.charAt(oldTokenEnd) == '&') {
 				break;
 			}
 		}
 		if (oldTokenEnd == oldTokenStart) {
 			return loc;
 		}
 		return loc.substring(0, oldTokenStart) + token
 				+ loc.substring(oldTokenEnd);
 	}
 
 	public boolean supportsLocationFix() {
 		return true;
 	}
 }