/**
 * (C) Copyright 2017 Benjamin Culkin.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package bjc.inflexion.nouns;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Implementation of {@link NounInflection} for words that don't inflect at the
 * end.
 *
 * @author EVE
 *
 */
public class CompoundNounInflection implements NounInflection {
	private static final String TOSTRING_FMT = "CompoundNounInflection [compoundMatcher=%s, singularPattern=%s,"
			+ " modernPluralPattern=%s, classicalPluralPattern=%s, hasPreposition=%s]";
	/*
	 * Data stores for use.
	 */
	private final Nouns		nunDB;
	private final Prepositions	pepositionDB;

	private final Pattern cmpoundMatcher;

	private final String sigularPattern;

	private final String	mdernPluralPattern;
	private final String	clasicalPluralPattern;

	/*
	 * Whether or not this inflection takes a preposition.
	 */
	private final boolean haPreposition;

	/*
	 * Whether or not there is a scratch word in place.
	 */
	private final boolean hasScratch;

	/**
	 * TODO fill in documentation.
	 *
	 * @param nounDB
	 * @param prepositionDB
	 * @param compoundMatcher
	 * @param singularPattern
	 * @param modernPluralPattern
	 * @param classicalPluralPattern
	 * @param hasPreposition
	 * @param hasScrtch
	 */
	public CompoundNounInflection(final Nouns nounDB, final Prepositions prepositionDB,
			final Pattern compoundMatcher, final String singularPattern, final String modernPluralPattern,
			final String classicalPluralPattern, final boolean hasPreposition, final boolean hasScrtch) {
		nunDB = nounDB;
		pepositionDB = prepositionDB;
		cmpoundMatcher = compoundMatcher;
		sigularPattern = singularPattern;
		mdernPluralPattern = modernPluralPattern;
		clasicalPluralPattern = classicalPluralPattern;
		haPreposition = hasPreposition;
		hasScratch = hasScrtch;
	}

	@Override
	public boolean matches(final String noun) {
		final Matcher matcher = cmpoundMatcher.matcher(noun);

		if (matcher.matches()) {
			final Noun actNoun = nunDB.getNoun(matcher.group("noun"));

			if (actNoun == null) return false;

			if (haPreposition) return pepositionDB.isPreposition(matcher.group("preposition"));

			return true;
		}

		return false;
	}

	@Override
	public boolean isSingular(final String noun) {
		final Matcher matcher = cmpoundMatcher.matcher(noun);
		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));

		return actNoun.isSingular();
	}

	@Override
	public boolean isPlural(final String noun) {
		final Matcher matcher = cmpoundMatcher.matcher(noun);
		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));

		return actNoun.isPlural();
	}

	@Override
	public String singularize(final String plural) {
		final Matcher matcher = cmpoundMatcher.matcher(plural);
		final Noun actNoun = getNoun(matcher);

		if (haPreposition && hasScratch)
			return String.format(sigularPattern, actNoun.singular(), matcher.group("preposition"),
					matcher.group("scratch"));
		else if (hasScratch)
			return String.format(sigularPattern, actNoun.singular(), matcher.group("scratch"));
		else if (haPreposition)
			return String.format(sigularPattern, actNoun.singular(), matcher.group("preposition"));
		else return String.format(sigularPattern, actNoun.singular());
	}

	@Override
	public String pluralize(final String singular) {
		final Matcher matcher = cmpoundMatcher.matcher(singular);
		final Noun actNoun = getNoun(matcher);

		final String patt = mdernPluralPattern == null ? clasicalPluralPattern : mdernPluralPattern;

		if (haPreposition && hasScratch)
			return String.format(patt, actNoun.plural(), matcher.group("preposition"),
					matcher.group("scratch"));
		else if (hasScratch)
			return String.format(patt, actNoun.plural(), matcher.group("scratch"));
		else if (haPreposition)
			return String.format(patt, actNoun.plural(), matcher.group("preposition"));
		else return String.format(patt, actNoun.plural());
	}

	@Override
	public String pluralizeModern(final String singular) {
		if (mdernPluralPattern == null) return pluralizeClassical(singular);

		final Matcher matcher = cmpoundMatcher.matcher(singular);
		final Noun actNoun = getNoun(matcher);

		if (haPreposition && hasScratch)
			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"),
					matcher.group("scratch"));
		else if (hasScratch)
			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("scratch"));
		else if (haPreposition)
			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"));
		else return String.format(mdernPluralPattern, actNoun.modernPlural());
	}

	@Override
	public String pluralizeClassical(final String singular) {
		if (clasicalPluralPattern == null) return pluralizeModern(singular);

		final Matcher matcher = cmpoundMatcher.matcher(singular);
		final Noun actNoun = getNoun(matcher);

		if (haPreposition && hasScratch)
			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
					matcher.group("preposition"), matcher.group("scratch"));
		else if (hasScratch)
			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
					matcher.group("scratch"));
		else if (haPreposition)
			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
					matcher.group("preposition"));
		else return String.format(clasicalPluralPattern, actNoun.classicalPlural());
	}

	private Noun getNoun(final Matcher matcher) {
		matcher.matches();

		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));
		return actNoun;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;

		result = prime * result + (clasicalPluralPattern == null ? 0 : clasicalPluralPattern.hashCode());
		result = prime * result + (cmpoundMatcher == null ? 0 : cmpoundMatcher.hashCode());
		result = prime * result + (haPreposition ? 1231 : 1237);
		result = prime * result + (mdernPluralPattern == null ? 0 : mdernPluralPattern.hashCode());
		result = prime * result + (sigularPattern == null ? 0 : sigularPattern.hashCode());

		return result;
	}

	@Override
	public boolean equals(final Object obj) {
		if (this == obj) return true;
		if (obj == null) return false;
		if (!(obj instanceof CompoundNounInflection)) return false;

		final CompoundNounInflection other = (CompoundNounInflection) obj;

		if (sigularPattern == null) {
			if (other.sigularPattern != null) return false;
		} else if (!sigularPattern.equals(other.sigularPattern)) return false;

		if (clasicalPluralPattern == null) {
			if (other.clasicalPluralPattern != null) return false;
		} else if (!clasicalPluralPattern.equals(other.clasicalPluralPattern)) return false;

		if (haPreposition != other.haPreposition) return false;

		if (mdernPluralPattern == null) {
			if (other.mdernPluralPattern != null) return false;
		} else if (!mdernPluralPattern.equals(other.mdernPluralPattern)) return false;

		if (cmpoundMatcher == null) {
			if (other.cmpoundMatcher != null) return false;
		} else if (!cmpoundMatcher.equals(other.cmpoundMatcher)) return false;

		return true;
	}

	@Override
	public String toString() {
		return String.format(TOSTRING_FMT, cmpoundMatcher, sigularPattern, mdernPluralPattern,
				clasicalPluralPattern, haPreposition);
	}
}