/*
 * Copyright 2009-2017 java-diff-utils.
 *
 * 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 com.github.difflib;

import com.github.difflib.algorithm.DiffAlgorithmFactory;
import com.github.difflib.algorithm.DiffAlgorithmI;
import com.github.difflib.algorithm.DiffAlgorithmListener;
import com.github.difflib.algorithm.myers.MeyersDiff;
import com.github.difflib.patch.AbstractDelta;
import com.github.difflib.patch.Patch;
import com.github.difflib.patch.PatchFailedException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.BiPredicate;

/**
 * Implements the difference and patching engine
 */
public final class DiffUtils {

    /**
     * This factory generates the DEFAULT_DIFF algorithm for all these routines.
     */
    static DiffAlgorithmFactory DEFAULT_DIFF = MeyersDiff.factory();

    public static void withDefaultDiffAlgorithmFactory(DiffAlgorithmFactory factory) {
        DEFAULT_DIFF = factory;
    }

    /**
     * Computes the difference between the original and revised list of elements
     * with default diff algorithm
     *
     * @param <T> types to be diffed
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param progress progress listener
     * @return The patch describing the difference between the original and
     * revised sequences. Never {@code null}.
     */
    public static <T> Patch<T> diff(List<T> original, List<T> revised, DiffAlgorithmListener progress) {
        return DiffUtils.diff(original, revised, DEFAULT_DIFF.create(), progress);
    }

    public static <T> Patch<T> diff(List<T> original, List<T> revised) {
        return DiffUtils.diff(original, revised, DEFAULT_DIFF.create(), null);
    }

    public static <T> Patch<T> diff(List<T> original, List<T> revised, boolean includeEqualParts) {
        return DiffUtils.diff(original, revised, DEFAULT_DIFF.create(), null, includeEqualParts);
    }

    /**
     * Computes the difference between the original and revised text.
     * @param sourceText
     * @param targetText
     * @param progress
     * @return the differences
     */
    public static Patch<String> diff(String sourceText, String targetText,
            DiffAlgorithmListener progress) {
        return DiffUtils.diff(
                Arrays.asList(sourceText.split("\n")),
                Arrays.asList(targetText.split("\n")), progress);
    }
    
    /**
     * Computes the difference between the original and revised text.
     * @param sourceText
     * @param targetText
     * @return the differences
     */
    public static Patch<String> diff(String sourceText, String targetText) {
        return DiffUtils.diff(
                Arrays.asList(sourceText.split("\n")),
                Arrays.asList(targetText.split("\n")));
    }
    /**
     * Computes the difference between the original and revised list of elements
     * with default diff algorithm
     *
     * @param <T>
     * @param source The original text. Must not be {@code null}.
     * @param target The revised text. Must not be {@code null}.
     *
     * @param equalizer the equalizer object to replace the default compare
     * algorithm (Object.equals). If {@code null} the default equalizer of the
     * default algorithm is used..
     * @return The patch describing the difference between the original and
     * revised sequences. Never {@code null}.
     */
    public static <T> Patch<T> diff(List<T> source, List<T> target,
            BiPredicate<T, T> equalizer) {
        if (equalizer != null) {
            return DiffUtils.diff(source, target,
                    DEFAULT_DIFF.create(equalizer));
        }
        return DiffUtils.diff(source, target, new MeyersDiff<>());
    }

    public static <T> Patch<T> diff(List<T> original, List<T> revised,
            DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress) {
        return diff(original, revised, algorithm, progress, false);
    }

    /**
     * Computes the difference between the original and revised list of elements
     * with default diff algorithm
     *
     * @param <T>
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param algorithm The diff algorithm. Must not be {@code null}.
     * @param progress The diff algorithm listener.
     * @param includeEqualParts Include equal data parts into the patch.
     * @return The patch describing the difference between the original and
     * revised sequences. Never {@code null}.
     */
    public static <T> Patch<T> diff(List<T> original, List<T> revised,
            DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress,
            boolean includeEqualParts) {
        Objects.requireNonNull(original, "original must not be null");
        Objects.requireNonNull(revised, "revised must not be null");
        Objects.requireNonNull(algorithm, "algorithm must not be null");

        return Patch.generate(original, revised, algorithm.computeDiff(original, revised, progress), includeEqualParts);
    }

    /**
     * Computes the difference between the original and revised list of elements
     * with default diff algorithm
     *
     * @param original The original text. Must not be {@code null}.
     * @param revised The revised text. Must not be {@code null}.
     * @param algorithm The diff algorithm. Must not be {@code null}.
     * @return The patch describing the difference between the original and
     * revised sequences. Never {@code null}.
     */
    public static <T> Patch<T> diff(List<T> original, List<T> revised, DiffAlgorithmI<T> algorithm) {
        return diff(original, revised, algorithm, null);
    }

    /**
     * Computes the difference between the given texts inline. This one uses the
     * "trick" to make out of texts lists of characters, like DiffRowGenerator
     * does and merges those changes at the end together again.
     *
     * @param original
     * @param revised
     * @return
     */
    public static Patch<String> diffInline(String original, String revised) {
        List<String> origList = new ArrayList<>();
        List<String> revList = new ArrayList<>();
        for (Character character : original.toCharArray()) {
            origList.add(character.toString());
        }
        for (Character character : revised.toCharArray()) {
            revList.add(character.toString());
        }
        Patch<String> patch = DiffUtils.diff(origList, revList);
        for (AbstractDelta<String> delta : patch.getDeltas()) {
            delta.getSource().setLines(compressLines(delta.getSource().getLines(), ""));
            delta.getTarget().setLines(compressLines(delta.getTarget().getLines(), ""));
        }
        return patch;
    }

    private static List<String> compressLines(List<String> lines, String delimiter) {
        if (lines.isEmpty()) {
            return Collections.emptyList();
        }
        return Collections.singletonList(String.join(delimiter, lines));
    }

    /**
     * Patch the original text with given patch
     *
     * @param original the original text
     * @param patch the given patch
     * @return the revised text
     * @throws PatchFailedException if can't apply patch
     */
    public static <T> List<T> patch(List<T> original, Patch<T> patch)
            throws PatchFailedException {
        return patch.applyTo(original);
    }

    /**
     * Unpatch the revised text for a given patch
     *
     * @param revised the revised text
     * @param patch the given patch
     * @return the original text
     */
    public static <T> List<T> unpatch(List<T> revised, Patch<T> patch) {
        return patch.restore(revised);
    }

    private DiffUtils() {
    }
}
