/*
 * SonarQube
 * Copyright (C) 2009-2017 SonarSource SA
 * mailto:info AT sonarsource DOT com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
package org.sonar.server.computation.task.projectanalysis.duplication;

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Nonnull;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
import org.sonar.duplications.block.Block;
import org.sonar.duplications.detector.suffixtree.SuffixTreeCloneDetectionAlgorithm;
import org.sonar.duplications.index.CloneGroup;
import org.sonar.duplications.index.CloneIndex;
import org.sonar.duplications.index.ClonePart;
import org.sonar.duplications.index.PackedMemoryCloneIndex;
import org.sonar.server.computation.task.projectanalysis.component.Component;

import static com.google.common.collect.FluentIterable.from;

/**
 * Transform a list of duplication blocks into clone groups, then add these clone groups into the duplication repository.
 */
public class IntegrateCrossProjectDuplications {

  private static final Logger LOGGER = Loggers.get(IntegrateCrossProjectDuplications.class);

  private static final String JAVA_KEY = "java";

  private static final int MAX_CLONE_GROUP_PER_FILE = 100;
  private static final int MAX_CLONE_PART_PER_GROUP = 100;

  private final Settings settings;
  private final DuplicationRepository duplicationRepository;

  private Map<String, NumberOfUnitsNotLessThan> numberOfUnitsByLanguage = new HashMap<>();

  public IntegrateCrossProjectDuplications(Settings settings, DuplicationRepository duplicationRepository) {
    this.settings = settings;
    this.duplicationRepository = duplicationRepository;
  }

  public void computeCpd(Component component, Collection<Block> originBlocks, Collection<Block> duplicationBlocks) {
    CloneIndex duplicationIndex = new PackedMemoryCloneIndex();
    populateIndex(duplicationIndex, originBlocks);
    populateIndex(duplicationIndex, duplicationBlocks);

    List<CloneGroup> duplications = SuffixTreeCloneDetectionAlgorithm.detect(duplicationIndex, originBlocks);
    Iterable<CloneGroup> filtered = from(duplications).filter(getNumberOfUnitsNotLessThan(component.getFileAttributes().getLanguageKey()));
    addDuplications(component, filtered);
  }

  private static void populateIndex(CloneIndex duplicationIndex, Collection<Block> duplicationBlocks) {
    for (Block block : duplicationBlocks) {
      duplicationIndex.insert(block);
    }
  }

  private void addDuplications(Component file, Iterable<CloneGroup> duplications) {
    int cloneGroupCount = 0;
    for (CloneGroup duplication : duplications) {
      cloneGroupCount++;
      if (cloneGroupCount > MAX_CLONE_GROUP_PER_FILE) {
        LOGGER.warn("Too many duplication groups on file {}. Keeping only the first {} groups.", file.getKey(), MAX_CLONE_GROUP_PER_FILE);
        break;
      }
      addDuplication(file, duplication);
    }
  }

  private void addDuplication(Component file, CloneGroup duplication) {
    ClonePart originPart = duplication.getOriginPart();
    Iterable<Duplicate> duplicates = convertClonePartsToDuplicates(file, duplication);
    if (!Iterables.isEmpty(duplicates)) {
      duplicationRepository.add(
        file,
        new Duplication(new TextBlock(originPart.getStartLine(), originPart.getEndLine()), duplicates)
        );
    }
  }

  private static Iterable<Duplicate> convertClonePartsToDuplicates(final Component file, CloneGroup duplication) {
    final ClonePart originPart = duplication.getOriginPart();
    return from(duplication.getCloneParts())
      .filter(new DoesNotMatchSameComponentKey(originPart.getResourceId()))
      .filter(new DuplicateLimiter(file, originPart))
      .transform(ClonePartToCrossProjectDuplicate.INSTANCE);
  }

  private NumberOfUnitsNotLessThan getNumberOfUnitsNotLessThan(String language) {
    NumberOfUnitsNotLessThan numberOfUnitsNotLessThan = numberOfUnitsByLanguage.get(language);
    if (numberOfUnitsNotLessThan == null) {
      numberOfUnitsNotLessThan = new NumberOfUnitsNotLessThan(getMinimumTokens(language));
      numberOfUnitsByLanguage.put(language, numberOfUnitsNotLessThan);
    }
    return numberOfUnitsNotLessThan;
  }

  private int getMinimumTokens(String languageKey) {
    // The java language is an exception : it doesn't compute tokens but statement, so the settings could not be used.
    if (languageKey.equalsIgnoreCase(JAVA_KEY)) {
      return 0;
    }
    int minimumTokens = settings.getInt("sonar.cpd." + languageKey + ".minimumTokens");
    if (minimumTokens == 0) {
      return 100;
    }
    return minimumTokens;
  }

  private static class NumberOfUnitsNotLessThan implements Predicate<CloneGroup> {
    private final int min;

    public NumberOfUnitsNotLessThan(int min) {
      this.min = min;
    }

    @Override
    public boolean apply(@Nonnull CloneGroup input) {
      return input.getLengthInUnits() >= min;
    }
  }

  private static class DoesNotMatchSameComponentKey implements Predicate<ClonePart> {
    private final String componentKey;

    private DoesNotMatchSameComponentKey(String componentKey) {
      this.componentKey = componentKey;
    }

    @Override
    public boolean apply(@Nonnull ClonePart part) {
      return !part.getResourceId().equals(componentKey);
    }
  }

  private static class DuplicateLimiter implements Predicate<ClonePart> {
    private final Component file;
    private final ClonePart originPart;
    private int counter = 0;

    public DuplicateLimiter(Component file, ClonePart originPart) {
      this.file = file;
      this.originPart = originPart;
    }

    @Override
    public boolean apply(@Nonnull ClonePart input) {
      if (counter == MAX_CLONE_PART_PER_GROUP) {
        LOGGER.warn("Too many duplication references on file {} for block at line {}. Keeping only the first {} references.",
          file.getKey(), originPart.getStartLine(), MAX_CLONE_PART_PER_GROUP);
      }
      boolean res = counter <= MAX_CLONE_GROUP_PER_FILE;
      counter++;
      return res;
    }
  }

  private enum ClonePartToCrossProjectDuplicate implements Function<ClonePart, Duplicate> {
    INSTANCE;

    @Override
    @Nonnull
    public Duplicate apply(@Nonnull ClonePart input) {
      return new CrossProjectDuplicate(
        input.getResourceId(),
        new TextBlock(input.getStartLine(), input.getEndLine()));
    }
  }
}