/********************************************************************************
 * Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

package org.eclipse.mdm.mdfsorter;

import java.util.logging.Level;

/**
 * Structure to store the program arguments.
 *
 * @author Tobias Leemann
 *
 */
public class ArgumentStruct {
	public String inputname;
	public String outputname;
	public boolean unzip = true;
	public long maxblocksize = 2_147_483_648L; // 2GB

	public boolean overrideOldSize;
	public boolean verbose;

	private boolean zipflagset;

	/**
	 * Parse Arguments given via the Command-Line-Inferface (only used for the
	 * "process" call.)
	 *
	 * @param argv
	 *            The Arguments of the call.
	 * @return An ArgumentStruct containing all values for this call.
	 * @throws IllegalArgumentException
	 *             If the arguments are not valid.
	 */
	public static ArgumentStruct parseArgs(String[] argv) throws IllegalArgumentException {
		if (argv.length < 3) {
			throw new IllegalArgumentException("At least two arguments must be provided.");
		} else {
			ArgumentStruct args = new ArgumentStruct();
			args.inputname = argv[1];
			args.outputname = argv[2];
			for (int i = 3; i < argv.length; i++) {
				String[] splitted = argv[i].split("=");
				switch (splitted[0]) {
				case "-unzip":
					if (args.zipflagset) {
						throw new MDFSorterArgException("Ambigous zip flags.");
					}
					args.unzip = true;
					args.zipflagset = true;
					break;
				case "-overridesize":
					args.overrideOldSize = true;
					break;
				case "-verbose":
					args.verbose = true;
					break;
				case "-zip":
					if (args.zipflagset) {
						throw new MDFSorterArgException("Ambigous zip flags.");
					}
					args.unzip = false;
					args.zipflagset = true;
					if (args.zipflagset) {
						break;
					}
				case "-maxblocksize":
					if (splitted.length < 2) {
						throw new MDFSorterArgException("Argument must be provided after \"-maxblocksize=\" flag.");
					} else {
						args.maxblocksize = parseLong(splitted[1]);
					}
					break;
				default:
					throw new MDFSorterArgException("Unknown Argument " + splitted[0]);
				}
			}

			if (!args.unzip && args.maxblocksize > 4 * 1024L * 1024L) {
				MDFSorter.log.log(Level.WARNING,
						"Setting maxblocksize to 4MB. Larger blocks are not allowed for zipped data.");
				args.maxblocksize = 4 * 1024L * 1024L;
			}

			return args;
		}
	}

	public static ArgumentStruct parseArgsCheck(String[] argv) throws IllegalArgumentException {
		ArgumentStruct args = new ArgumentStruct();
		if (argv.length < 1) {
			throw new MDFSorterArgException("At least one arguments must be provided.");
		}
		args.inputname = argv[1];

		if (argv.length <= 2) {
			args.maxblocksize = parseLong(argv[1]);
			if (argv.length == 3) {
				if (argv[2].equals("-unzip")) {
					args.unzip = true;
				} else if (argv[2].equals("-zip")) {
					args.unzip = false;
				} else {
					throw new MDFSorterArgException("Unknown zipflag");
				}
			} else if (argv.length > 3) {
				throw new MDFSorterArgException("Too many arguments.");
			}
		}

		return args;
	}

	/**
	 * Parse a long from a String with decimal prefix, e.g. "100M", "2G", ...
	 *
	 * @param arg
	 *            The String to parse.
	 * @return The value of the String as long.
	 */
	static long parseLong(String arg) {

		char c = arg.charAt(arg.length() - 1);
		// Numerical value only
		if (c > 47 && c < 58) {
			return Long.parseLong(arg);
		} else if (c == 'M' || c == 'm' || c == 'K' || c == 'k' || c == 'G' || c == 'g') {
			String numval = arg.substring(0, arg.length() - 1);
			long l = Long.parseLong(numval);
			switch (c) {
			case 'G':
			case 'g':
				l *= 1024L;
			case 'M':
			case 'm':
				l *= 1024L;
			case 'k':
			case 'K':
				l *= 1024L;
				break;
			default:
				l = 2_000_000_000L;
			}
			return l;
		} else {
			throw new MDFSorterArgException("Illegal numerical value");
		}
	}
}