WITH ada.text_IO; USE ada.text_IO;
WITH ada.Integer_Text_IO; USE ada.integer_text_IO;
WITH Fib_Package;
--------------------------------------------------------------------------------
--| Assignment 4
--| Zachary
--| NOTES: takes in a number 'n' between 4 and 25 & returns 'n' such that
--|         T(n) = T(n-1) ^ T(n-2) ^ T(n-3) ^ T(-4) ASSUMING
--|         T(0) = A, T(1) = T, T2 = C, T(3) = G
--| ***PRESS ENTER WHEN PROGRAM COMPLETES***
--| Text File crashes when input exceeds 22
--------------------------------------------------------------------------------
PROCEDURE Assignment_4 IS

   --define program variables
   n        : Natural;
   outFile  : File_Type;
   outName  : string(1..32);
   last     : integer;
   N_string : string(1..3412255); --largest string possible when n=25
   Length   : integer;

   --Define Package
   PACKAGE Fib_Pack IS NEW Fib_Package (ElementType => integer);
   USE Fib_Pack;

BEGIN --Assignment_4

   --get a proper "n" value
   LOOP
      new_Line;
      put("enter an integer between 4 and 25: ");
      get(n);

      IF n < 4 OR n > 25 THEN
         put("INVALID INPUT");
         new_line;
      ELSE
         skip_line;
         EXIT;
      END IF;
   END LOOP;

   --prompt for outfile name
   put("enter an output file: ");
   get_line(item => outName, last => last);
   open(File => outfile, Mode => Out_File, Name => outname(1..last));
   New_Line;

   --Call Fill_Array to create array of 1..n values
   Compute_Fib(n => n,
               n_Length => Length,
               Data  => N_String);

   --Output Fib_Seq to screen
   put("Fib Value of ");
   put(n, width => 2);
   put(": ");
   put_line(n_String(1..(Length)));

   --output number of chars in the fib sequence
   put("# of chars: ");
   put(item => Length, width => 6);
   new_Line(2);

   --Output Fib_Seq to file
   put(item => ("# of chars: "), File => outfile);
   put(item => Length, width => 6, File => outfile);
   new_Line(File => outfile);
   put(item => "Fibonacci Value of ", file => outFile);
   put(Item => n, width => 2, file => outFile);
   put(item => ":", File => outFile);
   new_line(File => outfile);
   put_line(Item => (n_String(1..(Length))), File => outFile);

   --Close output text file
   close(File => outfile);

   --notify of file completion
   put("Data Output to File.");
   new_Line(2);

   --notify of program completion
   put("Program 4 Completed.");
   new_line(2);

   --Makes program hang while using command line so output is readable
   put("<<< Press Enter To Exit >>>");
   skip_line;

END Assignment_4;

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

GENERIC
   TYPE ElementType IS PRIVATE;
PACKAGE Fib_Package IS
--------------------------------------------------------------------------------
--| Specification of Fibonacci Sequence Package
--| Zachary
--------------------------------------------------------------------------------

TYPE nPtr IS LIMITED PRIVATE;

   --PROCEDURE DEFINITIONS

   PROCEDURE Compute_Fib (n : IN integer; n_Length : OUT integer; data : IN OUT String);
   --PRE: take in an integer 'n' & an array of pointers
   --POST: passes out the array with correct fib values

PRIVATE

   TYPE nNode;
   TYPE nPtr IS ACCESS nNode;
   TYPE nNode IS RECORD
      Val   : string(1..3412255); --largest string possible when n=25
      Length    : integer;
      next  : nptr;
   END RECORD;

END Fib_Package;

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

WITH ada.text_IO;
USE ada.text_IO;
WITH ada.Integer_Text_IO;
USE ada.integer_text_IO;
WITH ada.Unchecked_Deallocation;
--------------------------------------------------------------------------------
--| Body of Fibonacci Sequence Package
--| Zachary
--------------------------------------------------------------------------------

PACKAGE BODY Fib_Package IS

   --declare unchecked deallocation
   PROCEDURE Dispose IS NEW ada.Unchecked_Deallocation
      (Object => nNode, Name => nPtr);

   --Computes the fib value of a given 'n' integer
   --PRE: take in an integer 'n' & an array of pointers
   --POST: passes out the array with correct fib values
   PROCEDURE Compute_Fib (n : IN integer; n_Length : OUT integer; data : IN OUT String) IS
      Fib_Seq   : nPtr := NULL;
      Prev1 : nPtr;
      prev2 : nPtr;
      prev3 : nPtr;
      prev4 : nPtr;
      deallPtr  : nPtr;
      temp_S    : string(1..3412255); --largest string possible when n=25

   BEGIN --compute_fib

      --Create first four nodes
      FOR i in 0..3 LOOP
         IF i = 0 THEN
            Fib_Seq := NEW nNode;
            Fib_Seq.length := 1;
            Fib_Seq.val(1..(Fib_Seq.length)) := "A";
            prev4 := Fib_Seq;
         ELSIF i = 1 THEN
            Fib_Seq.next := NEW nNode;
            Fib_Seq := Fib_Seq.next;
            Fib_Seq.length := 1;
            Fib_Seq.val(1..(Fib_Seq.length)) := "T";
            prev3 := Fib_Seq;
         ELSIF i = 2 THEN
            Fib_Seq.next := NEW nNode;
            Fib_Seq := Fib_Seq.next;
            Fib_Seq.length := 1;
            Fib_Seq.val(1..(Fib_Seq.length)) := "C";
            prev2 := Fib_Seq;
         ELSIF i = 3 THEN
            Fib_Seq.next := NEW nNode;
            Fib_Seq := Fib_Seq.next;
            Fib_Seq.length := 1;
            Fib_Seq.val(1..(Fib_Seq.length)) := "G";
            prev1 := Fib_Seq;
         END IF;
      END LOOP;

      FOR i IN 4..n LOOP

         --deallocate memory on the fly that wont be used again
         IF i > 4 THEN
            dispose(X => deallPtr);
         END IF;

         --creates list node
         Fib_Seq.next := NEW nNode;
         Fib_Seq := Fib_Seq.next;

         --assigns length of fib value to nNode.Length
         Fib_Seq.length := (prev1.length +
                            prev2.length +
                            prev3.length +
                            prev4.length);

         --Concatonates 4 previous values and create new fib value
         Fib_Seq.val(1..(Fib_Seq.length)) :=  ((prev1.val(1..(prev1.length)))
                                     & (prev2.val(1..(prev2.length)))
                                             & (prev3.val(1..(prev3.length)))
                                             & (prev4.val(1..(prev4.length))));

         --assign prev pointers to proper values
         deallptr   := prev4;
         prev4      := prev3;
         prev3      := prev2;
         prev2      := prev1;
         prev1      := Fib_seq;

      END LOOP;

      --assign values to pass back out
      n_Length  := Fib_Seq.Length;
      temp_S(1..n_length)    := Fib_Seq.val(1..n_length);
      data(data'first..n_length) := temp_S(1..n_length);

      --deallocate prev(1-4) & deallPtr & Fib_Seq
      Dispose(X => prev1);
      Dispose(X => prev2);
      Dispose(X => prev3);
      Dispose(X => prev4);
      Dispose(X => deallPtr);
      Fib_seq := NULL;

   END Compute_Fib;
END Fib_package;