CLI search, step 1

[fanfix.git] / src / be / nikiroo / fanfix / reader / BasicReader.java

package be.nikiroo.fanfix.reader;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.TreeMap;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.bundles.Config;
import be.nikiroo.fanfix.bundles.UiConfig;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.fanfix.library.BasicLibrary;
import be.nikiroo.fanfix.library.LocalLibrary;
import be.nikiroo.fanfix.supported.BasicSupport;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.serial.SerialUtils;

/**
 * The class that handles the different {@link Story} readers you can use.
 * <p>
 * All the readers should be accessed via {@link BasicReader#getReader()}.
 * 
 * @author niki
 */
public abstract class BasicReader implements Reader {
	private static BasicLibrary defaultLibrary = Instance.getLibrary();
	private static ReaderType defaultType = ReaderType.GUI;

	private BasicLibrary lib;
	private MetaData meta;
	private Story story;
	private int chapter;

	/**
	 * Take the default reader type configuration from the config file.
	 */
	static {
		String typeString = Instance.getConfig().getString(Config.READER_TYPE);
		if (typeString != null && !typeString.isEmpty()) {
			try {
				ReaderType type = ReaderType.valueOf(typeString.toUpperCase());
				defaultType = type;
			} catch (IllegalArgumentException e) {
				// Do nothing
			}
		}
	}

	@Override
	public synchronized Story getStory(Progress pg) {
		if (story == null) {
			story = getLibrary().getStory(meta.getLuid(), pg);
		}

		return story;
	}

	@Override
	public BasicLibrary getLibrary() {
		if (lib == null) {
			lib = defaultLibrary;
		}

		return lib;
	}

	@Override
	public void setLibrary(BasicLibrary lib) {
		this.lib = lib;
	}

	@Override
	public synchronized MetaData getMeta() {
		return meta;
	}

	@Override
	public synchronized void setMeta(MetaData meta) throws IOException {
		setMeta(meta == null ? null : meta.getLuid()); // must check the library
	}

	@Override
	public synchronized void setMeta(String luid) throws IOException {
		story = null;
		meta = getLibrary().getInfo(luid);

		if (meta == null) {
			throw new IOException("Cannot retrieve story from library: " + luid);
		}
	}

	@Override
	public synchronized void setMeta(URL url, Progress pg) throws IOException {
		BasicSupport support = BasicSupport.getSupport(url);
		if (support == null) {
			throw new IOException("URL not supported: " + url.toString());
		}

		story = support.process(pg);
		if (story == null) {
			throw new IOException(
					"Cannot retrieve story from external source: "
							+ url.toString());
		}

		meta = story.getMeta();
	}

	@Override
	public int getChapter() {
		return chapter;
	}

	@Override
	public void setChapter(int chapter) {
		this.chapter = chapter;
	}

	/**
	 * Return a new {@link BasicReader} ready for use if one is configured.
	 * <p>
	 * Can return NULL if none are configured.
	 * 
	 * @return a {@link BasicReader}, or NULL if none configured
	 */
	public static Reader getReader() {
		try {
			if (defaultType != null) {
				return (Reader) SerialUtils.createObject(defaultType
						.getTypeName());
			}
		} catch (Exception e) {
			Instance.getTraceHandler().error(
					new Exception("Cannot create a reader of type: "
							+ defaultType + " (Not compiled in?)", e));
		}

		return null;
	}

	/**
	 * The default {@link Reader.ReaderType} used when calling
	 * {@link BasicReader#getReader()}.
	 * 
	 * @return the default type
	 */
	public static ReaderType getDefaultReaderType() {
		return defaultType;
	}

	/**
	 * The default {@link Reader.ReaderType} used when calling
	 * {@link BasicReader#getReader()}.
	 * 
	 * @param defaultType
	 *            the new default type
	 */
	public static void setDefaultReaderType(ReaderType defaultType) {
		BasicReader.defaultType = defaultType;
	}

	/**
	 * Change the default {@link LocalLibrary} to open with the
	 * {@link BasicReader}s.
	 * 
	 * @param lib
	 *            the new {@link LocalLibrary}
	 */
	public static void setDefaultLibrary(BasicLibrary lib) {
		BasicReader.defaultLibrary = lib;
	}

	/**
	 * Return an {@link URL} from this {@link String}, be it a file path or an
	 * actual {@link URL}.
	 * 
	 * @param sourceString
	 *            the source
	 * 
	 * @return the corresponding {@link URL}
	 * 
	 * @throws MalformedURLException
	 *             if this is neither a file nor a conventional {@link URL}
	 */
	public static URL getUrl(String sourceString) throws MalformedURLException {
		if (sourceString == null || sourceString.isEmpty()) {
			throw new MalformedURLException("Empty url");
		}

		URL source = null;
		try {
			source = new URL(sourceString);
		} catch (MalformedURLException e) {
			File sourceFile = new File(sourceString);
			source = sourceFile.toURI().toURL();
		}

		return source;
	}

	/**
	 * Describe a {@link Story} from its {@link MetaData} and return a list of
	 * title/value that represent this {@link Story}.
	 * 
	 * @param meta
	 *            the {@link MetaData} to represent
	 * 
	 * @return the information
	 */
	public static Map<String, String> getMetaDesc(MetaData meta) {
		Map<String, String> metaDesc = new TreeMap<String, String>();

		// TODO: i18n

		StringBuilder tags = new StringBuilder();
		for (String tag : meta.getTags()) {
			if (tags.length() > 0) {
				tags.append(", ");
			}
			tags.append(tag);
		}

		metaDesc.put("Author", meta.getAuthor());
		metaDesc.put("Publication date", formatDate(meta.getDate()));
		metaDesc.put("Published on", meta.getPublisher());
		metaDesc.put("URL", meta.getUrl());
		if (meta.isImageDocument()) {
			metaDesc.put("Number of images", format(meta.getWords()));
		} else {
			metaDesc.put("Number of words", format(meta.getWords()));
		}
		metaDesc.put("Source", meta.getSource());
		metaDesc.put("Subject", meta.getSubject());
		metaDesc.put("Language", meta.getLang());
		metaDesc.put("Tags", tags.toString());

		return metaDesc;
	}

	/**
	 * Open the {@link Story} with an external reader (the program will be
	 * passed the main file associated with this {@link Story}).
	 * 
	 * @param lib
	 *            the {@link BasicLibrary} to select the {@link Story} from
	 * @param luid
	 *            the {@link Story} LUID
	 * @param sync
	 *            execute the process synchronously (wait until it is terminated
	 *            before returning)
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	@Override
	public void openExternal(BasicLibrary lib, String luid, boolean sync)
			throws IOException {
		MetaData meta = lib.getInfo(luid);
		File target = lib.getFile(luid, null);

		openExternal(meta, target, sync);
	}

	/**
	 * Open the {@link Story} with an external reader (the program will be
	 * passed the given target file).
	 * 
	 * @param meta
	 *            the {@link Story} to load
	 * @param target
	 *            the target {@link File}
	 * @param sync
	 *            execute the process synchronously (wait until it is terminated
	 *            before returning)
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected void openExternal(MetaData meta, File target, boolean sync)
			throws IOException {
		String program = null;
		if (meta.isImageDocument()) {
			program = Instance.getUiConfig().getString(
					UiConfig.IMAGES_DOCUMENT_READER);
		} else {
			program = Instance.getUiConfig().getString(
					UiConfig.NON_IMAGES_DOCUMENT_READER);
		}

		if (program != null && program.trim().isEmpty()) {
			program = null;
		}

		start(target, program, sync);
	}

	/**
	 * Start a file and open it with the given program if given or the first
	 * default system starter we can find.
	 * 
	 * @param target
	 *            the target to open
	 * @param program
	 *            the program to use or NULL for the default system starter
	 * @param sync
	 *            execute the process synchronously (wait until it is terminated
	 *            before returning)
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected void start(File target, String program, boolean sync)
			throws IOException {

		Process proc = null;
		if (program == null) {
			boolean ok = false;
			for (String starter : new String[] { "xdg-open", "open", "see",
					"start", "run" }) {
				try {
					Instance.getTraceHandler().trace(
							"starting external program");
					proc = Runtime.getRuntime().exec(
							new String[] { starter, target.getAbsolutePath() });
					ok = true;
					break;
				} catch (IOException e) {
				}
			}
			if (!ok) {
				throw new IOException("Cannot find a program to start the file");
			}
		} else {
			Instance.getTraceHandler().trace("starting external program");
			proc = Runtime.getRuntime().exec(
					new String[] { program, target.getAbsolutePath() });
		}

		if (proc != null && sync) {
			try {
				proc.waitFor();
			} catch (InterruptedException e) {
			}
		}
	}

	/**
	 * @deprecated use StringUtils when updated
	 */
	@Deprecated
	static private String format(long value) {
		//TODO: use StringUtils
		
		String display = "";
		String suffix = "";

		if (value > 4000) {
			value = value / 1000;
			suffix = "k";
		}

		while (value > 0) {
			if (!display.isEmpty()) {
				display = "." + display;
			}
			display = (value % 1000) + display;
			value = value / 1000;
		}

		return display + suffix;
	}

	static private String formatDate(String date) {
		long ms = 0;

		try {
			ms = StringUtils.toTime(date);
		} catch (ParseException e) {
		}

		if (ms <= 0) {
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd'T'HH:mm:ssSSS");
			try {
				ms = sdf.parse(date).getTime();
			} catch (ParseException e) {
			}
		}

		if (ms > 0) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			return sdf.format(new Date(ms));
		}

		// :(
		return date;
	}
}