with Ada.Text_IO;
with Core_Types; use Core_Types;
with Math_Utils;

package body Benchmark is

   procedure Set_Name (R : in out Bench_Result; S : String) is
      Len : Natural := Natural'Min (S'Length, R.Name'Length);
   begin
      R.Name := (others => ' ');
      for I in 0 .. Len - 1 loop
         R.Name (I) := S (S'First + I);
      end loop;
   end Set_Name;

   function Recursive_GCD (A, B : Word32) return Word32 is
   begin
      if B = 0 then return A; end if;
      return Recursive_GCD (B, A mod B);
   end Recursive_GCD;

   function Recursive_Fibonacci (N : Natural) return Word32 is
   begin
      if N <= 1 then return Word32 (N); end if;
      return Recursive_Fibonacci (N - 1) + Recursive_Fibonacci (N - 2);
   end Recursive_Fibonacci;

   function Recursive_Factorial (N : Natural) return Word32 is
   begin
      if N <= 1 then return 1; end if;
      return Word32 (N) * Recursive_Factorial (N - 1);
   end Recursive_Factorial;

   function Recursive_Power (Base : Word32; Exp : Natural) return Word32 is
   begin
      if Exp = 0 then return 1; end if;
      return Base * Recursive_Power (Base, Exp - 1);
   end Recursive_Power;

   function Recursive_Sum (N : Natural) return Word32 is
   begin
      if N = 0 then return 0; end if;
      return Word32 (N) + Recursive_Sum (N - 1);
   end Recursive_Sum;

   procedure Run_Benchmarks (Results : out Bench_Results; Count : out Natural; Overall : out Boolean) is
      Idx : Natural := 0;
      W : Word32;
   begin
      Results := (others => (Name => (others => ' '), Iterations => 0, Cycles => 0, Passed => False));
      Overall := True;

      Set_Name (Results (Idx), "GCD_48_18");
      W := Recursive_GCD (48, 18);
      Results (Idx).Passed := W = 6;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 4;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Fib_10");
      W := Recursive_Fibonacci (10);
      Results (Idx).Passed := W = 55;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 177;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Fact_10");
      W := Recursive_Factorial (10);
      Results (Idx).Passed := W = 3628800;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 10;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Pow_2_10");
      W := Recursive_Power (2, 10);
      Results (Idx).Passed := W = 1024;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 10;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Sum_100");
      W := Recursive_Sum (100);
      Results (Idx).Passed := W = 5050;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 100;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "GCD_Large");
      W := Recursive_GCD (1071, 462);
      Results (Idx).Passed := W = 21;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 6;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Fib_20");
      W := Recursive_Fibonacci (20);
      Results (Idx).Passed := W = 6765;
      Results (Idx).Iterations := 1;
      Results (Idx).Cycles := 21891;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "Safe_Add_Bench");
      declare
         Ov : Boolean; R : Word32;
      begin
         for I in 1 .. 1000 loop
            R := Math_Utils.Safe_Add (Word32 (I), Word32 (I), Ov);
         end loop;
         Results (Idx).Passed := not Ov;
         Results (Idx).Iterations := 1000;
         Results (Idx).Cycles := 1000;
      end;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Set_Name (Results (Idx), "ISqrt_Bench");
      for I in 1 .. 100 loop
         W := Math_Utils.ISqrt (Word32 (I) * 100);
      end loop;
      Results (Idx).Passed := W = 100;
      Results (Idx).Iterations := 100;
      Results (Idx).Cycles := 100;
      if not Results (Idx).Passed then Overall := False; end if;
      Idx := Idx + 1;

      Count := Idx;
   end Run_Benchmarks;

   procedure Report_Benchmarks (Results : Bench_Results; Count : Natural; Overall : Boolean) is
      Name_Str : String (1 .. 64); Name_Len : Natural;
   begin
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put_Line ("=== SOVEREIGN RTX BENCHMARK SUITE ===");
      Ada.Text_IO.Put_Line ("Benchmarks: " & Natural'Image (Count));
      Ada.Text_IO.Put_Line ("------------------------------------");
      for I in 0 .. Count - 1 loop
         Name_Len := 0;
         for J in Results (I).Name'Range loop
            if Results (I).Name (J) /= ' ' then Name_Len := J + 1; end if;
         end loop;
         if Name_Len > 0 then
            Name_Str := (others => ' ');
            for J in 0 .. Name_Len - 1 loop
               Name_Str (J + 1) := Results (I).Name (J);
            end loop;
            if Results (I).Passed then
               Ada.Text_IO.Put_Line ("  [PASS] " & Name_Str (1 .. Name_Len) &
                  "  iters=" & Word32'Image (Results (I).Iterations) &
                  "  cycles=" & Word32'Image (Results (I).Cycles));
            else
               Ada.Text_IO.Put_Line ("  [FAIL] " & Name_Str (1 .. Name_Len));
            end if;
         end if;
      end loop;
      Ada.Text_IO.New_Line;
      if Overall then
         Ada.Text_IO.Put_Line ("RESULT: ALL BENCHMARKS PASSED");
      else
         Ada.Text_IO.Put_Line ("RESULT: SOME BENCHMARKS FAILED");
      end if;
   end Report_Benchmarks;

end Benchmark;