/*
    * Copyright (C) 2010, 2017 Red Hat Inc. and others
    *
    * This program and the accompanying materials are made available under the
    * terms of the Eclipse Distribution License v. 1.0 which is available at
    * https://www.eclipse.org/org/documents/edl-v10.php.
    *
    * SPDX-License-Identifier: BSD-3-Clause
    */
  package org.eclipse.jgit.attributes;
  
  import static org.eclipse.jgit.ignore.IMatcher.NO_MATCH;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import org.eclipse.jgit.attributes.Attribute.State;
  import org.eclipse.jgit.errors.InvalidPatternException;
  import org.eclipse.jgit.ignore.FastIgnoreRule;
  import org.eclipse.jgit.ignore.IMatcher;
  import org.eclipse.jgit.ignore.internal.PathMatcher;
  
  /**
   * A single attributes rule corresponding to one line in a .gitattributes file.
   *
   * Inspiration from: {@link org.eclipse.jgit.ignore.FastIgnoreRule}
   *
   * @since 3.7
   */
  public class AttributesRule {
  
  	/**
  	 * regular expression for splitting attributes - space, tab and \r (the C
  	 * implementation oddly enough allows \r between attributes)
  	 * */
  	private static final String ATTRIBUTES_SPLIT_REGEX = "[ \t\r]"; //$NON-NLS-1$
  
  	private static List<Attribute> parseAttributes(String attributesLine) {
  		// the C implementation oddly enough allows \r between attributes too.
  		ArrayList<Attribute> result = new ArrayList<>();
  		for (String attribute : attributesLine.split(ATTRIBUTES_SPLIT_REGEX)) {
  			attribute = attribute.trim();
  			if (attribute.length() == 0)
  				continue;
  
  			if (attribute.startsWith("-")) {//$NON-NLS-1$
  				if (attribute.length() > 1)
  					result.add(new Attribute(attribute.substring(1),
  							State.UNSET));
  				continue;
  			}
  
  			if (attribute.startsWith("!")) {//$NON-NLS-1$
  				if (attribute.length() > 1)
  					result.add(new Attribute(attribute.substring(1),
  							State.UNSPECIFIED));
  				continue;
  			}
  
  			final int equalsIndex = attribute.indexOf('=');
  			if (equalsIndex == -1)
  				result.add(new Attribute(attribute, State.SET));
  			else {
  				String attributeKey = attribute.substring(0, equalsIndex);
  				if (attributeKey.length() > 0) {
  					String attributeValue = attribute
  							.substring(equalsIndex + 1);
  					result.add(new Attribute(attributeKey, attributeValue));
  				}
  			}
  		}
  		return result;
  	}
  
  	private final String pattern;
  	private final List<Attribute> attributes;
  
  	private final boolean nameOnly;
  
  	private final boolean dirOnly;
  
  	private final IMatcher matcher;
  
  	/**
  	 * Create a new attribute rule with the given pattern. Assumes that the
  	 * pattern is already trimmed.
  	 *
  	 * @param pattern
  	 *            Base pattern for the attributes rule. This pattern will be
  	 *            parsed to generate rule parameters. It can not be
  	 *            <code>null</code>.
  	 * @param attributes
  	 *            the rule attributes. This string will be parsed to read the
  	 *            attributes.
  	 */
  	public AttributesRule(String pattern, String attributes) {
  		this.attributes = parseAttributes(attributes);
  
 		if (pattern.endsWith("/")) { //$NON-NLS-1$
 			pattern = pattern.substring(0, pattern.length() - 1);
 			dirOnly = true;
 		} else {
 			dirOnly = false;
 		}
 
 		int slashIndex = pattern.indexOf('/');
 
 		if (slashIndex < 0) {
 			nameOnly = true;
 		} else if (slashIndex == 0) {
 			nameOnly = false;
 		} else {
 			nameOnly = false;
 			// Contains "/" but does not start with one
 			// Adding / to the start should not interfere with matching
 			pattern = "/" + pattern; //$NON-NLS-1$
 		}
 
 		IMatcher candidateMatcher = NO_MATCH;
 		try {
 			candidateMatcher = PathMatcher.createPathMatcher(pattern,
 					Character.valueOf(FastIgnoreRule.PATH_SEPARATOR), dirOnly);
 		} catch (InvalidPatternException e) {
 			// ignore: invalid patterns are silently ignored
 		}
 		this.matcher = candidateMatcher;
 		this.pattern = pattern;
 	}
 
 	/**
 	 * Whether to match directories only
 	 *
 	 * @return {@code true} if the pattern should match directories only
 	 * @since 4.3
 	 */
 	public boolean isDirOnly() {
 		return dirOnly;
 	}
 
 	/**
 	 * Return the attributes.
 	 *
 	 * @return an unmodifiable list of attributes (never returns
 	 *         <code>null</code>)
 	 */
 	public List<Attribute> getAttributes() {
 		return Collections.unmodifiableList(attributes);
 	}
 
 	/**
 	 * Whether the pattern is only a file name and not a path
 	 *
 	 * @return <code>true</code> if the pattern is just a file name and not a
 	 *         path
 	 */
 	public boolean isNameOnly() {
 		return nameOnly;
 	}
 
 	/**
 	 * Get the pattern
 	 *
 	 * @return The blob pattern to be used as a matcher (never returns
 	 *         <code>null</code>)
 	 */
 	public String getPattern() {
 		return pattern;
 	}
 
 	/**
 	 * Returns <code>true</code> if a match was made.
 	 *
 	 * @param relativeTarget
 	 *            Name pattern of the file, relative to the base directory of
 	 *            this rule
 	 * @param isDirectory
 	 *            Whether the target file is a directory or not
 	 * @return True if a match was made.
 	 */
 	public boolean isMatch(String relativeTarget, boolean isDirectory) {
 		if (relativeTarget == null)
 			return false;
 		if (relativeTarget.length() == 0)
 			return false;
 		boolean match = matcher.matches(relativeTarget, isDirectory, true);
 		return match;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
 		sb.append(pattern);
 		for (Attribute a : attributes) {
 			sb.append(" "); //$NON-NLS-1$
 			sb.append(a);
 		}
 		return sb.toString();
 
 	}
 }