/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.refactoring.nls;

import java.util.Properties;

import org.eclipse.core.runtime.Assert;


public class NLSSubstitution {
	public static final int EXTERNALIZED= 0;
	public static final int IGNORED= 1;
	public static final int INTERNALIZED= 2;

	public static final int DEFAULT= EXTERNALIZED;
	public static final int STATE_COUNT= 3;

	private int fState;
	private String fKey;
	/**
	 * @since 3.1
	 */
	private String fCachedPrefixPlusKey;
	private String fValue;

	private int fInitialState;
	private String fInitialKey;
	private String fInitialValue;

	private NLSElement fNLSElement;
	private AccessorClassReference fAccessorClassReference;

	private String fNewAccessorClassName;

	private String fPrefix= ""; //$NON-NLS-1$


	public NLSSubstitution(int state, String value, NLSElement element) {
		fNLSElement= element;
		fValue= value;
		fState= state;
		fInitialState= state;
		fInitialValue= value;
		fCachedPrefixPlusKey= null;
		Assert.isTrue(state == EXTERNALIZED || state == IGNORED || state == INTERNALIZED);
	}

	/**
	 * @param state initial state of the substitution
	 * @param key initial key
	 * @param value the externalized value, or <b>null</b> to indicate a corrupt substitution
	 * @param element the element to externalize
	 * @param accessorClassReference the accessor class descriptor
	 */
	public NLSSubstitution(int state, String key, String value, NLSElement element, AccessorClassReference accessorClassReference) {
		this(state,value,element);
		if (state != EXTERNALIZED) {
			throw new IllegalArgumentException("Set to INTERNALIZE/IGNORED State with different Constructor"); //$NON-NLS-1$
		}
		fKey= key;
		fInitialKey= key;
		fAccessorClassReference= accessorClassReference;
		fNewAccessorClassName= null;
	}

	//util
	public static int countItems(NLSSubstitution[] elems, int task) {
		Assert.isTrue(task == NLSSubstitution.EXTERNALIZED || task == NLSSubstitution.IGNORED || task == NLSSubstitution.INTERNALIZED);
		int result= 0;
		for (NLSSubstitution substitution : elems) {
			if (substitution.fState == task) {
				result++;
			}
		}
		return result;
	}

	public NLSElement getNLSElement() {
		return fNLSElement;
	}

	public String getKeyWithoutPrefix() {
		return fKey;
	}

	/**
	 * Returns key dependent on state.
	 * @return prefix + key when
	 */
	public String getKey() {
		if ((fState == EXTERNALIZED) && hasStateChanged()) {
			if (fCachedPrefixPlusKey == null) {
				int length= 0;
				if (fPrefix != null)
					length= length + fPrefix.length();
				if (fKey != null)
					length= length + fKey.length();
				StringBuilder sb= new StringBuilder(length);
				sb.append(fPrefix);
				sb.append(fKey);
				fCachedPrefixPlusKey= sb.toString();
			}
			return fCachedPrefixPlusKey;
		}
		return fKey;
	}

	public void setKey(String key) {
		if (fState != EXTERNALIZED) {
			throw new IllegalStateException("Must be in Externalized State !"); //$NON-NLS-1$
		}
		fCachedPrefixPlusKey= null;
		fKey= key;
	}

	public void setValue(String value) {
		fValue= value;
	}

	public void setInitialValue(String value) {
		fInitialValue= value;
	}

	/**
	 * @return the value or <b>null</b> if none
	 */
	public String getValue() {
		return fValue;
	}

	public String getValueNonEmpty() {
		if (fValue == null) {
			return ""; //$NON-NLS-1$
		}
		return fValue;
	}

	public int getState() {
		return fState;
	}

	public void setState(int state) {
		fCachedPrefixPlusKey= null;
		fState= state;
	}

	public void setUpdatedAccessor(String accessorClassName) {
		fNewAccessorClassName= accessorClassName;
	}

	public String getUpdatedAccessor() {
		return fNewAccessorClassName;
	}

	public boolean hasStateChanged() {
		return fState != fInitialState;
	}

	public boolean isKeyRename() {
		return 	(fInitialKey != null && !fInitialKey.equals(fKey));
	}

	public boolean isValueRename() {
		return 	(fInitialValue != null && !fInitialValue.equals(fValue));
	}

	public boolean isAccessorRename() {
		return (fAccessorClassReference != null) && (fNewAccessorClassName != null) && !fNewAccessorClassName.equals(fAccessorClassReference.getName());
	}


	public boolean hasPropertyFileChange() {
		if (fInitialState != EXTERNALIZED && fState != EXTERNALIZED) {
			return false;
		}
		if (fInitialState != fState) {
			return true;
		}
		if (fState == EXTERNALIZED) {
			if ((fInitialValue == null) // recreate entry in property file
					|| !fInitialValue.equals(fValue) // change of value
					) {
				return true;
			}
			if (!fInitialKey.equals(fKey)) {
				return true; // change of key
			}
		}
		return false;
	}

	public boolean hasAccessorClassChange() {
		if (fInitialState != EXTERNALIZED && fState != EXTERNALIZED) {
			return false;
		}
		if (fInitialState != fState) {
			return true;
		}
		if (fState == EXTERNALIZED) {
			if (fInitialValue == null) {
				return true; // recreate entry in property file
			} else if (!fInitialValue.equals(fValue)) {
				return false; // change of value
			}
			if (!fInitialKey.equals(fKey)) {
				return true; // change of key
			}
		}
		return false;
	}

	public boolean hasSourceChange() {
		if (hasStateChanged()) {
			return true;
		}
		if (fState == EXTERNALIZED) {
			if (!fInitialKey.equals(fKey)) {
				return true; // change of key
			}
			if (isAccessorRename()) {
				return true;
			}
		} else {
			if (!fInitialValue.equals(fValue)) {
				return true; // change of value
			}
		}
		return false;
	}

	public int getInitialState() {
		return fInitialState;
	}

	public String getInitialKey() {
		return fInitialKey;
	}

	public String getInitialValue() {
		return fInitialValue;
	}

	public AccessorClassReference getAccessorClassReference() {
		return fAccessorClassReference;
	}

	/**
	 * @param prefix the prefix to use for the key
	 */
	public void setPrefix(String prefix) {
		fPrefix= prefix;
		fCachedPrefixPlusKey= null;
	}

	public boolean isConflicting(NLSSubstitution[] substitutions) {
		if (fState == EXTERNALIZED) {
			String currKey= getKey();
			String currValue= getValueNonEmpty();
			for (NLSSubstitution substitution : substitutions) {
				if (substitution != this && substitution.getState() == EXTERNALIZED) {
					// same key but different value
					if (currKey.equals(substitution.getKey()) && !currValue.equals(substitution.getValueNonEmpty())) {
						return true;
					}
				}
			}
		}
		return false;
	}

	private String internalGetKeyWithoutPrefix() {
		if (fState == EXTERNALIZED && fPrefix != null && fKey != null && fKey.indexOf(fPrefix) == 0)
			return fKey.substring(fPrefix.length());
		return fKey;
	}

	public void generateKey(NLSSubstitution[] substitutions, Properties properties) {
		if (fState != EXTERNALIZED || ((fState == EXTERNALIZED) && hasStateChanged())) {
			int number= 0;
			while (true) {
				String ithKey= createKey(number);
				if (!properties.containsKey(fPrefix + ithKey) && !containsKey(substitutions, ithKey)) {
					fCachedPrefixPlusKey= null;
					fKey= ithKey;
					return;
				}
				number++;
			}
		}
	}

	private boolean containsKey(NLSSubstitution[] substitutions, String key) {
		for (NLSSubstitution substitution : substitutions) {
			if (substitution == this || substitution.fState != EXTERNALIZED)
				continue;

			if (key.equals(substitution.internalGetKeyWithoutPrefix()))
				return true;
		}

		return false;
	}

	public static void updateSubtitutions(NLSSubstitution[] substitutions, Properties props, String accessorClassName) {
		for (NLSSubstitution substitution : substitutions) {
			if ((substitution.getState() == NLSSubstitution.EXTERNALIZED) && !substitution.hasStateChanged()) {
				substitution.setInitialValue(props.getProperty(substitution.getKey()));
				substitution.setUpdatedAccessor(accessorClassName);
			}
		}
	}

	public void revert() {
		fState= fInitialState;
		fKey= fInitialKey;
		fCachedPrefixPlusKey= null;
		fValue= fInitialValue;
	}

	private String createKey(int counter) {
		return String.valueOf(counter);
	}

}