/**
 * Created by leon on 1/29/18.
 */
import java.util.*;
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) {
        int last_index=array.length-1;
        return array[last_index];
    }

    /**
     * @param array array of String objects
     * @return second to last element in specified array
     */ // TODO
    public static String getSecondToLastElement(String[] array) {

        int last_index=array.length-2;
        return array[last_index];
    }

    /**
     * @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 b=false;
        for(int i=0;i<array.length;i++)
        {
            if(array[i].equals(value))
            {
                b=true;
            }
        }
        return b;
    }

    /**
     * @param array of String objects
     * @return an array with identical contents in reverse order
     */ // TODO
    public static String[] reverse(String[] array) {
        String[] str=new String[array.length];
        int k=0;
        for(int i=array.length-1;i>=0;i--)
        {

            str[k]=array[i];
            k++;

        }
        //System.out.println((str));
        return str;
    }

    /**
     * @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) {

        String[] reversed=new String[array.length];
        reversed=reverse(array);
        boolean flag=true;
        for( int i=0;i<reversed.length;i++)
        {
            if(!array[i].equals(reversed[i]))
            {
                flag=false;
                break;

            }
        }
        return flag;
    }

    /**
     * @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) {
        ArrayList<Character> albha = new ArrayList<Character>();
        String str="";
        int count =0;
        boolean result=false;
        for(int i=0;i<array.length;i++)
        {
            str=str+array[i];
        }
        System.out.println(str);
        str=str.toLowerCase();
        for(int i=0;i<str.length();i++)
        {
            int k=str.charAt(i);
            if(k>=65&&k<=90 || k>=97&&k<=122)
            {
               
                if(!albha.contains(str.charAt(i)))
                {

                    albha.add(str.charAt(i));

                    count ++;
                }
            }
        }
        
        System.out.println(count);
        System.out.println(albha);
        
        if(count==26)
        {
            result=true;
        }
        else
        {
            result=false;
        }
        return result;
    }

    /**
     * @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 k=0;
        for(int i=0;i<array.length;i++)
        {
            if(value.equals(array[i].toString()))
            {
                k++;
            }
        }
        return k;
    }

    /**
     * @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) {
        int k=0;
        int n=getNumberOfOccurrences(array,valueToRemove);
        String[] newArray= new String[array.length-n];
        for(int i=0;i<array.length;i++)
        {
            if(!array[i].equals(valueToRemove))
            {
                newArray[k]=array[i];
                k++;

            }

        }
        System.out.println(Arrays.toString(array));
        return newArray;
    }

    /**
     * @param array array of chars
     * @return array of Strings with consecutive duplicates removes
     */ // TODO
    public static String[] removeConsecutiveDuplicates(String[] array) {
        int k=0;
        
        ArrayList<String> resultList = new ArrayList<String>();
        resultList.add(array[0]);
        for(int i = 1; i < array.length; i++) {

            if(!array[i-1].equals(array[i])) {
                resultList.add(array[i]);
            }

        }
        String[] resultArray = resultList.toArray(new String[resultList.size()]);

        return resultArray;
    }

    /**
     * @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) {
        ArrayList<String> list = new ArrayList<>();
        list.add(array[0]);
        int k=0;

        for(int i = 1 ; i < array.length ; i++) {

            if(array[i-1].equalsIgnoreCase(array[i])){

                String lastElement = list.get(list.size()-1);

                lastElement = lastElement.concat(array[i]);

                list.set(list.size()-1,lastElement);
            }
            else{
                list.add(array[i]);
            }
        }

        String[] newArray = list.toArray(new String[list.size()]);
        return newArray;

    }

}