create or replace package sqlru_workers authid definer
is
 
-- booby 22.12.2021

 Type T_Worker_Spc Is Record( speed number -- время обработки одной коробки в минутах
                            , capacity number -- число коробок обрабатываемых без перерыва
                            , delay number -- перерыв в минутах после обработки capacity коробок
                            );

 --------------------                               
 TYPE T_WRK_CURSOR IS REF CURSOR RETURN T_Worker_Spc;
 -----
/*
  вернет отрицательный результат, если для заказанного положительного объема pN 
  не найдется работников в курсоре pcrs вообще
  пример вызова:
select sqlru_workers.get_min_wrk_time(pcrs => CURSOR(
                                                      select speed, capacity, delay 
                                                      From 
                                                      (select 1 as speed, 2 as capacity, 3 as delay from dual
                                                      union all select 3, 10, 3 from dual
                                                      union all select 2, 4, 3 from dual) w
                                                       )
                         , pN => 10        -- число коробок
                          )
from dual 
*/
 function get_min_wrk_time(pcrs in T_WRK_CURSOR -- курсор с работничками
                         , pN in Number        -- число коробок
                          ) Return Number; 

end sqlru_workers;
/
create or replace package body sqlru_workers is

 TYPE T_WORKERS_PLDICT is table of T_Worker_Spc index by pls_integer; 

 Type T_Worker_State Is Record( inum pls_integer -- номер работника в списке работников
                              , current_capacity Number -- текущее число обработанных коробок работником
                              , next_avalible Number -- следующее время доступности работника
                              );
 TYPE T_wrk_states is table of T_Worker_State Index by pls_integer;
 
 -- вернет отрицательный результат, если для заказанного положительного объема pN 
 -- не найдется работников в курсоре pcrs вообще
 function get_min_wrk_time(pcrs in T_WRK_CURSOR -- курсор с работничками
                         , pN in Number        -- число коробок
                          ) Return Number
 Is
   nstop_time Number := 0.0;
   N Number := Coalesce(pN, 0.0);
   a_workers T_WORKERS_PLDICT; -- работнички
   a_wrkstate T_wrk_states;     -- их рабочее состояние
   --
   ncur_time Number := 0.0; -- текущее время
   r_worker T_Worker_State;

  ------------------------------------------------------------------------------
  -- процедуры работы с очередью занятых работников
  -------------------------------------------
  Function Is_Empty(pa_wrk_states in T_wrk_states) return Boolean
    is
  Begin
    Return pa_wrk_states.COUNT = 0;
  End;
  -- получение индекса родителя
  function get_parent_idx(p_idx_in in Pls_integer) return Pls_integer Deterministic
    is
  begin
    return Floor(0.5*(p_idx_in));
  end;  
  -- копирование элемента 
  Procedure Copy_ItemTo(pa_array in out nocopy T_wrk_states
                      , pi_from in Pls_integer -- индекс с которого копируется элемент
                      , pi_to in Pls_Integer   -- индекс в который копируется элемент
                      )
  is
  Begin
    pa_array(pi_to) := pa_array(pi_from);
  End;   
  -- сравнение элементов по значению
  Function Less(pr_parent in T_Worker_State
              , pr_child in T_Worker_State
               ) Return Boolean
  Is
  Begin          
    Return Case 
             When  pr_child.next_avalible < pr_parent.next_avalible 
               Then True
             When pr_child.next_avalible = pr_parent.next_avalible       
               Then (a_workers(pr_child.inum).speed < a_workers(pr_parent.inum).speed)
           Else False
           End;
  End;  
  -- всплытие с указанной позиции
  Procedure Swim( pa_array in out nocopy T_wrk_states
                , pi_from in Pls_integer
                )
  is
    i_flow Pls_integer;
    i_parent Pls_integer;
    r_temp T_Worker_State;
  Begin
    i_flow := pi_from;
    i_parent :=  get_parent_idx(i_flow);
    r_temp := pa_array(pi_from);    
    
    While i_flow > 1
        And Less( pr_parent => pa_array(i_parent)
               ,  pr_child => r_temp 
                )   
    Loop
      pa_array(i_flow) := pa_array(i_parent); 
      i_flow := i_parent;
      i_parent := get_parent_idx(i_flow);
    End Loop;
    
    If i_flow != pi_from
      Then
      pa_array(i_flow) := r_temp; 
    End if;      
    
  End;    
  -- погружение с указанной позиции  
  Procedure Sink(pa_array in out nocopy T_wrk_states
                , pi_from in Pls_integer
                 )
  Is
    i_flow Pls_integer;
    i_child Pls_integer;
    i_lastPos Pls_integer;

    r_temp T_Worker_State;
  Begin
    i_lastPos := pa_array.COUNT;
    i_flow := pi_from;   
    If i_flow <= i_lastPos
      Then
      r_temp := pa_array(pi_from);
      While (i_flow + i_flow ) <= i_lastPos
      Loop
        i_child := (i_flow + i_flow); 

        If i_child < i_lastPos
            And Less( pr_parent => pa_array(i_child)
                    , pr_child =>  pa_array(i_child+1)
                    )
          Then
            i_Child := i_child + 1;
        End If;
        
        Exit When Not Less( pr_parent => r_temp
                         ,  pr_child => pa_array(i_Child)
                          ); 
                          
        Copy_ItemTo(pa_array => pa_array, pi_from => i_child, pi_to => i_flow);
        i_flow := i_child;

      End Loop;

      If i_flow != pi_from
        Then
        pa_array(i_flow) := r_temp; 
      End If;   
    End If; 
    --
  End;
  --------------------------------------------------  
  -- удаление и возврат максимального элемента
  Procedure delMax(pa_array in out nocopy T_wrk_states
                 , pr_Key_out OUT NOCOPY T_Worker_State
                   )
  Is
    i_rootPos Pls_integer := 1; --- индекс корня
    ilastPos Pls_integer; -- индекс последнего элемента
  Begin

    ilastPos := pa_array.COUNT;
    -- возвращаемое (снимаемое) значение
    pr_Key_out :=  pa_array(i_rootPos);

    Copy_ItemTo(pa_array => pa_array, pi_from => ilastPos, pi_to => i_rootPos); 
    pa_array.Delete(ilastPos);
    Sink(pa_array, i_rootPos); 
    Return;
  End;  

  -- постановка работы в очередь ожидания завершения
  Procedure Insert_Q(pa_array in out nocopy  T_wrk_states, pr_Key in T_Worker_State)
  Is
    ilastPos Pls_integer;
  Begin
    ilastpos := Coalesce(pa_array.Last + 1, 1 );
    pa_array(ilastpos) := pr_Key;
    Swim( pa_array => pa_array, pi_from => ilastpos);
    Return;
  End;

   -- получение следующего освободившегося работника
  Function get_Next_Event( pa_evt In OUT Nocopy T_wrk_states ) return T_Worker_State
    Is
    r_ret T_Worker_State; 
  Begin    
    If Not Is_Empty(pa_evt) Then
       delMax(pa_evt, r_ret);
    End If;
    Return r_ret;
  End;
 ---------------------------------------------------
   -- подготовка состояния работников 
   -- с одновременной загрузкой их начальной работой
   procedure prepare_workers
   Is
    r_worker T_Worker_State;
   Begin  
     nstop_time := -1.0;
     fetch pcrs Bulk Collect Into a_workers;
     If a_workers.count > 0 Then
       nstop_time := 0.0;       
       For i in 1..a_workers.count
       Loop
         r_worker.inum := i;
         r_worker.current_capacity := 1;
         r_worker.next_avalible := a_workers(i).speed;
         
         Insert_Q(pa_array => a_wrkstate, pr_Key => r_worker);       
         -- nstop_time := Greatest(nstop_time, r_worker.next_avalible);         
         N := N-1;         
         Exit When N <= 0;
       End Loop;  
     End If;       
   End;  
  
 Begin -- основное тело 
   If N > 0.0 Then
     prepare_workers;
     If a_workers.count > 0
       Then        
        Loop
          r_worker := get_Next_Event(a_wrkstate);
          ncur_time := r_worker.next_avalible;
          
          If r_worker.current_capacity < a_workers(r_worker.inum).capacity
            Then
              r_worker.current_capacity := r_worker.current_capacity + 1;
              r_worker.next_avalible := r_worker.next_avalible + a_workers(r_worker.inum).speed;
              N := N-1;
          Else
             r_worker.current_capacity := 0; 
             r_worker.next_avalible := r_worker.next_avalible + a_workers(r_worker.inum).delay;              
          End If;     
          -- поставить обратно в очередь ожидания выполнения работ
          Insert_Q(pa_array => a_wrkstate, pr_key => r_worker );
          Exit When N <=0;
        End Loop;
        -- цикл съема результата 
        While Not Is_Empty(a_wrkstate)
        Loop
          r_worker := get_Next_Event(a_wrkstate);
          If r_worker.current_capacity > 0
            Then
            nstop_time := Greatest(nstop_time, r_worker.next_avalible);         
          End If;
        End Loop;    
     End If;    
   End If;
   Return nstop_time;
 End;  

end sqlru_workers;
/