// Manage the values of the file that contains chicago average temperature, values are separated by space

class WeatherTable {
  
  String MAX_READING_DATE = "Aug/01/2011";
  int rowCountAvg;
  int rowCountAvgXMonth;
  
  int columnCount;
  float[][] dataAvg; //Stores avg per day
  float[][] dataAvgXMonth; //Stores avg per month
  
  long[] rowNamesAvg;
  long[] rowNamesAvgXMonth;
  String[] columnNames = new String[]{"Average"};
  
  long minDate;
  long maxDate;
  
  float maxDataAvg;
  float minDataAvg;
  
  float minDataAvgXMonth;
  float maxDataAvgXMonth;
  
  WeatherTable(String filename) {
    
      try {
            
            String[] rows = loadStrings(filename);
            //Columns are the indexes of the rooms
            columnCount = columnNames.length;
        
            rowNamesAvg = new long[rows.length];
            dataAvg = new float[rows.length][columnCount];
            
            long prevDate = 0;
         
            maxDataAvg = -Float.MAX_VALUE;
            minDataAvg = Float.MAX_VALUE;
            maxDataAvgXMonth = -Float.MAX_VALUE;
            minDataAvgXMonth = Float.MAX_VALUE;
            
            int indexMonth = 0; 
            float sumXMonth = 0;           
            rowCountAvg = 0;
            rowCountAvgXMonth = 0;
       
            dataAvgXMonth = new float[rows.length][columnCount];
            rowNamesAvg = new long [rows.length];
            rowNamesAvgXMonth = new long [rows.length];
            
            String prevMonth = "";
            
            // Load the temperatures from the file and compute the averages by month
            for (int i = 0; i < rows.length; i++) { //i for the rows, that means for dates x hours
                                      
                // split the row by blank spaces
                String[] reading = splitTokens(rows[i]);
                
               // split the date by blank spaces to get only the date without time
               String strDateValue = reading[DATE]+" "+reading[HOUR_MIN]+" "+reading[AM_PM];
               long dateValue = readingDateFormat.parse(strDateValue).getTime();
           
                String monthValue =  monthFormatToPrint.format(getDateFromMillis(dateValue));
                float value = parseFloat(reading[3]);           
                 dataAvg[rowCountAvg][0] = value;
                 rowNamesAvg[rowCountAvg] = dateValue;
                 
                if (value < minDataAvg) {
                    minDataAvg = value;
                  }
                if (value > maxDataAvg) {
                    maxDataAvg = value;
                  }
                 rowCountAvg++;
                 
                 if (!prevMonth.equals(monthValue)){    
                      if(i > 0){
                         float avg = sumXMonth / indexMonth;
                         dataAvgXMonth[rowCountAvgXMonth][0] = avg;
                         rowNamesAvgXMonth[rowCountAvgXMonth] = (rowNamesAvg[rowCountAvg - 2]) ;
                   
                        if (avg < minDataAvgXMonth) {
                            minDataAvgXMonth = avg;
                          }
                        if (avg > maxDataAvgXMonth) {
                            maxDataAvgXMonth = avg;
                          }
                          
                       sumXMonth = 0;
                       indexMonth = 0;
                            
                      rowCountAvgXMonth++; 
                   }
                    prevMonth = monthValue;
                } 
                
                sumXMonth = sumXMonth + value;
                indexMonth++;
                
            }           
            //verify if the last month was store in the array.
            if (!(dateFormat.format(getDateFromMillis(rowNamesAvg[rowCountAvg-1]))).equals(dateFormat.format(getDateFromMillis(rowNamesAvgXMonth[rowCountAvgXMonth-1])))){
               float avg = sumXMonth / indexMonth;
               dataAvgXMonth[rowCountAvgXMonth][0] = avg;
               rowNamesAvgXMonth[rowCountAvgXMonth] = (rowNamesAvg[rowCountAvg - 1]) ;
         
              if (avg < minDataAvgXMonth) {
                  minDataAvgXMonth = avg;
                }
              if (avg > maxDataAvgXMonth) {
                  maxDataAvgXMonth = avg;
                }
                          
               rowCountAvgXMonth++;
            }
            // resize the 'dataAvg' and 'dataAvgXMonth' array as necessary
            dataAvg = (float[][]) subset(dataAvg, 0, rowCountAvg);
            rowNamesAvg = (long[]) subset(rowNamesAvg,0,rowCountAvg);
            
            dataAvgXMonth = (float[][]) subset(dataAvgXMonth, 0, rowCountAvgXMonth);
            rowNamesAvgXMonth = (long[]) subset(rowNamesAvgXMonth,0,rowCountAvgXMonth);
            
            minDate = rowNamesAvg[0];
            maxDate = rowNamesAvg[rowCountAvg-1]; 
          
    } catch (ParseException e) {
      //println("Error");
      die("Problem loading the file", e);
    }
    
    //println("File uploaded --> rowCount = " + rowCount + " , rowCountAvg = " + rowCountAvg);
  }
    
  
  int getRowCount() {
    if (showData == 'D' || showData == 'H')
        return rowCountAvg;
   
    return rowCountAvgXMonth;
  }
  
  
  long getRowName(int rowIndex) {
    if (showData == 'D' || showData == 'H')
        return rowNamesAvg[rowIndex];

    return rowNamesAvgXMonth[rowIndex];
  }
  
  
  long[] getRowNames() {
     if (showData == 'D' || showData == 'H')
        return rowNamesAvg;


     return rowNamesAvgXMonth;
  }

  
  // Find a row by its name, returns -1 if no row found. 
  // This will return the index of the first row with this name.
  // A more efficient version of this function would put row names
  // into a Hashtable (or HashMap) that would map to an integer for the row.
  int getRowIndex(String name) {
   try{
        if (showData == 'D' || showData == 'H'){
          for (int i = 0; i < rowCountAvg; i++) {
           // println(rowNamesAvg[i])
            if (rowNamesAvg[i] == (dateFormat.parse(name)).getTime()) {
              return i;
            }
          }
          ////println("No row named '" + name + "' was found");
          return -1;
        }
       
        //Look for the same month a year.   
        for (int i = 0; i < rowCountAvgXMonth; i++) {
          if ( rowNamesAvgXMonth[i] == (dateFormat.parse(name)).getTime()) {
            return i;
          }
        }
        ////println("No row named '" + name + "' was found");
        return -1;
   }
    catch (ParseException e) {
      //println("Error");
      die("Problem loading the file", e);
      return -1;
    }
  }
  
  int getRowMinIndex(long name) {
   
     return 0;
        ////println("No row named '" + name + "' was found");
  }
  
  int getRowMinIndex(String name) {
   try{
        long dateName;
        dateName = (readingDateFormat.parse(name +" 12:00 AM")).getTime();
           
        if (showData == 'D' || showData == 'H'){
                
              if (rowNamesAvg[rowCountAvg-1] <= dateName)
                  return rowCountAvgXMonth - 1;
              if (dateName <= rowNamesAvg[0])
                  return 0;
                          
              int dayIndex = (int)((dateName - rowNamesAvg[0]) / MILLIS_PER_DAY);   // index to help to go fast in the array.    
             
              if (dayIndex > rowCountAvg)
                   dayIndex = rowCountAvg - 1;
                   
                for (int i = dayIndex; i >= 0; i--) {
                
                if (rowNamesAvg[i] <= dateName) {
                  println (dateFormat.format(rowNamesAvg[i]) + " "  + i); 
                  return i;
                }
              }
        }
      
        //Look for the same month a year. 
        if (rowNamesAvgXMonth[rowCountAvgXMonth-1] <= dateName)
            return rowCountAvgXMonth - 1;
        if (dateName <= rowNamesAvgXMonth[0])
            return 0;
        
        int yearIndex = (int(yearFormatToPrint.format(dateName)) - int(yearFormatToPrint.format(minDate))) * 12;   // index to help to go fast in the array.    
        if (yearIndex > rowCountAvgXMonth - 1)
            yearIndex = rowCountAvgXMonth - 1;
        for (int i = yearIndex; i > 0; i--) {
          if (rowNamesAvgXMonth[i] <= dateName) {
            return i;
          }
        }
        ////println("No row named '" + name + "' was found");
        return -1;
   }
    catch (ParseException e) {
      //println("Error");
      die("Problem loading the file", e);
      return -1;
    }
  }
  
  int getRowMaxIndex(String name) {
   try{
        long dateName;
        if (showByDay)
           dateName = (readingDateFormat.parse(name +" 11:00 PM")).getTime();
        else
           dateName = (readingDateFormat.parse(name +" 12:00 AM")).getTime();
        if (showData == 'D' || showData == 'H'){
              if (rowNamesAvg[rowCountAvg-1] <= dateName)
                  return rowCountAvg - 1;
              if (dateName <= rowNamesAvg[0])
                  return 0;
                          
              int dayIndex = (int)((dateName - rowNamesAvg[0]) / MILLIS_PER_DAY);   // index to help to go fast in the array.    
              if (dayIndex > rowCountAvg)
                   dayIndex = rowCountAvg - 1;
              for (int i = dayIndex; i >= 0; i--) {
                if (rowNamesAvg[i] <= dateName) {
                   return i;
                }
              }
        }
      
        //Look for the same month a year.  
        if (dateName <= rowNamesAvgXMonth[0])
            return 0;
        if (rowNamesAvgXMonth[rowCountAvgXMonth-1] <= dateName)
            return rowCountAvgXMonth - 1;
       
        int yearIndex = (int(yearFormatToPrint.format(dateName)) - int(yearFormatToPrint.format(minDate)) + 1) * 12;   // index to help to go fast in the array.    
        println(yearIndex + "-->" + dateName);
        if (yearIndex > rowCountAvgXMonth - 1)
            yearIndex = rowCountAvgXMonth - 1;
        for (int i = yearIndex; i >= 0; i--) {
          if (rowNamesAvgXMonth[i] <= dateName) {
            return i;
          }
        }
        ////println("No row named '" + name + "' was found");
        return -1;
   }
    catch (ParseException e) {
      //println("Error");
      die("Problem loading the file", e);
      return -1;
    }
  }
  
  
  int getRowMaxIndex(long name) {
        if (showData == 'D' || showData == 'H')
            return rowCountAvg - 1;
        else
           return rowCountAvgXMonth - 1;
           
  }
  
  
  // technically, this only returns the number of columns 
  // in the very first row (which will be most accurate)
  int getColumnCount() {
    return columnCount;
  }
  
  long getMinDate() {
   /* println("Entro "+readingDateFormat.format(getDateFromMillis(rowNames[0])));
   if (showData == 'D')
         return rowNamesAvg[0];
    else if (showData == 'H')
         return rowNames[0];
    else 
        return rowNamesAvgXMonth[0];
  */
      return rowNamesAvg[0];
  }  
  
  long getMaxDate() {
  /*  println("Entro "+readingDateFormat.format(getDateFromMillis(rowNames[rowCount-1])));
    if (showData == 'D')
       return rowNamesAvg[rowCountAvg-1];
    else if (showData == 'H')
       return rowNames[rowCount-1];
    else     
       return rowNamesAvgXMonth[rowCountAvgXMonth-1];*/
    return rowNamesAvg[rowCountAvg-1];
  }
  
  
  
  String getColumnName(int colIndex) {
    return columnNames[colIndex];
  }
  
  
  String[] getColumnNames() {
    return columnNames;
  }


  float getFloat(int rowIndex, int col) {

    // Remove the 'training wheels' section for greater efficiency
    // It's included here to provide more useful error messages
    if (showData == 'D' || showData == 'H'){
        // begin training wheels
        if ((rowIndex < 0) || (rowIndex >= dataAvg.length)) {
          throw new RuntimeException("There is no row " + rowIndex);
        }
        if ((col < 0) || (col >= dataAvg[rowIndex].length)) {
          throw new RuntimeException("Row " + rowIndex + " does not have a column " + col);
        }
        // end training wheels
        //// It is going to show the data by hours as it is on the file history.txt
        if (CorF=='F')
            return round(dataAvg[rowIndex][col]); // Give value in F grades
        else
            return round(MULTIPLICATOR_VALUE * (dataAvg[rowIndex][col] - 32)); // Give value in C grades
    }
    
    // begin training wheels
        if ((rowIndex < 0) || (rowIndex >= dataAvgXMonth.length)) {
          throw new RuntimeException("There is no row " + rowIndex);
        }
        if ((col < 0) || (col >= dataAvgXMonth[rowIndex].length)) {
          throw new RuntimeException("Row " + rowIndex + " does not have a column " + col);
        }
        // end training wheels
        //// It is going to show the data by hours as it is on the file history.txt
        if (CorF=='F')
            return round(dataAvgXMonth[rowIndex][col]); // Give value in F grades
        else
            return round(MULTIPLICATOR_VALUE * (dataAvgXMonth[rowIndex][col] - 32)); // Give value in C grades
            
  }
  
  
  boolean isValid(int row, int col) {

    if (row < 0) return false;
    if (col < 0) return false;
    if (col >= columnCount) return false;
    
    if (showData == 'D' || showData == 'H'){
      if (row >= rowCountAvg) return false;
      return !Float.isNaN(dataAvg[row][col]);
    }
    if (row >= rowCountAvgXMonth) return false;
    return !Float.isNaN(dataAvgXMonth[row][col]);
  }


  float getColumnMin(int col) {
    float m = Float.MAX_VALUE;
    for (int row = 0; row < rowCountAvg; row++) {
      if (isValid(row, col)) {
        if (dataAvg[row][col] < m) {
          m = dataAvg[row][col];
        }
      }
    }
    return m;
  }


  float getColumnMax(int col) {
    float m = -Float.MAX_VALUE;
    for (int row = 0; row < rowCountAvg; row++) {
      if (isValid(row, col)) {
        if (dataAvg[row][col] > m) {
          m = dataAvg[row][col];
        }
      }
    }
    return m;
  }

  
  float getRowMin(int row) {
    float m = Float.MAX_VALUE;
    for (int col = 0; col < columnCount; col++) {
      if (isValid(row, col)) {
        if (dataAvg[row][col] < m) {
          m = dataAvg[row][col];
        }
      }
    }
    return m;
  } 


  float getRowMax(int row) {
    float m = -Float.MAX_VALUE;
    for (int col = 0; col < columnCount; col++) {
      if (isValid(row, col)) {
        if (dataAvg[row][col] > m) {
          m = dataAvg[row][col];
        }
      }
    }
    return m;
  }


  float getTableMin() {

    if (showData == 'D' || showData == 'H'){
      if (CorF=='F')
          return round(minDataAvg);
      else 
          return round(MULTIPLICATOR_VALUE * (minDataAvg - 32)); // Give value in C grades
    }
    
      if (CorF=='F')
            return round(minDataAvgXMonth);
        else 
            return round(MULTIPLICATOR_VALUE * (minDataAvgXMonth - 32)); // Give value in C grades

  }


  float getTableMax() {
   
   if (showData == 'D' || showData == 'H'){
      if (CorF=='F')
          return round(maxDataAvg);
      else 
          return round(MULTIPLICATOR_VALUE * (maxDataAvg - 32)); // Give value in C grades
    }
        if (CorF=='F')
            return round(maxDataAvgXMonth);
        else 
            return round(MULTIPLICATOR_VALUE * (maxDataAvgXMonth - 32)); // Give value in C grades*/
  }
  
}