package launcher.hasher;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.regex.Pattern;

import launcher.LauncherAPI;
import launcher.helper.IOHelper;

public final class FileNameMatcher {
	private static final Entry[] NO_ENTRIES = new Entry[0];

	// Instance
	private final Entry[] update;
	private final Entry[] verify;
	private final Entry[] exclusions;

	@LauncherAPI
	public FileNameMatcher(String[] update, String[] verify, String[] exclusions) {
		this.update = toEntries(update);
		this.verify = toEntries(verify);
		this.exclusions = toEntries(exclusions);
	}

	private FileNameMatcher(Entry[] update, Entry[] verify, Entry[] exclusions) {
		this.update = update;
		this.verify = verify;
		this.exclusions = exclusions;
	}

	@LauncherAPI
	public boolean shouldUpdate(Collection<String> path) {
		return (anyMatch(update, path) || anyMatch(verify, path)) && !anyMatch(exclusions, path);
	}

	@LauncherAPI
	public boolean shouldVerify(Collection<String> path) {
		return anyMatch(verify, path) && !anyMatch(exclusions, path);
	}

	@LauncherAPI
	public FileNameMatcher verifyOnly() {
		return new FileNameMatcher(NO_ENTRIES, verify, exclusions);
	}

	private static boolean anyMatch(Entry[] entries, Collection<String> path) {
		return Arrays.stream(entries).anyMatch(e -> e.matches(path));
	}

	private static Entry[] toEntries(String... entries) {
		return Arrays.stream(entries).map(Entry::new).toArray(Entry[]::new);
	}

	private static final class Entry {
		private static final Pattern SPLITTER = Pattern.compile(Pattern.quote(IOHelper.CROSS_SEPARATOR) + '+');
		private final Pattern[] parts;

		private Entry(CharSequence exclusion) {
			parts = SPLITTER.splitAsStream(exclusion).map(Pattern::compile).toArray(Pattern[]::new);
		}

		private boolean matches(Collection<String> path) {
			if (parts.length > path.size()) {
				return false;
			}

			// Verify path parts
			Iterator<String> iterator = path.iterator();
			for (Pattern patternPart : parts) {
				String pathPart = iterator.next();
				if (!patternPart.matcher(pathPart).matches()) {
					return false;
				}
			}

			// All matches
			return true;
		}
	}
}