with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Synchronous_Task_Control; use Ada.Synchronous_Task_Control;

procedure Lab1 is
  N: integer := 4;

  P: integer := 2;
  H: integer := N/P;

  a: integer; -- 2 stream
  e: integer; -- 1 stream

  type Int_Vector is array (1..N) of Integer;
  type Int_Matrix is array (1..N) of Int_Vector;

  MatrixA: Int_Matrix; -- 1 stream
  MatrixK: Int_Matrix; -- 2 stream
  MatrixR: Int_Matrix; -- 2 stream
  MatrixO: Int_Matrix; -- 1 stream

  Left: Int_Matrix;
  Matrix: Int_Matrix;
  Right: Int_Matrix;

  Sem1, Sem2, Sem3, Skd: Suspension_Object;

  --filling matrix
  function fill_matrix(number: integer) return Int_Matrix is
  matr: Int_Matrix;
  begin
    for i in 1..N loop
      for j in 1..N loop
        matr(i)(j) := number;
      end loop;
    end loop;
    return matr;
  end fill_matrix;

  --printing matrix
  procedure print_matrix(matr: Int_Matrix) is
  begin
    for i in 1..N loop
      for j in 1..N loop
        put(matr(i)(j));
      end loop;
      new_line(1);
    end loop;
  end print_matrix;

  --multilpy matrix by number
procedure multiply_half_matrix_by_number(matr: Int_Matrix; number: integer;half: integer;res: out Int_Matrix) is
    i: integer := 0;
    j: integer := 0;
  begin
    if half = 0 then
      --if even
      if N mod 2 = 0 then
        for i in 1..N/2 loop
          for j in 1..N loop
            res(i)(j) := number * matr(i)(j);
          end loop;
        end loop;
        --if odd
      else
        for i in 1..N/2+1 loop
          for j in 1..N loop
            res(i)(j) := number * matr(i)(j);
          end loop;
        end loop;
      end if;
    else
      --if even
      if N mod 2 = 0 then
        for i in N/2+1..N loop
          for j in 1..N loop
            res(i)(j) := number * matr(i)(j);
          end loop;
        end loop;
        --if odd
      else
        for i in N/2+2..N loop
          for j in 1..N loop
            res(i)(j) := number * matr(i)(j);
          end loop;
        end loop;
      end if;
    end if;
  end multiply_half_matrix_by_number;

  procedure add_half_matrix_to_matrix(matr1: Int_Matrix; matr2: Int_Matrix;half: integer;res: out Int_Matrix) is
      i: integer := 0;
      j: integer := 0;
    begin
      if half = 0 then
        --if even
        if N mod 2 = 0 then
          for i in 1..N/2 loop
            for j in 1..N loop
              res(i)(j) := matr1(i)(j) + matr2(i)(j);
            end loop;
          end loop;
          --if odd
        else
          for i in 1..N/2+1 loop
            for j in 1..N loop
              res(i)(j) := matr1(i)(j) + matr2(i)(j);
            end loop;
          end loop;
        end if;
      else
        --if even
        if N mod 2 = 0 then
          for i in N/2+1..N loop
            for j in 1..N loop
              res(i)(j) := matr1(i)(j) + matr2(i)(j);
            end loop;
          end loop;
          --if odd
        else
          for i in N/2+2..N loop
            for j in 1..N loop
              res(i)(j) := matr1(i)(j) + matr2(i)(j);
            end loop;
          end loop;
        end if;
      end if;
    end add_half_matrix_to_matrix;

  procedure multiply_half_matrix_by_matrix(matr1: Int_Matrix; matr2: Int_Matrix; half: integer;res: out Int_Matrix) is
      i: integer := 0;
      j: integer := 0;
    begin
      if half = 0 then
        --if even
        if N mod 2 = 0 then

          for  i in 1..N/2  loop
                        for j in 1..N loop
                            res(i)(j) := 0;
                            for k in 1..N loop
                                res(i)(j) := res(i)(j) + (matr1(i)(k) * matr2(k)(j));
                            end loop;
                        end loop;
                    end loop;

          --if odd
        else

          for i in 1..N/2+1 loop
                        for j in 1..N loop
                            res(i)(j) := 0;
                            for k in 1..N loop
                                res(i)(j) := res(i)(j) + (matr1(i)(k) * matr2(k)(j));
                            end loop;
                        end loop;
                    end loop;
end if;
      else
        --if even
        if N mod 2 = 0 then

          for i in N/2+1..N loop
                        for j in 1..N loop
                            res(i)(j) := 0;
                            for k in 1..N loop
                                res(i)(j) := res(i)(j) + (matr1(i)(k) * matr2(k)(j));
                            end loop;
                        end loop;
                    end loop;

          --if odd
        else

          for i in N/2+2..N loop
                        for j in 1..N loop
                            res(i)(j) := 0;
                            for k in 1..N loop
                                res(i)(j) := res(i)(j) + (matr1(i)(k) * matr2(k)(j));
                            end loop;
                        end loop;
                    end loop;

        end if;
      end if;
    end multiply_half_matrix_by_matrix;

  procedure Task_Start is

    task T1;

    task body T1 is
      e1: integer;
      a1: integer;
    begin
      put_line("Process T1 started");
      MatrixO := fill_matrix(1);
      e:=1;
      put_line("Process T1 filled");
      Set_True(Sem1);

      Suspend_Until_True(Sem2);

      Suspend_Until_True(Skd);
      e1:=e;
      a1 := a;
      Set_True(Skd);

      --computations
      put_line("Process T1 can compute");

      Multiply_Half_Matrix_By_Matrix(MatrixK, MatrixR, 0, Matrix);
      multiply_half_matrix_by_number(Matrix, e1, 0, Right);
      multiply_half_matrix_by_number(MatrixO, a1, 0, Left);
      add_half_matrix_to_matrix(Left, Right, 0, MatrixA);

      Suspend_Until_True(Sem3);

    --output
    if N < 30 then
      print_matrix(MatrixA);
    end if;
      put_line("Process T1 finished");
    end T1;

    task T2;

    task body T2 is
      a2: integer;
      e2: integer;
    begin
      put_line("Process T2 started");
      MatrixK := fill_matrix(1);
      MatrixR := fill_matrix(1);
      a := 1;
      put_line("Process T2 filled");
      Set_true(Sem2);
      Suspend_Until_True(Sem1);

      Suspend_Until_True(Skd);
      e2 := e;
      a2 := a;
      Set_true(Skd);
      --computations
      put_line("Process T2 can compute");
      Multiply_Half_Matrix_By_Matrix(MatrixK, MatrixR, 1, Matrix);
      multiply_half_matrix_by_number(Matrix, e2, 1, Right);
      multiply_half_matrix_by_number(MatrixO, a2, 1, Left);
      add_half_matrix_to_matrix(Left, Right,1, MatrixA);

      Set_True(Sem3);
      put_line("Process T2 finished");
    end T2;
  begin
    null;
  end Task_Start;
begin
  put_line("main procedure started");
  Set_True(Skd);
  Task_Start;

end Lab1;