package be.nikiroo.utils.resources;

import java.util.ArrayList;
import java.util.List;

/**
 * Internal class used to convert data to/from {@link String}s in the context of
 * {@link Bundle}s.
 * 
 * @author niki
 */
class BundleHelper {
	/**
	 * Convert the given {@link String} into a {@link Boolean} if it represents
	 * a {@link Boolean}, or NULL if it doesn't.
	 * <p>
	 * Note: null, "strange text", ""... will all be converted to NULL.
	 * 
	 * @param str
	 *            the input {@link String}
	 * @param item
	 *            the item number to use for an array of values, or -1 for
	 *            non-arrays
	 * 
	 * @return the converted {@link Boolean} or NULL
	 */
	static public Boolean parseBoolean(String str, int item) {
		str = getItem(str, item);
		if (str == null) {
			return null;
		}

		if (str.equalsIgnoreCase("true") || str.equalsIgnoreCase("on")
				|| str.equalsIgnoreCase("yes"))
			return true;
		if (str.equalsIgnoreCase("false") || str.equalsIgnoreCase("off")
				|| str.equalsIgnoreCase("no"))
			return false;

		return null;
	}

	/**
	 * Return a {@link String} representation of the given {@link Boolean}.
	 * 
	 * @param value
	 *            the input value
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromBoolean(boolean value) {
		return Boolean.toString(value);
	}

	/**
	 * Convert the given {@link String} into a {@link Integer} if it represents
	 * a {@link Integer}, or NULL if it doesn't.
	 * <p>
	 * Note: null, "strange text", ""... will all be converted to NULL.
	 * 
	 * @param str
	 *            the input {@link String}
	 * @param item
	 *            the item number to use for an array of values, or -1 for
	 *            non-arrays
	 * 
	 * @return the converted {@link Integer} or NULL
	 */
	static public Integer parseInteger(String str, int item) {
		str = getItem(str, item);
		if (str == null) {
			return null;
		}

		try {
			return Integer.parseInt(str);
		} catch (Exception e) {
		}

		return null;
	}

	/**
	 * Return a {@link String} representation of the given {@link Integer}.
	 * 
	 * @param value
	 *            the input value
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromInteger(int value) {
		return Integer.toString(value);
	}

	/**
	 * Convert the given {@link String} into a {@link Character} if it
	 * represents a {@link Character}, or NULL if it doesn't.
	 * <p>
	 * Note: null, "strange text", ""... will all be converted to NULL
	 * (remember: any {@link String} whose length is not 1 is <b>not</b> a
	 * {@link Character}).
	 * 
	 * @param str
	 *            the input {@link String}
	 * @param item
	 *            the item number to use for an array of values, or -1 for
	 *            non-arrays
	 * 
	 * @return the converted {@link Character} or NULL
	 */
	static public Character parseCharacter(String str, int item) {
		str = getItem(str, item);
		if (str == null) {
			return null;
		}

		String s = str.trim();
		if (s.length() == 1) {
			return s.charAt(0);
		}

		return null;
	}

	/**
	 * Return a {@link String} representation of the given {@link Boolean}.
	 * 
	 * @param value
	 *            the input value
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromCharacter(char value) {
		return Character.toString(value);
	}

	/**
	 * Convert the given {@link String} into a colour (represented here as an
	 * {@link Integer}) if it represents a colour, or NULL if it doesn't.
	 * <p>
	 * The returned colour value is an ARGB value.
	 * 
	 * @param str
	 *            the input {@link String}
	 * @param item
	 *            the item number to use for an array of values, or -1 for
	 *            non-arrays
	 * 
	 * @return the converted colour as an {@link Integer} value or NULL
	 */
	static Integer parseColor(String str, int item) {
		str = getItem(str, item);
		if (str == null) {
			return null;
		}

		Integer rep = null;

		str = str.trim();
		int r = 0, g = 0, b = 0, a = -1;
		if (str.startsWith("#") && (str.length() == 7 || str.length() == 9)) {
			try {
				r = Integer.parseInt(str.substring(1, 3), 16);
				g = Integer.parseInt(str.substring(3, 5), 16);
				b = Integer.parseInt(str.substring(5, 7), 16);
				if (str.length() == 9) {
					a = Integer.parseInt(str.substring(7, 9), 16);
				} else {
					a = 255;
				}

			} catch (NumberFormatException e) {
				// no changes
			}
		}

		// Try by name if still not found
		if (a == -1) {
			if ("black".equalsIgnoreCase(str)) {
				a = 255;
				r = 0;
				g = 0;
				b = 0;
			} else if ("white".equalsIgnoreCase(str)) {
				a = 255;
				r = 255;
				g = 255;
				b = 255;
			} else if ("red".equalsIgnoreCase(str)) {
				a = 255;
				r = 255;
				g = 0;
				b = 0;
			} else if ("green".equalsIgnoreCase(str)) {
				a = 255;
				r = 0;
				g = 255;
				b = 0;
			} else if ("blue".equalsIgnoreCase(str)) {
				a = 255;
				r = 0;
				g = 0;
				b = 255;
			} else if ("grey".equalsIgnoreCase(str)
					|| "gray".equalsIgnoreCase(str)) {
				a = 255;
				r = 128;
				g = 128;
				b = 128;
			} else if ("cyan".equalsIgnoreCase(str)) {
				a = 255;
				r = 0;
				g = 255;
				b = 255;
			} else if ("magenta".equalsIgnoreCase(str)) {
				a = 255;
				r = 255;
				g = 0;
				b = 255;
			} else if ("yellow".equalsIgnoreCase(str)) {
				a = 255;
				r = 255;
				g = 255;
				b = 0;
			}
		}

		if (a != -1) {
			rep = ((a & 0xFF) << 24) //
					| ((r & 0xFF) << 16) //
					| ((g & 0xFF) << 8) //
					| ((b & 0xFF) << 0);
		}

		return rep;
	}

	/**
	 * Return a {@link String} representation of the given colour.
	 * <p>
	 * The colour value is interpreted as an ARGB value.
	 * 
	 * @param color
	 *            the ARGB colour value
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromColor(int color) {
		int a = (color >> 24) & 0xFF;
		int r = (color >> 16) & 0xFF;
		int g = (color >> 8) & 0xFF;
		int b = (color >> 0) & 0xFF;

		String rs = Integer.toString(r, 16);
		String gs = Integer.toString(g, 16);
		String bs = Integer.toString(b, 16);
		String as = "";
		if (a < 255) {
			as = Integer.toString(a, 16);
		}

		return "#" + rs + gs + bs + as;
	}

	/**
	 * The size of this raw list (note than a NULL list is of size 0).
	 * 
	 * @param raw
	 *            the raw list
	 * 
	 * @return its size if it is a list (NULL is an empty list), -1 if it is not
	 *         a list
	 */
	static public int getListSize(String raw) {
		if (raw == null) {
			return 0;
		}

		List<String> list = parseList(raw, -1);
		if (list == null) {
			return -1;
		}

		return list.size();
	}

	/**
	 * Return a {@link String} representation of the given list of values.
	 * <p>
	 * The list of values is comma-separated and each value is surrounded by
	 * double-quotes; caret (^) and double-quotes (") are escaped by a caret.
	 * 
	 * @param str
	 *            the input value
	 * @param item
	 *            the item number to use for an array of values, or -1 for
	 *            non-arrays
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public List<String> parseList(String str, int item) {
		if (str == null) {
			return null;
		}

		if (item >= 0) {
			str = getItem(str, item);
		}

		List<String> list = new ArrayList<String>();
		try {
			boolean inQuote = false;
			boolean prevIsBackSlash = false;
			StringBuilder builder = new StringBuilder();
			for (int i = 0; i < str.length(); i++) {
				char car = str.charAt(i);

				if (prevIsBackSlash) {
					// We don't process it here
					builder.append(car);
					prevIsBackSlash = false;
				} else {
					switch (car) {
					case '"':
						// We don't process it here
						builder.append(car);

						if (inQuote) {
							list.add(unescape(builder.toString()));
							builder.setLength(0);
						}

						inQuote = !inQuote;
						break;
					case '^':
						// We don't process it here
						builder.append(car);
						prevIsBackSlash = true;
						break;
					case ' ':
					case '\n':
					case '\r':
						if (inQuote) {
							builder.append(car);
						}
						break;

					case ',':
						if (!inQuote) {
							break;
						}
						// continue to default
					default:
						if (!inQuote) {
							// Bad format!
							return null;
						}

						builder.append(car);
						break;
					}
				}
			}

			if (inQuote || prevIsBackSlash) {
				// Bad format!
				return null;
			}

		} catch (Exception e) {
			return null;
		}

		return list;
	}

	/**
	 * Return a {@link String} representation of the given list of values.
	 * <p>
	 * NULL will be assimilated to an empty {@link String} if later non-null
	 * values exist, or just ignored if not.
	 * <p>
	 * Example:
	 * <ul>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>3</tt> will become <tt>1</tt>,
	 * <tt>""</tt>, <tt>3</tt></li>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>NULL</tt> will become <tt>1</tt></li>
	 * <li><tt>NULL</tt>, <tt>NULL</tt>, <tt>NULL</tt> will become an empty list
	 * </li>
	 * </ul>
	 * 
	 * @param list
	 *            the input value
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromList(List<String> list) {
		if (list == null) {
			list = new ArrayList<String>();
		}

		int last = list.size() - 1;
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i) != null) {
				last = i;
			}
		}

		StringBuilder builder = new StringBuilder();
		for (int i = 0; i <= last; i++) {
			String item = list.get(i);
			if (item == null) {
				item = "";
			}

			if (builder.length() > 0) {
				builder.append(", ");
			}
			builder.append(escape(item));
		}

		return builder.toString();
	}

	/**
	 * Return a {@link String} representation of the given list of values.
	 * <p>
	 * NULL will be assimilated to an empty {@link String} if later non-null
	 * values exist, or just ignored if not.
	 * <p>
	 * Example:
	 * <ul>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>3</tt> will become <tt>1</tt>,
	 * <tt>""</tt>, <tt>3</tt></li>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>NULL</tt> will become <tt>1</tt></li>
	 * <li><tt>NULL</tt>, <tt>NULL</tt>, <tt>NULL</tt> will become an empty list
	 * </li>
	 * </ul>
	 * 
	 * @param list
	 *            the input value
	 * @param value
	 *            the value to insert
	 * @param item
	 *            the position to insert it at
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromList(List<String> list, String value, int item) {
		if (list == null) {
			list = new ArrayList<String>();
		}

		while (item >= list.size()) {
			list.add(null);
		}
		list.set(item, value);

		return fromList(list);
	}

	/**
	 * Return a {@link String} representation of the given list of values.
	 * <p>
	 * NULL will be assimilated to an empty {@link String} if later non-null
	 * values exist, or just ignored if not.
	 * <p>
	 * Example:
	 * <ul>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>3</tt> will become <tt>1</tt>,
	 * <tt>""</tt>, <tt>3</tt></li>
	 * <li><tt>1</tt>,<tt>NULL</tt>, <tt>NULL</tt> will become <tt>1</tt></li>
	 * <li><tt>NULL</tt>, <tt>NULL</tt>, <tt>NULL</tt> will become an empty list
	 * </li>
	 * </ul>
	 * 
	 * @param list
	 *            the input value
	 * @param value
	 *            the value to insert
	 * @param item
	 *            the position to insert it at
	 * 
	 * @return the raw {@link String} value that correspond to it
	 */
	static public String fromList(String list, String value, int item) {
		return fromList(parseList(list, -1), value, item);
	}

	/**
	 * Escape the given value for list formating (no carets, no NEWLINES...).
	 * <p>
	 * You can unescape it with {@link BundleHelper#unescape(String)}
	 * 
	 * @param value
	 *            the value to escape
	 * 
	 * @return an escaped value that can unquoted by the reverse operation
	 *         {@link BundleHelper#unescape(String)}
	 */
	static public String escape(String value) {
		return '"' + value//
				.replace("^", "^^") //
				.replace("\"", "^\"") //
				.replace("\n", "^\n") //
				.replace("\r", "^\r") //
		+ '"';
	}

	/**
	 * Unescape the given value for list formating (change ^n into NEWLINE and
	 * so on).
	 * <p>
	 * You can escape it with {@link BundleHelper#escape(String)}
	 * 
	 * @param value
	 *            the value to escape
	 * 
	 * @return an unescaped value that can reverted by the reverse operation
	 *         {@link BundleHelper#escape(String)}, or NULL if it was badly
	 *         formated
	 */
	static public String unescape(String value) {
		if (value.length() < 2 || !value.startsWith("\"")
				|| !value.endsWith("\"")) {
			// Bad format
			return null;
		}

		value = value.substring(1, value.length() - 1);

		boolean prevIsBackslash = false;
		StringBuilder builder = new StringBuilder();
		for (char car : value.toCharArray()) {
			if (prevIsBackslash) {
				switch (car) {
				case 'n':
				case 'N':
					builder.append('\n');
					break;
				case 'r':
				case 'R':
					builder.append('\r');
					break;
				default: // includes ^ and "
					builder.append(car);
					break;
				}
				prevIsBackslash = false;
			} else {
				if (car == '^') {
					prevIsBackslash = true;
				} else {
					builder.append(car);
				}
			}
		}

		if (prevIsBackslash) {
			// Bad format
			return null;
		}

		return builder.toString();
	}

	/**
	 * Retrieve the specific item in the given value, assuming it is an array.
	 * 
	 * @param value
	 *            the value to look into
	 * @param item
	 *            the item number to get for an array of values, or -1 for
	 *            non-arrays (in that case, simply return the value as-is)
	 * 
	 * @return the value as-is for non arrays, the item <tt>item</tt> if found,
	 *         NULL if not
	 */
	static private String getItem(String value, int item) {
		if (item >= 0) {
			value = null;
			List<String> values = parseList(value, -1);
			if (values != null && item < values.size()) {
				value = values.get(item);
			}
		}

		return value;
	}
}