package com.knecon.fforesight.service.layoutparser.processor.utils;

import java.util.ArrayDeque;
import java.util.Comparator;
import java.util.Deque;
import java.util.List;

import lombok.experimental.UtilityClass;

/**
 * Copied and minimal modified from PDFBox.
 */
@UtilityClass
public final class QuickSort {

    private static final Comparator<? extends Comparable> OBJCOMP = new Comparator<Comparable>() {
        @Override
        public int compare(Comparable object1, Comparable object2) {

            return object1.compareTo(object2);
        }
    };


    /**
     * Sorts the given list using the given comparator.
     *
     * @param <T>  type of the objects to be sorted.
     * @param list list to be sorted
     * @param cmp  comparator used to compare the objects within the list
     */
    public static <T> void sort(List<T> list, Comparator<? super T> cmp) {

        int size = list.size();
        if (size < 2) {
            return;
        }
        quicksort(list, cmp);
    }


    /**
     * Sorts the given list using compareTo as comparator.
     *
     * @param <T>  type of the objects to be sorted.
     * @param list list to be sorted
     */
    public static <T extends Comparable> void sort(List<T> list) {

        sort(list, (Comparator<T>) OBJCOMP);
    }


    private static <T> void quicksort(List<T> list, Comparator<? super T> cmp) {

        Deque<Integer> stack = new ArrayDeque<Integer>();
        stack.push(0);
        stack.push(list.size());
        while (!stack.isEmpty()) {
            int right = stack.pop();
            int left = stack.pop();
            if (right - left < 2) {
                continue;
            }
            int p = left + ((right - left) / 2);
            p = partition(list, cmp, p, left, right);

            stack.push(p + 1);
            stack.push(right);

            stack.push(left);
            stack.push(p);
        }
    }


    private static <T> int partition(List<T> list, Comparator<? super T> cmp, int p, int start, int end) {

        int l = start;
        int h = end - 2;
        T piv = list.get(p);
        swap(list, p, end - 1);

        while (l < h) {
            if (cmp.compare(list.get(l), piv) <= 0) {
                l++;
            } else if (cmp.compare(piv, list.get(h)) <= 0) {
                h--;
            } else {
                swap(list, l, h);
            }
        }
        int idx = h;
        if (cmp.compare(list.get(h), piv) < 0) {
            idx++;
        }
        swap(list, end - 1, idx);
        return idx;
    }


    private static <T> void swap(List<T> list, int i, int j) {

        T tmp = list.get(i);
        list.set(i, list.get(j));
        list.set(j, tmp);
    }

}
