import java.util.Arrays;
/**
 * Created by leon on 1/29/18.
 */
public class StringArrayUtils {
    /**
     * @param array array of String objects
     * @return first element of specified array
     */ // TODO
    public static String getFirstElement(String[] array) {
        return array[0];
    }

    /**
     * @param array array of String objects
     * @return second element in specified array
     */
    public static String getSecondElement(String[] array) {
        return array[1];
    }

    /**
     * @param array array of String objects
     * @return last element in specified array
     */ // TODO
    public static String getLastElement(String[] array) {
        //String[] array = {"brown", "fox", "jumps", "over", "the", "lazy", "dog"};
        String word = "";
        for(int i = 0; i < array.length -1; i++){

            return word = array[array.length-1];
        }
        return word;
    }

    /**
     * @param array array of String objects
     * @return second to last element in specified array
     */ // TODO
    public static String getSecondToLastElement(String[] array) {
        String word = "";
        for(int i = 0; i < array.length -2; i++){

            return word = array[array.length-2];
        }
        return word;
    }

    /**
     * @param array array of String objects
     * @param value value to check array for
     * @return true if the array contains the specified `value`
     */ // TODO
    public static boolean contains(String[] array, String value) {
        boolean hold = false;
        for(String s:array){
            if(s.equals(value)){
                return hold = true;
            }
        }

        return hold;
    }

    /**
     * @param array of String objects
     * @return an array with identical contents in reverse order
     */ // TODO
    public static String[] reverse(String[] array) {
        String[] tempStringArray = new String[array.length];
        System.arraycopy( array, 0, tempStringArray, 0, array.length );
        for(int i = 0 ;i<tempStringArray.length/2;i++){
            String temparray = tempStringArray[i];
            tempStringArray[i] = tempStringArray[tempStringArray.length -1 - i];
            tempStringArray[tempStringArray.length - 1 - i] = temparray;
        }
        return tempStringArray;

    }

    /**
     * @param array array of String objects
     * @return true if the order of the array is the same backwards and forwards
     */ // TODO
    public static boolean isPalindromic(String[] array) {
        /*
         * I'm trying to reverse the order of the array
         * than compare if array is equals to array
         */
        boolean returnPal = false;
        String [] reverseArray = reverse(array);
        for(int i = 0; i < array.length; i++){
            // System.out.println("array[i] " + array[i] + " reverseArray[i] " + reverseArray[i]);
            if(array[i].equals(reverseArray[i])){
                returnPal = true;
            }
        }
        return returnPal;
    }

    /**
     * @param array array of String objects
     * @return true if each letter in the alphabet has been used in the array
     */ // TODO
    public static boolean isPangramic(String[] array) {
        /*int letters = 26;
         * if(isPangramic.length() < letters){
         *  }
         */
        //        int letters = 26;
        //        boolean pangram = false;
        //
        //        if(array.length < letters){
        //            pangram = true;
        //        }
        //        if(array.length == letters){
        //            pangram = false;
        //        }else{
        //            pangram = true;
        //        }
        //        return pangram;
        String stringToArray = array.toString();
        String str = stringToArray.toLowerCase();
        boolean answer = false;
        for (char start = 'a';start <='z';++start){
            if (!str.contains(String.valueOf(start))){
                answer = true;
                break;
            }
        }
        return answer;
    }

    /**
     * @param array array of String objects
     * @param value value to check array for
     * @return number of occurrences the specified `value` has occurred
     */ // TODO
    public static int getNumberOfOccurrences(String[] array, String value) {

        int count = 0;
        for(int i = 0;i < array.length;i++){
            if(array[i] == value){
                count++;
            }
        }
        return count;
    }

    /**
     * @param array         array of String objects
     * @param valueToRemove value to remove from array
     * @return array with identical contents excluding values of `value`
     */ // TODO
    public static String[] removeValue(String[] array, String valueToRemove) {
        StringBuilder sb = new StringBuilder();

        //Looping through array
        for(int index = 0;index < array.length;index++){
            //if the array value does not equal
            //the value to remove, then add the values to a temp array

            if(array[index] != valueToRemove ){
                sb.append(array[index] + "~");

            }

        }
        String answer = sb.toString();
        String [] temp = answer.split("~");
        return temp;
    }

    /**
     * @param array array of chars
     * @return array of Strings with consecutive duplicates removes
     */ // TODO
    public static String[] removeConsecutiveDuplicates(String[] array) {
        //created emptry array with length of array
        //created an
        String [] answer = new String[array.length];
        int i = 0;
        answer[i]=array[0];
         i++; 
        for(int j=1;j<array.length;j++){
             if(!answer[i-1].equals(array[j])){
                answer[i]=array[j];
                 i++; 
                }
            }
        String [] newArray = new String [i];
        //copies a source array from a specific beginning position to the destination array
        // from the mentioned position.
        // No. of arguments to be copied are decided by len argument.
        System.arraycopy(answer, 0, newArray, 0, i);
        return newArray;
    }
    
    public static int counter(String[] array){
         int counter = 0;
        for(int index = 0; index < array.length-1; index++){
            if(array[index].equals(array[index+1])){
            counter = counter+=1;
          }
        }          
        return counter; 
    }

    /**
     * @param array array of chars
     * @return array of Strings with each consecutive duplicate occurrence concatenated as a single string in an array of Strings
     */ // TODO
    public static String[] packConsecutiveDuplicates(String[] array) {
           StringBuilder pack = new StringBuilder(array[0]);
           String [] answer = new String[array.length-counter(array)];
           int index = 0;  
           for(int i=1;i<array.length;i++){
            if(array[i-1].equals(array[i])){           
                pack.append(array[i]);
                
            } else{            
                answer[index] = pack.toString();
                pack.setLength(0);
                pack.append(array[i]);
                index++;
            }
            }
             answer[index]=pack.toString();
        return answer;
    }

}