WITH Ada.Text_IO; USE ADA.Text_IO;
WITH Ada.Integer_Text_IO; USE ADA.Integer_Text_IO;
WITH Ada.Float_Text_IO; USE Ada.Float_Text_IO;
with ada.Unchecked_Deallocation;
with P_SIMU_ATELIER_io; use P_SIMU_ATELIER_io;
with P_SEMAPHORE; use P_SEMAPHORE;
with p_fifo;
--with P_SIMU_ATELIER_IO; use P_SIMU_ATELIER_IO;




procedure soupe is

   package p_fifo_piece is new p_fifo(T_PIECE);
   use p_fifo_piece;



   semaphorePiece : Semaphore_exclusion_mutuelle ;
   file : T_fifo ;


   task S_Am is
      entry init (numGamme : T_NUM_GAMME ; numPiece : T_NUM_PIECE) ;
      entry prendre(numCellule:T_Num_Cellule) ;
      entry fin_prendre(numCellule:T_Num_Cellule) ;
      entry Transfert(pieceTour:in out T_PIECE) ;
   end S_Am;

   task S_Av is
      entry poser(numCellule:T_Num_Cellule; piece :T_piece) ;
      entry fin_poser(numCellule:T_Num_Cellule) ;
   end S_Av;

   task T_R_G is

      entry poser(numCellule:T_Num_Cellule; numTour:T_NUM_TOUR; pieceTour:in out T_PIECE); --idem que précedemment, prend en entrée les paramètres nécessaires pour les différentes procédures
      entry fin_poser(numCellule:T_Num_Cellule; numTour:T_Num_Tour);
   end T_R_G;

   task T_R_D is

      entry prendre(numCellule:T_Num_Cellule;  numTour:T_Num_Tour); --le robot prend de la tour et le place dans le stock aval
      entry fin_prendre(numCellule:T_Num_Cellule;  numTour:T_Num_Tour; piece: T_PIECE); --le robot finit dde prendre
   end T_R_D;


   task body S_Am is
      piece : T_PIECE;
   begin



      loop
         select

            accept init(numGamme : T_NUM_GAMME ; numPiece : T_NUM_PIECE) do
               piece.num_piece := numPiece ;
               piece.num_gamme := numGamme ;
               file.POSER(piece);
            end init;
         or
            accept prendre(numCellule:T_Num_Cellule) do

               file.PRENDRE(piece);
               deplacer_robot(numCellule, 1, repos, STOCK_AMONT_1); --on déplace le robot vers le stock amont
               fermer_pince(numCellule,1);

            end prendre;
            accept fin_prendre(numCellule:T_Num_Cellule) do
               --on ferme la pince, implicitement cela veut dire que la matière première a été prise

               deplacer_robot(numCellule,1,STOCK_AMONT_1,REPOS); --on déplace le robot vers la position de repos : le chargement de la tour se fait donc en deux temps

            end fin_prendre;
         or
            accept Transfert(pieceTour : in out T_PIECE) do
               pieceTour.num_gamme:=piece.Num_Gamme ;
               pieceTour.num_piece:=piece.Num_Piece;
            end Transfert ;
         or
            terminate;
         end select;

      end loop;
   end S_Am;

   task body S_Av is
   begin
      loop
         select
            accept poser(numCellule:T_Num_Cellule; piece : T_PIECE) do


               deplacer_robot(numCellule,2,repos,STOCK_AVAL_1) ;
               ouvrir_pince(numCellule,2);
               file.POSER(piece) ;
             --  Put_Line("Num piece : " & integer'image(T_Num_Piece'pos(piece.num_piece)));

                     --   Put_Line("Num gamme : " & integer'image(T_Num_Gamme'pos(piece.num_gamme)));
                          end poser ;

                          accept fin_poser(numCellule:T_Num_Cellule) do

                          deplacer_robot(numCellule,2, STOCK_AVAL_1, REPOS);


                          end fin_poser;
                          or
                          terminate;
                          end select;
                          end loop;
                          end S_Av;



                          task body T_R_G is


                          begin

                          loop
                          select


                          accept poser(numCellule:T_Num_Cellule; numTour:T_Num_Tour; pieceTour:in out T_PIECE) do --same
                          S_Am.prendre(1);
                          S_Am.fin_prendre(1);
                          S_am.Transfert(pieceTour) ;
                          deplacer_robot(numCellule, 1, repos, T_LIEU'val(numTour)); -- on déplace le robot vers la tour concernée
                          engager_robot(numCellule, 1, numTour); -- on engage le robot

                          serrer_mandrin(numCellule,numTour);
                          ouvrir_pince(numCellule, 1); -- on ouvre la pince



                          end poser;

                          accept fin_poser(numCellule:T_Num_Cellule ; numTour:T_Num_Tour) do
                          desengager_robot(numCellule,1,numTour); --on désengage


                          deplacer_robot(numCellule,1,T_Lieu'val(numTour),repos); --on le fait revenir en position de repos
                          end fin_poser;
                          or



                          terminate ;
                          end select;
                          end loop;

                          end T_R_G;

                          task body T_R_D is

                          begin
                          loop
                          select

                          accept prendre(numCellule:T_Num_Cellule;  numTour:T_Num_Tour) do
                          deplacer_robot(numCellule,2,repos,T_Lieu'val(numTour));
                          engager_robot(numCellule,2,numTour);
                          fermer_pince(numCellule,2) ;

                          end prendre;

                          accept fin_prendre(numCellule:T_Num_Cellule;  numTour:T_Num_Tour ; piece:T_piece) do
                          DESSERRER_MANDRIN(numCellule,numTour) ;
                          desengager_robot(numCellule,2,numTour);
                          deplacer_robot(numCellule,2,T_Lieu'val(numTour),repos);
                          S_Av.poser(1,piece);
                          S_Av.fin_poser(1);

                          end fin_prendre;
                          end select;
                          end loop;



                          end T_R_D;




   task type T_Tours ;

   type T_T_Tours is array(1..3) of T_Tours;
   type ptr is access T_T_Tours ;

   tableauTours : T_T_Tours;
   x : ptr := new tableauTours ;

   -- tableauTours(1).T_R_G.poser(1, T_Num_Tour'val'2);


                          task body T_Tours is

                          pieceBis:T_PIECE;
                          numGamme, numPiece:integer:=0;
                          --numPiece:T_Num_Piece:=T_Num_Piece'first;
                          begin

                          loop
                          for i in 1..3 loop
                          S_Am.init(T_Num_Gamme'val(numGamme),T_Num_Piece'val(numPiece));
                          T_R_G.poser(1,T_Num_Tour'val(i),pieceBis);
                          T_R_G.fin_poser(1,T_Num_Tour'val(i));


                          usiner(1,T_Num_Tour'val(i),pieceBis);
                          numGamme:=numGamme+1;
                          numPiece:=numPiece+1;

                         -- if numGamme=T_Num_Gamme'last then
                          --numGamme:=0; end if;
                          --if numPiece=T_Num_Piece'last then
                          --numPiece:=0;
                          --end if;






                          T_R_D.prendre(1,T_Num_Tour'val(i));
                          T_R_D.fin_prendre(1,T_Num_Tour'val(i),piecebis);





                          end loop;
                          end loop;
   end T_Tours;




                          begin

                          --  semaphorePiece.init(1);


                          --for i in 1..5 loop
                          -- for j in 1..5 loop


                          --  S_Am.init(T_Num_Gamme'val(i),T_Num_Piece'val(j));

                          null;
                          --end loop;
                          --end loop;









                          end soupe;