/*
 *   Intro to Programming CSE 1310
 * University of Texas at Arlington
 */

package code21mar19extra;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.NoSuchElementException;
import java.util.Scanner;

/**
 *
 * @author jcmtiernan
 */
public class Code21Mar19extra 
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        /*
        Array declaration refresh
	Automatic initializations
	String init (to remove null ptr err)
	Count of elements vs. size of array
	Handling “empty” elements
        
        Methods with return types
                Numbers, chars, Booleans
        Arraylists!

        */
        // This version handles errors in the input data file
        File nameAgeFile = new File("namesDatesErr21Mar.txt");
        Scanner nameDataFile = new Scanner(System.in);
        try
        {
            nameDataFile = new Scanner(nameAgeFile);
        }
        catch (FileNotFoundException fnfe)
        {
            System.out.println("No data file found");
        }

        final int MAXNUM = 50;
        // format should be lastName, firstName ; SHName pubYr movieYr
        String[] lastNm = new String[MAXNUM];
        String[] firstNm = new String[MAXNUM];
        String[] shNm = new String[MAXNUM];
        int[] pubYr = new int[MAXNUM];
        int[] movYr = new int[MAXNUM];
        int[] age = new int[MAXNUM];
        // Initialize all string arrays to prevent crashing due to null pointer values
        for (int i=0; i<MAXNUM; i++)
        {
            lastNm[i] = "";
            firstNm[i] = "";
            shNm[i] = "";
        }
        
        String oneLine = "";
        Scanner inLine;
        int index = 0;
        boolean valid = true;
        String number = "";
        boolean lnValid = true;
        int origCount = 1;
        
        while (nameDataFile.hasNextLine())
        {
            valid = true;
            lnValid = true;
            inLine = new Scanner(nameDataFile.nextLine());
            /*
                Read all inputs as Strings
                Use delimiters as needed to seperate values
                Convert Strings to numbers
                Store each data element into appropriate array
            */
            
            try
            {
                inLine.useDelimiter(", ");
                lastNm[index] = inLine.next();
                lastNm[index] = removeBlanks(lastNm[index]);
                inLine.reset();
                if (lastNm[index].isEmpty())  // superhero must have one "real" name but can be first or last
                    lnValid = false;          // so use boolean to record if there is no last name
                
                inLine.next(); // read comma
                inLine.useDelimiter(" : "); 
                firstNm[index] = inLine.next();
                //System.out.println("firstNm["+index+"] is "+firstNm[index]);
                firstNm[index] = removeBlanks(firstNm[index]); 
                inLine.reset();
                if (firstNm[index].isEmpty() && !lnValid)  // if superhero has no real name, i.e. no first and no last name
                { 
                    valid = false;                         // this is an invalid line of data
                    System.out.println("::: "+origCount+". No valid first or last name");
                }
                    
                inLine.next(); // read colon
                //inLine.useDelimiter("[+0-9]");   // check w neg #
                inLine.useDelimiter("-?\\d");
                shNm[index] = inLine.next();
                shNm[index] = removeBlanks(shNm[index]);
                if (shNm[index].isEmpty())  // superhero must have a superhero name
                {
                    valid = false; 
                    System.out.println("::: "+origCount+". No valid superhero name");
                }
                try
                {
                    int shTempInt = Integer.parseInt(shNm[index]);
                    valid = false;
                    System.out.println("::: "+origCount+". Superhero name is a number");
                }
                catch (NumberFormatException nfe)
                {   
                   // Correct behavior is for this try to fail and go to the catch
                }
                // use the line below (with the "*") when you are NOT using 
                // removeBlanks in order to see all the blanks around the 
                // name and how they change the name sort
                //shNm[index] = "*"+shNm[index]+"*";                 
                
            }
            catch (NoSuchElementException nsee)
            {
                System.out.println("::: "+origCount+". Insufficient name data available on current line");
                valid = false;
            }

            inLine.reset(); 
            // reading numbers as strings and parsing
            if (valid && inLine.hasNext())
            {
                try
                {
                    number = inLine.next();  
                    //System.out.println("number (pubYr) = "+number);
                    pubYr[index] = Integer.valueOf(number);  //Integer  assigned to int  
                    //System.out.println("pubYr["+index+"] is "+pubYr[index]);

                    number = inLine.next();  
                    //System.out.println("number (movYr) = "+number); 
                    movYr[index] = Integer.parseInt(number);  // int
                    //System.out.println("movYr["+index+"] is "+movYr[index]);
                }
                catch (NumberFormatException nfe)
                {   
                    System.out.println("::: "+origCount+". Year data is invalid");
                    valid = false;
                }
                catch (NoSuchElementException nsee)
                {
                    System.out.println("::: "+origCount+". Insufficient numeric data available on current line");
                    valid = false;
                }
                if (valid && (pubYr[index] < 1837))
                {
                    System.out.println("::: "+origCount+". Publication year is invalid");
                    valid = false;
                }
                if (valid && ((movYr[index] !=0) && (movYr[index] < 1888)))
                {
                    System.out.println("::: "+origCount+". Movie year is invalid");
                    valid = false;
                }                
            }
            if (!valid)
                index--;  // if the data isn't valid, ignore the current row of values and replace
                
                

            origCount++;
            index++;
            
            
        }  // end of while (nameDataFile.hasNextLine())
        
        System.out.println("Read "+origCount+" lines from the file");
        for (int k = 0; k < index; k++)
        {
            age[k] = movYr[k] - pubYr[k];
            if (movYr[k] == 0)
            {
                age[k] = 2019 - pubYr[k];
            }
        }
        
        System.out.println("\nFile data with calculated age is:");
        printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("");
        

        /* 
            Sort all arrays together by age using bubble sort with multiple arguments1
            Print table to verify
        */  
        
        int countSwaps = bubbleSortAllbyAgeSwap(lastNm, firstNm, shNm, pubYr, movYr, age, index);
        //System.out.println("After bubble sort, element count is "+index +" and the number of swaps was "+countSwaps);
        
        System.out.println("\nTable after sorting on age: ");
        
        boolean table = printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        //System.out.println("The table did "+ (table ? "" : "not ") +"print correctly.");
        System.out.println("The table had an "+(table?"even ":"odd ")+"number of superheros with no movies");
        System.out.println("");
        
        //bubbleSortAllbySHNameSwap(lastNm, firstNm, shNm, pubYr, movYr, age, index);
        bubbleSortAllbyAnyNameSwap(shNm, firstNm, lastNm, pubYr, movYr, age, index);
        
        System.out.println("\nTable after shNm sorting using AnyName sort: ");
        printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("");       
        
        bubbleSortAllbyAnyNameSwap(lastNm, firstNm, shNm, pubYr, movYr, age, index);
        
        System.out.println("\nTable after lastNm sorting using AnyName sort: ");
        printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("");   
        
        bubbleSortAllbyAnyNameSwap(firstNm, lastNm, shNm, movYr, pubYr, age, index);
        
        System.out.println("\nTable after firstNm sorting using AnyName sort: ");
        printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("");         
    }

    public static int bubbleSortAllbyAnyNameSwap(String[] Nm1, String[] Nm2, 
            String[] Nm3,int[] Yr1, int[] Yr2, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {   
                //do you need to check for blank strings?
                if ( (Nm1[comp].compareToIgnoreCase(Nm1[comp+1])) > 0 )
                { // swap
                    //System.out.print("Nm1["+comp+"] = "+Nm1[comp]);
                    //System.out.println(" compared to Nm1["+(comp+1)+"] = "+Nm1[comp+1]);
                    swap(list,comp);
                    swap(Nm1, comp);
                    swap(Nm2, comp);
                    swap(Nm3, comp);
                    swap(Yr1, comp);
                    swap(Yr2, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }   
    
    /*
    public static int bubbleSortAllbySHNameSwap(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                //do you need to check for blank strings?
                if ( (shNm[comp].compareToIgnoreCase(shNm[comp+1])) > 0 )
                { // swap
                    swap(list,comp);
                    swap(lastNm, comp);
                    swap(firstNm, comp);
                    swap(shNm, comp);
                    swap(pubYr, comp);
                    swap(movYr, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    } 
    */
    
    
    public static int bubbleSortAllbyAgeSwap(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp] > list[comp+1])
                { // swap
                    swap(list,comp);
                    swap(lastNm, comp);
                    swap(firstNm, comp);
                    swap(shNm, comp);
                    swap(pubYr, comp);
                    swap(movYr, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }  
    
    private static void swap(int[] list, int comp)
    {   int temp;
        //System.out.println("In int swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }
    private static void swap(String[] list, int comp)
    {   String temp;
        //System.out.println("In String swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }
    private static void swap(double[] list, int comp)
    {   double temp;
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp; 
        return;
    }    
    

    
    public static boolean printTableFLS(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] age, int sz)
    {
        boolean tableTF = true;
        // printing for verification
        System.out.printf("\n%20s %12s %17s %5s %5s %5s\n","SHName","First","Last","Comic","Movie","Age");
        for(int i=0; i < 80; i++)
            System.out.print("-");
        System.out.println("");
        for(int i=0; i < sz; i++)
        {
           System.out.printf("%20s %12s %17s %5d %5d %5d\n", 
                   shNm[i], firstNm[i], lastNm[i],pubYr[i], movYr[i], age[i]);
           //System.out.printf("%15s %24\n",firstNm[i],lastNm[i]);
           if (movYr[i] == 0)  // just an example of testing something and 
               tableTF = !tableTF;  // setting a boolean
           
        }  
        return tableTF;
    }

    public static String removeBlanks(String inStr)
    {
        //System.out.println("In rB, string is *"+inStr+"*");
        //String nStr = inStr.trim();
        String nStr = inStr;
        //System.out.println("In rB, string after trim is *"+nStr+"*");
        int cnt = 0;
        if (nStr.length() > 0)
        {
            //System.out.println("in rB, in if, before 1st while, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
            while ((nStr.length() > 0) && (nStr.charAt(cnt) == ' ') ) // check lenght BEFORE checking charAt when string is too short
            {
                //System.out.println("in rB, in if, in 1st while, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
                nStr = nStr.substring(1);
                //System.out.println("in rB, in if, in 1st while after subs, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
                
            }
            //System.out.println("In rB, string after remove front blanks is *"+nStr+"*");
        }
        if (nStr.length() > 0)
        {
            //System.out.println("in rB, in 2nd if, before while, nStr.length() = "+nStr.length());
            while ((nStr.length()>0) && (nStr.charAt(nStr.length()-1) == ' ') )
            {
                nStr = nStr.substring(0, nStr.length()-1);
            }
        }
        //System.out.println("In rB, string after remove back blanks is *"+nStr+"*");
        return nStr;
    }    

}