//Zadania z ADy

--zadania cykliczne z wykładów JPI
with Ada.Text_IO, Ada.Real_Time;
use Ada.Text_IO, Ada.Real_Time;

procedure Co_Pol_Sek is

    procedure bla is
    begin
        delay 0.3;
        Put_Line("Bla");
    end;

    Loop_Time : Time_Span := To_Time_Span(0.5);
    Next_Loop_Time : Time;
begin
    Next_Loop_Time := Clock;
    loop
        bla;

        Next_Loop_Time := Next_Loop_Time + Loop_Time;
        delay until Next_Loop_Time;
    end loop;
end Co_Pol_Sek;

--obrazek
with Ada.Text_IO;
use Ada.Text_IO;

type PIC is array (POSITIVE range <>, POSITIVE range <>) of INTEGER;
type PIC_Acc is access PIC;

task type wykonaj is
    entry start(Picture_Acc: PIC_Acc; poczatek, koniec, rozmiar_kolumny : Integer);
    entry koniec;
end wykonaj;

task body wykonaj is
    local_Img_Acc : PIC_Acc;
    local_poczatek, local_koniec, local_rozmiar : Integer;
begin
    accept start(Picture_Acc: PIC_Acc; poczatek, koniec, rozmiar_kolumny : Integer) do
        local_Img_Acc := Picture_Acc;
        local_poczatek := poczatek;
        local_koniec := koniec;
        local_rozmiar := rozmiar_Kolumny;
    end start;

    for i in Integer range local_poczatek..local_koniec loop
        for j in Integer range 1..local_rozmiar loop
            local_Img_Acc(i, j) := 255 - local_Img_Acc(i, j);
        end loop;
    end loop;

    accept koniec;
end;

procedure inwersja(Picture: PIC_Acc; X, Y, Count: in Integer) is
    Step: Integer;
    Taski : Array(1..Count) of wykonaj;
begin
    Step := X / Count;
    for i in 1..Count loop
        if (i = Count) then
            Taski(i).start(Picture,step*(i-1),X,Y);
        else
            Taski(i).start(Picture,step*(i-1),step*i,Y);
        end if;
    end loop;

    for i in 1..Count loop
        Taski(i).koniec;
    end loop;
end;



--przeterminowane wywołanie wejscia
select
    FixWorld(W:World);
or delay 5000
    Put_Line("Nie zostało zakoncozne");
end select;

--policzenie macierzy równolegle

--wywołanie wejść procesów
procedure zad1 is

task type A is
  entry E;
end;

task body A is
begin
  accept E;
end;

procesy: array(Integer range 1..10) of A;
begin
  for i in 1..10 loop
    procesy(i).E;
  end loop;
end zad1;

--normalizacja próbki dźwięku
procedure normalize(sound: in out SND, n: in POSITIVE) is
  task type worker is
    entry set(sound: in SND, max in Sample);
    entry get(sound: out SND);
  end;
  task body worker is
    samples: SND;
    maxSample: Sample;
  begin
    accept set(sound: in SND, max in Sample)
      samples := sound;
      maxSample := max;
    end;
    for i in samples'Range
      samples(i) := samples(i) * 1/maxSample;
    end
    accept get(sound: out SND)
      sound := samples
    end
  end;

  tasks: array(1..n) of worker
  max: Sample;
  spacing: Positive;
  partialResult: SND;


begin
  max := sound(sound'First);
  for i in sound'Range do
    if max < sound(i) then
      max := sound(i);
    end;
  end;

  spacing := sound'length mod n;

  for i in 1..(n-1) do
    tasks(i).set(sound((sound'first + (i-1) * spacing)..(sound'first + i * spacing - 1)), max);
  end;
  tasks(n).set(sound( (sound'first + (n-1) * spacing)..sound'last ), max);

  for i in 1..(n-1) do
    tasks(i).get(partialResult);
    sound((sound'first + (i-1) * spacing)..(sound'first + i * spacing - 1)) := partialResult;
  end;
  tasks(n).get(partialResult);
  sound( (sound'first + (n-1) * spacing)..sound'last) := partialResult;

end


-- obsługa przerwań
protected Sensor is
    procedure Int_Handler;
    pragma Attach_Handler(Int_Handler, InterruptID);
private
    -- ...
end;

protected body Sensor is
    procedure Int_Handler is
    begin
        -- ...
    end;
    -- ...
end;