Tools.java

package com.torrenttunes.client.tools;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ObjectNode;
import org.javalite.activejdbc.DB;
import org.javalite.activejdbc.DBException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import spark.Request;
import spark.Response;
import spark.utils.GzipUtils;

import com.frostwire.jlibtorrent.Entry;
import com.frostwire.jlibtorrent.TorrentStatus;
import com.frostwire.jlibtorrent.swig.create_torrent;
import com.frostwire.jlibtorrent.swig.error_code;
import com.frostwire.jlibtorrent.swig.file_storage;
import com.frostwire.jlibtorrent.swig.libtorrent;
import com.google.common.base.Charsets;
import com.google.common.hash.HashCode;
import com.google.common.hash.HashFunction;
import com.google.common.hash.Hashing;
import com.google.common.io.Files;
import com.musicbrainz.mp3.tagger.Tools.Song;

public class Tools {

	static final Logger log = LoggerFactory.getLogger(Tools.class);

	public static final ObjectMapper MAPPER = new ObjectMapper();

	public static final NumberFormat NUMBER_FORMAT = new DecimalFormat("#0.00"); 

	public static final String USER_AGENT = "torrenttunes-client/1.0.0 (https://github.com/tchoulihan/torrenttunes-client)";

	public static final SimpleDateFormat RESPONSE_HEADER_DATE_FORMAT = 
			new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz");

	public static void allowOnlyLocalHeaders(Request req, Response res) {


		log.debug("req ip = " + req.ip());


		//		res.header("Access-Control-Allow-Origin", "http://mozilla.com");
		//		res.header("Access-Control-Allow-Origin", "null");
		//		res.header("Access-Control-Allow-Origin", "*");
		//		res.header("Access-Control-Allow-Credentials", "true");


		if (!isLocalIP(req.ip())) {
			throw new NoSuchElementException("Not a local ip, can't access");
		}
	}

	public static Boolean isLocalIP(String ip) {
		Boolean isLocalIP = (ip.equals("127.0.0.1") || ip.equals("0:0:0:0:0:0:0:1"));
		return isLocalIP;
	}

	public static void allowAllHeaders(Request req, Response res) {
		String origin = req.headers("Origin");
		res.header("Access-Control-Allow-Credentials", "true");
		res.header("Access-Control-Allow-Origin", origin);
		res.header("Content-Encoding", "gzip");


	}


	public static void set15MinuteCache(Request req, Response res) {
		res.header("Cache-Control", "public,max-age=300,s-maxage=900");
		res.header("Last-Modified", RESPONSE_HEADER_DATE_FORMAT.format(DataSources.APP_START_DATE));
	}



	public static void logRequestInfo(Request req) {
		String origin = req.headers("Origin");
		String origin2 = req.headers("origin");
		String host = req.headers("Host");


		log.debug("request host: " + host);
		log.debug("request origin: " + origin);
		log.debug("request origin2: " + origin2);


		//		System.out.println("origin = " + origin);
		//		if (DataSources.ALLOW_ACCESS_ADDRESSES.contains(req.headers("Origin"))) {
		//			res.header("Access-Control-Allow-Origin", origin);
		//		}
		for (String header : req.headers()) {
			log.debug("request header | " + header + " : " + req.headers(header));
		}
		log.debug("request ip = " + req.ip());
		log.debug("request pathInfo = " + req.pathInfo());
		log.debug("request host = " + req.host());
		log.debug("request url = " + req.url());
	}

	public static final Map<String, String> createMapFromAjaxPost(String reqBody) {
		log.debug(reqBody);
		Map<String, String> postMap = new HashMap<String, String>();
		String[] split = reqBody.split("&");
		for (int i = 0; i < split.length; i++) {
			String[] keyValue = split[i].split("=");
			try {
				if (keyValue.length > 1) {
					postMap.put(URLDecoder.decode(keyValue[0], "UTF-8"),URLDecoder.decode(keyValue[1], "UTF-8"));
				}
			} catch (UnsupportedEncodingException |ArrayIndexOutOfBoundsException e) {
				e.printStackTrace();
				throw new NoSuchElementException(e.getMessage());
			}
		}



		return postMap;

	}


	public static FilenameFilter MUSIC_FILE_FILTER = new FilenameFilter() {
		public boolean accept(File dir, String name) {
			return name.endsWith(".mp3");
		}
	};


	public static String sha2FileChecksum(File file) {
		HashCode hc = null;
		try {
			hc = Files.hash(file, Hashing.sha256());
		} catch (IOException e) {
			e.printStackTrace();
		}
		return hc.toString();
	}

	public static void setupDirectories() {
		if (!new File(DataSources.TORRENTS_DIR()).exists()) {
			log.info("Setting up ~/." + DataSources.APP_NAME + " dirs");
			new File(DataSources.HOME_DIR()).mkdirs();
			new File(DataSources.TORRENTS_DIR()).mkdirs();
			new File(DataSources.DEFAULT_MUSIC_STORAGE_PATH()).mkdirs();


		} else {
			log.info("Home directory already exists");
		}
	}

	public static void copyResourcesToHomeDir(Boolean copyAnyway) {

		String foundVersion = "";
		try {
			foundVersion = readFile(DataSources.INSTALLED_VERSION_FILE()).trim();
		} catch (Exception e) {}

		if (copyAnyway || 
				!new File(DataSources.SOURCE_CODE_HOME()).exists() || 
				!foundVersion.equals(DataSources.VERSION)) {


			log.info("Copying resources to  ~/." + DataSources.APP_NAME + " dirs");

			String zipFile = copyJarFileToHome();

			deleteTemporaryJarFile();

			// Unzip it and rename it
			Tools.unzip(new File(zipFile), new File(DataSources.SOURCE_CODE_HOME()));
			new File(DataSources.ZIP_FILE()).renameTo(new File(DataSources.JAR_FILE()));

			// Update the version number
			Tools.writeFile(DataSources.VERSION, DataSources.INSTALLED_VERSION_FILE());

			Tools.installShortcuts();

			WriteMultilingualHTMLFiles.write();

		} else {
			log.info("The source directory already exists");
		}
	}

	private static String copyJarFileToHome() {
		String zipFile = null;
		try {
			if (new File(DataSources.SHADED_JAR_FILE).exists()) {
				java.nio.file.Files.copy(Paths.get(DataSources.SHADED_JAR_FILE), Paths.get(DataSources.ZIP_FILE()), 
						StandardCopyOption.REPLACE_EXISTING);
				zipFile = DataSources.SHADED_JAR_FILE;

			} else if (new File(DataSources.SHADED_JAR_FILE_2()).exists()) {
				java.nio.file.Files.copy(Paths.get(DataSources.SHADED_JAR_FILE_2()), Paths.get(DataSources.ZIP_FILE()),
						StandardCopyOption.REPLACE_EXISTING);
				zipFile = DataSources.SHADED_JAR_FILE_2();
			} else {
				log.info("you need to build the project first");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return zipFile;
	}

	private static void deleteTemporaryJarFile() {
		File jarFile = new File(DataSources.JAR_FILE());
		try {
			File currentJar = new File(Tools.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());
			if (!jarFile.equals(currentJar)) {
				jarFile.delete();
			}


		} catch (URISyntaxException e) {
			e.printStackTrace();
		}
	}

	public static void unzip(File zipfile, File directory) {
		try {
			ZipFile zfile = new ZipFile(zipfile);
			Enumeration<? extends ZipEntry> entries = zfile.entries();
			while (entries.hasMoreElements()) {
				ZipEntry entry = entries.nextElement();
				File file = new File(directory, entry.getName());
				if (entry.isDirectory()) {
					file.mkdirs();
				} else {
					file.getParentFile().mkdirs();
					InputStream in = zfile.getInputStream(entry);
					try {
						copy(in, file);
					} finally {
						in.close();
					}
				}
			}

			zfile.close();


		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private static void copy(InputStream in, File file) throws IOException {
		OutputStream out = new FileOutputStream(file);
		try {
			copy(in, out);
		} finally {
			out.close();
		}
	}

	private static void copy(InputStream in, OutputStream out) throws IOException {
		byte[] buffer = new byte[1024];
		while (true) {
			int readCount = in.read(buffer);
			if (readCount < 0) {
				break;
			}
			out.write(buffer, 0, readCount);
		}
	}

	private static void copy(File file, OutputStream out) throws IOException {
		InputStream in = new FileInputStream(file);
		try {
			copy(in, out);
		} finally {
			in.close();
		}
	}

	public static void runSQLFile(Connection c,File sqlFile) {

		try {
			Statement stmt = null;
			stmt = c.createStatement();
			String sql;

			sql = Files.toString(sqlFile, Charset.defaultCharset());

			stmt.executeUpdate(sql);
			stmt.close();
		} catch (IOException | SQLException e) {
			e.printStackTrace();
		}
	}

	public static final void dbInit() {
		try {
			new DB("ttc").open("org.sqlite.JDBC", "jdbc:sqlite:" + DataSources.DB_FILE(), "root", "p@ssw0rd");
		} catch (DBException e) {
			e.printStackTrace();
			dbClose();
			dbInit();
		}

	}

	public static final void dbClose() {
		new DB("ttc").close();
	}

	public static String constructTrackTorrentFilename(File file, Song song) {



		String artistReleaseSongName = song.getArtist() + " - " + 
				song.getRelease() + " - " + 
				song.getRecording();
		String artistReleaseSongLimitedName = String.format("%1.80s", artistReleaseSongName);

		String fileName = artistReleaseSongLimitedName
				+ " - tt[mbid-" + song.getRecordingMBID().toLowerCase()
				+ "_sha2-" + sha2FileChecksum(file) + "]";

		fileName = fileName.replaceAll("/", "-");


		return fileName;

	}



	public static void uploadFileToTracker(File torrentFile) {


		try {
			HttpClient httpclient = HttpClientBuilder.create().build(); 

			HttpPost httppost = new HttpPost(DataSources.TORRENT_UPLOAD_URL);

			MultipartEntityBuilder builder = MultipartEntityBuilder.create();
			builder.addPart("torrent", new FileBody(torrentFile));
			builder.addPart("test", new StringBody("derp", ContentType.DEFAULT_TEXT));

			HttpEntity entity = builder.build();

			httppost.setEntity(entity);

			HttpResponse response = httpclient.execute(httppost);
			log.debug(response.toString());

		} catch (IOException e) {
			throw new NoSuchElementException("Filename too long.");
		}


	}

	public static String uploadTorrentInfoToTracker(String jsonInfo) {


		String postURL = DataSources.TORRENT_INFO_UPLOAD_URL;

		String message = "";
		try {

			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(30 * 1000).
					build();
			CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build();			


			HttpPost httpPost = new HttpPost(postURL);
			httpPost.setEntity(new StringEntity(jsonInfo, "UTF-8"));



			//			httpPost.setEntity(new StringEntity("L"));

			ResponseHandler<String> handler = new BasicResponseHandler();


			CloseableHttpResponse response = httpClient.execute(httpPost);



			message = handler.handleResponse(response);

			httpClient.close();
		} catch (IOException e) {
			e.printStackTrace();
			throw new NoSuchElementException("Couldn't save the torrent info");
		}

		message = "upload status : " + message;
		log.debug(message);
		return message;
	}





	public static String readFile(String path) {
		String s = null;

		byte[] encoded;
		try {
			encoded = java.nio.file.Files.readAllBytes(Paths.get(path));

			s = new String(encoded, Charset.defaultCharset());
		} catch (IOException e) {
			log.error("file : " + path + " doesn't exist.");
		}
		return s;
	}

	public static String readFile(File file) {
		return readFile(file.getAbsolutePath());
	}

	public static void writeFile(String text, String path) {
		try {
			java.nio.file.Files.write(Paths.get(path), text.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void writeFile(String text, File filePath) {
		writeFile(text, filePath.getAbsolutePath());
	}

	public static Boolean writeFileToResponse(File file, Request req, Response res) {
		return writeFileToResponse(file.getAbsolutePath(), req, res);
	}


	public static Boolean writeFileToResponse(String path, Request req, Response res) {
		try {
			
			OutputStream wrappedOutputStream = GzipUtils.checkAndWrap(req.raw(), 
					res.raw());

			IOUtils.copy(new FileInputStream(new File(path)), wrappedOutputStream);

			wrappedOutputStream.flush();
			wrappedOutputStream.close();
			

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return true;
	}
	
	public static HttpServletResponse writeFileToResponse2(String path, Response res) {

		byte[] encoded;
		try {
			encoded = java.nio.file.Files.readAllBytes(Paths.get(path));


			ServletOutputStream os = res.raw().getOutputStream();
			os.write(encoded);
			os.close();

			return res.raw();

		} catch (IOException e) {
			throw new NoSuchElementException("Couldn't write response from path: " + path);
		}
	}

	public static void uninstall() {

		try {
			FileUtils.deleteDirectory(new File(DataSources.HOME_DIR()));


			Tools.uninstallShortcuts();

			log.info(DataSources.APP_NAME + " uninstalled successfully.");
			System.exit(0);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static JsonNode jsonToNode(String json) {

		try {
			JsonNode root = MAPPER.readTree(json);
			return root;
		} catch (Exception e) {
			log.error("json: " + json);
			e.printStackTrace();
		}
		return null;
	}

	public static String nodeToJson(ObjectNode a) {
		try {
			return Tools.MAPPER.writeValueAsString(a);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String nodeToJsonPretty(JsonNode a) {
		try {
			return Tools.MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(a);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String humanReadableByteCount(long bytes, boolean si) {
		int unit = si ? 1000 : 1024;
		if (bytes < unit) return bytes + " B";
		int exp = (int) (Math.log(bytes) / Math.log(unit));
		String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
		return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
	}

	public static final String httpGetString(String url) {
		String res = "";
		try {
			URL externalURL = new URL(url);

			URLConnection yc = externalURL.openConnection();
			yc.setRequestProperty("User-Agent", USER_AGENT);

			BufferedReader in = new BufferedReader(
					new InputStreamReader(
							yc.getInputStream()));
			String inputLine;

			while ((inputLine = in.readLine()) != null) 
				res+="\n" + inputLine;
			in.close();

			return res;
		} catch(IOException e) {}
		return res;
	}

	public static final byte[] httpGetBytes(String urlString) throws IOException {
		URL url = new URL(urlString);

		URLConnection uc = url.openConnection();
		int len = uc.getContentLength();
		InputStream is = new BufferedInputStream(uc.getInputStream());
		try {
			byte[] data = new byte[len];
			int offset = 0;
			while (offset < len) {
				int read = is.read(data, offset, data.length - offset);
				if (read < 0) {
					break;
				}
				offset += read;
			}
			if (offset < len) {
				throw new IOException(
						String.format("Read %d bytes; expected %d", offset, len));
			}
			return data;
		} finally {
			is.close();
		}
	}


	public static final void httpSaveFile(String urlString, String savePath) throws IOException {
		log.info("url string = " + urlString);

		URL url = new URL(urlString);

		URLConnection uc = url.openConnection();

		InputStream input = uc.getInputStream();
		byte[] buffer = new byte[4096];
		int n = - 1;

		OutputStream output = new FileOutputStream(savePath);
		while ( (n = input.read(buffer)) != -1) {

			output.write(buffer, 0, n);

		}
		output.close();

	}

	public static String httpSimplePost(String seederInfoUpload) {
		String res = "";
		try {
			URL externalURL = new URL(seederInfoUpload);

			URLConnection yc = externalURL.openConnection();

			yc.setRequestProperty("User-Agent", USER_AGENT);

			BufferedReader in = new BufferedReader(
					new InputStreamReader(
							yc.getInputStream()));
			String inputLine;

			while ((inputLine = in.readLine()) != null) 
				res+="\n" + inputLine;
			in.close();

			return res;
		} catch(IOException e) {}
		return res;
	}

	public static void addExternalWebServiceVarToTools() {

		log.info("tools.js = " + DataSources.TOOLS_JS());
		try {
			List<String> lines = java.nio.file.Files.readAllLines(Paths.get(DataSources.TOOLS_JS()));

			String interalServiceLine = "var localSparkService = '" + 
					DataSources.WEB_SERVICE_URL + "';";

			String torrentTunesServiceLine = "var torrentTunesSparkService ='" + 
					DataSources.TORRENTTUNES_URL + "';";

			String externalServiceLine = "var externalSparkService ='" + 
					DataSources.EXTERNAL_URL + "';";

			lines.set(0, interalServiceLine);
			lines.set(1, torrentTunesServiceLine);
			lines.set(2, externalServiceLine);


			java.nio.file.Files.write(Paths.get(DataSources.TOOLS_JS()), lines);
			Files.touch(new File(DataSources.TOOLS_JS()));


		} catch (IOException e) {
			e.printStackTrace();
		}

	}


	public static void openFileWebpage(String urlString) {
		String fileUrlString = "file://" + urlString;
		openWebpage(fileUrlString);
	}

	public static void openWebpage(String uri) {
		log.info("Opening web page: " + uri);

		try {
			DesktopApi.browse(new URI(uri));
		} catch (URISyntaxException e) {
			e.printStackTrace();
		}
	}

	public static Long folderSize(File directory) {
		long length = 0;
		log.info("folder size directory: " + directory);
		Collection<File> files = FileUtils.listFiles(directory, new String[]{".mp3"}, true);
		for (File file : files) {
			length += file.length();
		}
		return length;

	}

	public static void installShortcuts() {

		String osName = System.getProperty("os.name").toLowerCase();

		if (osName.contains("linux")) {
			installLinuxShortcuts();
		} else if (osName.contains("windows")) {
			installWindowsShortcuts();
		} else if (osName.contains("mac")) {
			installMacShortcuts();
		}
	}

	public static void uninstallShortcuts() {

		String osName = System.getProperty("os.name").toLowerCase();

		if (osName.contains("linux")) {
			uninstallLinuxShortcuts();
		} else if (osName.contains("windows")) {
			uninstallWindowsShortcuts();
		} else if (osName.contains("mac")) {
			uninstallMacShortcuts();
		}
	}


	public static void uninstallMacShortcuts() {
		try {
			FileUtils.deleteDirectory(new File(DataSources.MAC_APP_LOCATION()));
		} catch (IOException e) {
			e.printStackTrace();
		}


	}

	public static void uninstallWindowsShortcuts() {
		new File(DataSources.WINDOWS_SHORTCUT_LINK()).delete();
	}

	public static void uninstallLinuxShortcuts() {
		new File(DataSources.LINUX_DESKTOP_FILE()).delete();

	}

	public static void installMacShortcuts() {
		log.info("Installing mac shortcuts...");

		try {
			String s = "do shell script \"java -jar " + DataSources.LAUNCHER_FILE() + "\"";
			java.nio.file.Files.write(Paths.get(DataSources.MAC_INSTALL_APPLESCRIPT()), s.getBytes());

			File appDir = new File(DataSources.MAC_APP_LOCATION());
			if (appDir.exists()) {
				FileUtils.deleteDirectory(appDir);
			}
			// Run the shortcut install script
			String cmd = "osacompile -o " + DataSources.MAC_APP_LOCATION() + " " + 
					DataSources.MAC_INSTALL_APPLESCRIPT();

			log.info("osacompile cmd : " + cmd);
			Process p = Runtime.getRuntime().exec(cmd);
			p.waitFor();

			// Replace the icon:
			java.nio.file.Files.copy(Paths.get(DataSources.ICON_MAC_LOCATION()), 
					Paths.get(DataSources.MAC_ICON_APPLET()),
					StandardCopyOption.REPLACE_EXISTING);

			// Touch the app folder: 
			new File(DataSources.MAC_APP_LOCATION()).setLastModified(System.currentTimeMillis());

		} catch (IOException | InterruptedException e) {
			e.printStackTrace();
		}

	}

	public static void installWindowsShortcuts() {

		log.info("Installing windows shortcuts...");
		try {

			// create and write the .vbs file
			String s = "Set oWS = WScript.CreateObject(\"WScript.Shell\")\n"+
					"sLinkFile = \"" + DataSources.WINDOWS_SHORTCUT_LINK() + "\"\n"+
					"Set oLink = oWS.CreateShortcut(sLinkFile)\n"+
					"oLink.TargetPath = \"" + System.getProperty("java.home") + "/bin/javaw.exe \"\n" +
					"oLink.Arguments = \"-jar " +  DataSources.LAUNCHER_FILE() + "\"\n"+
					"oLink.Description = \"Torrent Tunes\" \n"+
					"\' oLink.HotKey = \"ALT+CTRL+F\"\n"+
					"oLink.IconLocation = \"" + DataSources.ICON_LOCATION() + "\"\n"+
					"\' oLink.WindowStyle = \"1\" \n"+
					"\' oLink.WorkingDirectory = \"C:\\Program Files\\MyApp\"\n"+
					"oLink.Save";

			java.nio.file.Files.write(Paths.get(DataSources.WINDOWS_INSTALL_VBS()), s.getBytes());

			// Run the shortcut install script
			String cmd = "cscript " + DataSources.WINDOWS_INSTALL_VBS();
			Runtime.getRuntime().exec(cmd);



		} catch (IOException e) {
			e.printStackTrace();
		}


	}


	public static void installLinuxShortcuts() {
		log.info("Installing linux shortcuts...");
		try {
			String s = "[Desktop Entry]\n"+
					"Type=Application\n"+
					"Encoding=UTF-8\n"+
					"Name=Torrent Tunes\n"+
					"Comment=A sample application\n"+
					"Exec=java -jar " + DataSources.LAUNCHER_FILE() + "\n"+
					"Path=" + DataSources.HOME_DIR() + "\n" + 
					"Icon=" + DataSources.ICON_LOCATION() + "\n"+
					"Terminal=false\n"+
					"Categories=Audio;Music;Player;AudioVideo\n"+
					"GenericName=Music Player";

			//			log.info(s);

			File desktopFile = new File(DataSources.LINUX_DESKTOP_FILE());
			if (desktopFile.exists()) {
				desktopFile.delete();
			} else {
				desktopFile.getParentFile().mkdirs();
			}
			java.nio.file.Files.write(Paths.get(DataSources.LINUX_DESKTOP_FILE()), s.getBytes());

			// Run the shortcut install script
			//			String cmd = "desktop-file-install " + DataSources.LINUX_DESKTOP_FILE();
			//			Runtime.getRuntime().exec(cmd);

		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void restartApplication() throws URISyntaxException, IOException {
		final String javaBin = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
		final File currentJar = new File(Tools.class.getProtectionDomain().getCodeSource().getLocation().toURI());

		/* is it a jar file? */
		if(!currentJar.getName().endsWith(".jar"))
			return;

		/* Build command: java -jar application.jar */
		final ArrayList<String> command = new ArrayList<String>();
		command.add(javaBin);
		command.add("-jar");
		command.add(currentJar.getPath());

		final ProcessBuilder builder = new ProcessBuilder(command);
		builder.start();
		System.exit(0);
	}

	public static File createAndSaveTorrent(File torrentFile, File inputFileOrDir) {

		file_storage fs = new file_storage();

		// Add the file
		libtorrent.add_files(fs, inputFileOrDir.getAbsolutePath());

		create_torrent t = new create_torrent(fs);


		// Add trackers in tiers
		for (URI announce : DataSources.ANNOUNCE_LIST()) {
			t.add_tracker(announce.toASCIIString());
		}


		t.set_priv(false);
		t.set_creator(System.getProperty("user.name"));

		error_code ec = new error_code();


		// reads the files and calculates the hashes
		libtorrent.set_piece_hashes(t, inputFileOrDir.getParent(), ec);

		if (ec.value() != 0) {
			log.info(ec.message());
		}

		// Get the bencode and write the file
		Entry entry =  new Entry(t.generate());

		Map<String, Entry> entryMap = entry.dictionary();
		Entry entryFromUpdatedMap = Entry.fromMap(entryMap);
		final byte[] bencode = entryFromUpdatedMap.bencode();

		try {
			FileOutputStream fos;

			fos = new FileOutputStream(torrentFile);

			BufferedOutputStream bos = new BufferedOutputStream(fos);
			bos.write(bencode);
			bos.flush();
			bos.close();
		} catch (IOException e) {
			log.error("Couldn't write file");
			e.printStackTrace();
		}

		return torrentFile;
	}


	public static void printTorrentStatus(TorrentStatus ts) {

		StringBuilder s = new StringBuilder();
		s.append("Torrent status for name: " + ts.getName() + "\n");
		s.append("info_hash: " + ts.getInfoHash() + "\n");
		s.append("state: " + ts.getState().toString() + "\n");
		s.append("error: " + ts.errorCode() + "\n");
		s.append("progress: " + ts.getProgress() + "\n");
		s.append("Queue position: " + ts.getQueuePosition() + "\n");

		//		ts.getHandle().forceRecheck();
		//		ts.getHandle().queuePositionTop();

		log.info(s.toString());
	}

	public static void setContentTypeFromFileName(String pageName, Response res) {

		if (pageName.endsWith(".css")) {
			res.type("text/css");
		} else if (pageName.endsWith(".js")) {
			res.type("application/javascript");
		} else if (pageName.endsWith(".png")) {
			res.type("image/png");
			res.header("Content-Disposition", "filename=MyFileName.png");
			res.header("Accept-Ranges", "bytes");			
		} else if (pageName.endsWith(".svg")) {
			res.type("image/svg+xml");
		}
	}


	public static String getIPHash() {

		// IP address is mixed with the users home directory, 
		// so that it can't be decrypted by the server.

		String text = DataSources.EXTERNAL_IP + System.getProperty("user.home");

		HashFunction hf = Hashing.md5();
		HashCode hc = hf.hashString(text, Charsets.UTF_8);

		String ipHash = hc.toString();

		return ipHash;
	}


}