package eecs2030.test2;

import java.util.ArrayList;
import java.util.List;

public class Test2G {
    
    /**
     * The size of the list required by the method Test2G.negate2 
     */
    public static final int NEGATE2_LIST_SIZE = 2;

    private Test2G() {
        // empty by design
    }
    
    /**
     * Returns true if <code>value</code> is strictly less than <code>min</code>
     * or strictly greater than <code>max</code>, and false otherwise.
     * 
     * @param min
     *            a minimum value
     * @param max
     *            a maximum value
     * @param value
     *            a value to check
     * @return true if <code>value</code> is strictly less than <code>min</code>
     *         or strictly greater than <code>max</code>, and false otherwise
     * @pre. min is greater than or equal to max
     */
    public static boolean isOutside(int min, int max, int value) {
        return value < min || value > max;
    }

    /**
     * Given a list containing exactly 2 integers, negates the values of the
     * integers in the list. The list <code>t</code> is not modified by this method. 
     * For example, given a list
     * 
     * <p>
     * <code>[-5, 9]</code>
     * 
     * <p>
     * <code>negate2</code> modifies the list so that it becomes
     * 
     * <p>
     * <code>[5, -9]</code>
     * 
     * @pre. t is not null
     * 
     * @param t
     *            a list containing exactly 2 integers
     * @throws IllegalArgumentException
     *             if the list does not contain exactly 2 integers
     */
    public static void negate2(List<Integer> t) {
        if (t.size() != 2) {
            throw new IllegalArgumentException("list size != 2");
        }
        int t0 = t.get(0);
        int t1 = t.get(1);
        t.set(0, -t0);
        t.set(1, -t1);
    }

    /**
     * Returns a new list containing the values 0, 1, 2, ..., n. Returns an
     * empty list if n is less than zero.
     * 
     * @param n
     *            the upper limit of the interval
     * @return a new list containing the values 0, 1, 2, ..., n or the empty
     *         list if n is less than zero
     */
    public static List<Integer> interval(int n) {
        List<Integer> t = new ArrayList<Integer>();
        for (int i = 0; i <= n; i++) {
            t.add(i);
        }
        return t;
    }

    /**
     * Returns a run length encoded list representing the numbers in the
     * the list <code>t</code>. The list <code>t</code> is not modified by this method.
     * 
     * <p>
     * Consider the list containing twelve ones:
     * 
     * <pre>
     * [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
     * </pre>
     * 
     * <p>
     * A run length encoded version of the list would be:
     * </p>
     * 
     * <pre>
     * [12, 1]         (twelve 1s)
     * </pre>
     * 
     * <p>
     * Similarly, consider the list containing four tens and three fives:
     * 
     * <pre>
     * [10, 10, 10, 10, 5, 5, 5]
     * </pre>
     * 
     * <p>
     * A run length encoded version of the list would be:
     * </p>
     * 
     * <pre>
     * [4, 10, 3, 5]         (four 10s, three 5s)
     * </pre>
     * 
     * <p>
     * If the list contains few or no repeated values, then the run length
     * encoded version of the list is longer than the original list. For example,
     * the run length encoded version of the list:
     * 
     * <pre>
     * [1, 2, 3, 4]
     * </pre>
     * 
     * <p>
     * is:
     * 
     * <pre>
     * [1, 1, 1, 2, 1, 3, 1, 4]    (one 1, one 2, one 3, one 4)
     * </pre>
     * 
     * @param t a list of integer values
     * @return a new list equal to the run length encoded version of t
     * @pre t is not null
     * @pre t is not empty
     */
    public static List<Integer> encode(List<Integer> t) {
        List<Integer> rle = new ArrayList<Integer>();
        int count = 1;
        int prev = t.get(0);
        if (t.size() > 1) {
            for (int i = 1; i < t.size(); i++) {
                int digit = t.get(i);
                if (digit == prev) {
                    count++;
                } else {
                    rle.add(count);
                    rle.add(prev);
                    count = 1;
                    prev = digit;
                }
            }
        }
        rle.add(count);
        rle.add(prev);
        return rle;
    }

    
    public static void main(String[] args) {
        // isOutside
        int min = 1;
        int max = 10;
        int value = 100;
        System.out.println(
                String.format("isOutside(%d, %d, %d) : ", min, max, value) + 
                Test2G.isOutside(min, max, value));
        
        // negate2
        List<Integer> t = new ArrayList<Integer>();
        t.add(3);
        t.add(5);
        String s = t.toString();
        Test2G.negate2(t);
        System.out.println(
                String.format("negate2(%s) : %s", s, t.toString()));
        
        // interval
        int n = 9;
        System.out.println(
                String.format("interval(%d) : %s", 
                        n, Test2G.interval(n)));
        
        // encode
        t.clear();
        t.add(10);
        t.add(10);
        t.add(10);
        t.add(10);
        t.add(5);
        t.add(5);
        t.add(5);
        System.out.println(
                String.format("encode(%s) : %s", 
                        t, Test2G.encode(t)));
    }
}