package pr02;

public class FibonacciListLarge {
   
   private static final int MAX_LENGTH = 105;
   private static final int MAX_INT = FibonacciListSimple.getMaxLength();
   private static final int MAX_ENTRY = 1000000000;
   
   private int[] values;
   private int length;
   
   public FibonacciListLarge(int n) {
      int maxLength = getMaxLength();
      if (n < 0)
         n = 0;
      if (n > maxLength)
         n = maxLength;
      length = n;
      fillValues(n);
   }
   
   public static int getMaxLength() {
      double maxValue = (double)MAX_ENTRY;
      maxValue = maxValue*maxValue*maxValue*maxValue;
      double fib1 = 0;
      double fib2 = 1;
      double next = fib1 + fib2;
      int count = 2;
      while (next < maxValue) {
         count++;
         fib1 = fib2;
         fib2 = next;
         next = fib1 + fib2;
      }
      return count;
   }
   
   private void fillValues(int n) {
      values = new int[4*n];
      for (int i=0;i<values.length;i++)
         values[i] = 0;
      if (n == 0)
         return;
      values[4] = 1;
      if (n == 1)
         return;
      values[4] = 1;
      for (int i=2;i<n;i++)
         createFib(i, values);
   }
   
   private void createFib(int n, int[] list) {
      for (int k=0;k<4;k++) {
         list[4*n+k] = list[4*n+k] + list[4*n+k-8] + list[4*n+k-4];
         if( list[4*n+k] >= MAX_ENTRY) {
            list[4*n+k] = list[4*n+k] - MAX_ENTRY;
            list[4*n+k+1]++;
         }
      }
   }
   
   public int getLength() {
      return length;
   }
   
   public int getAsInt(int n) {
      if ((n < 0) || (n >= length) || (n > MAX_INT))
         return -1;
      return values[4*n] + MAX_ENTRY*values[4*n+1];
   }
   
   public double getAsDouble(int n) {
      if ((n < 0) || (n >= length))
         return -1;
      double result = 0;
      double multiplier = 1;
      for (int k=0;k<4;k++) {
         result = result + multiplier*values[4*n+k];
         multiplier = multiplier*MAX_ENTRY;
      }                           
      return result;
   }
   
   public String getAsString(int n) {
      if ((n < 0) || (n >= length))
         return null;
      String s = values[4*n+3] + nineDigits(values[4*n+2]) + nineDigits(values[4*n+1]) + nineDigits(values[4*n]);
      while ((s.length() > 1) && (s.charAt(0) == '0'))
         s = s.substring(1);
      String result = "";
      while (s.length() > 3) {
         result = "," + s.substring(s.length()-3) + result;
         s = s.substring(0,s.length()-3);
      }
      result = s + result;
      return result;
   }
   
   private String nineDigits(int n) {
      String s = ""+ n;
      while (s.length() < 9)
         s = "0"  + s;
      return s;
   }
   
   public int[] getAllAsInt() {
      int len = length;
      if (len > MAX_INT)
         len = MAX_INT;
      int[] newValues = new int[len];
      for (int i=0;i<len;i++)
         newValues[i] = getAsInt(i);
      return newValues;
   }
   
   private int[] getSomeAsInt(int mod ) {
      int count = 0;
      int value;
      for (int i=0;i<length;i++) {
         value = getAsInt(i);
         if (value < 0)
            break;
         if (value%2 == mod)
            count++;
      }
      int[] result = new int[count];
      count = 0;
      for (int i=0;i<length;i++) {
         value = getAsInt(i);
         if (value < 0)
            break;
         if (value%2 == mod)
            result[count++] = value;
      }
      return result;
   }
   
   public int[] getOddAsInt() {
      return getSomeAsInt(1);
   }
   
   public int[] getEvenAsInt() {
      return getSomeAsInt(0);
   }
   
   public String toString() {
      StringBuilder s = new StringBuilder();
      for (int i=0;i<length;i++)
         s.append("F["+(i)+"]: " + getAsString(i) + "\n");
      return s.toString();
   }


}