with Ada.Text_IO; use Ada.Text_IO;

package Vector is

    -- explication:
    -- Nous avons choisit de créer des sous-modules simplement pour pouvoir tout regroupe dans un seul fichier
    -- Nous avons aussi séparé les vecteurs d'entiers des vecteurs de flottant, car créer un seul et unique module permettant
    -- la gestion d'entier ou de flottant était trop compliqué. Le code aurait été plus compliqué à lire.
    -- nous avons alors choiss de séparer comme ceci le code, bien que cela produise du code un peu redondant.

    generic

        Capacite: Positive;
    
    package Entier is

        type T_Vecteur is array (0..Capacite-1) of Natural;

        -- permet d'initialiser le vecteur avec pour tout i, vec[i] = value
        procedure initialize(vec: in out T_Vecteur; value: in Natural);

        -- permet d'initialiser le vecteur avec pour tout i, vec[i] = i
        procedure identity(vec: in out T_Vecteur);

        -- permet de renverser le vecteur, équivalent vec[::-1] en python
        procedure flip(vec: in out T_Vecteur);

        -- procédure permettant d'afficher les vecteurs et d'écrire dans des fichiers
        procedure put(vec: in T_Vecteur);
        procedure put(file: in out Ada.Text_IO.File_Type; vec: in T_Vecteur);

        -- procédure permettant de trier le vecteur selon l'algorithme de quicksort
        procedure quicksort(vec: in out T_Vecteur; low: Natural := 0; high: Natural := Capacite-1);

    end Entier;



    generic

        type T_Digit is digits <>;
        Capacite: Positive;
        with package Vector_Entier is new Vector.Entier(Capacite => Capacite);

    package Digit is

        -- on permet l'affichage direct des T_Digit
        package Text_T_Element is
            new Ada.Text_IO.Float_IO(Num => T_Digit);
        use Text_T_Element;       

        type T_Vecteur is array (0..Capacite-1) of T_Digit;

        procedure initialize(vec: in out T_Vecteur; value: in T_Digit);

        -- 
        function sum(vec: in T_Vecteur) return T_Digit;


        procedure flip(vec: in out T_Vecteur);

        procedure put(vec: in T_Vecteur);
        procedure put(file: in out Ada.Text_IO.File_Type; vec: in T_Vecteur);

        procedure quicksort(vec: in out T_Vecteur; low: Natural := 0; high: Natural := Capacite-1);

        -- procédure permettant de trier le vecteur selon l'algorithme quicksort et aussi de récupérer les indices triés.
        procedure quicksort(vec: in out T_Vecteur; vec_index: in out Vector_Entier.T_Vecteur;
                            low: Natural := 0; high: Natural := Capacite-1);

    end Digit;



    -- nous avons choisis de modéliser le réseau via cette structure d'un vecteur d'enregistrement plutot que d'un matrice
    -- avec deux colonnes car de cette manière le trie du réseau est plus simple.

    generic

        Capacite: Positive;
    
    package Link is

        type T_Link is record
           from: Natural;
           to: Natural;
        end record;

        type T_Vecteur is array (0..Capacite-1) of T_Link;
        
        procedure put(vec: in T_Vecteur);

        procedure is_sorted_and_uniq(vec: in T_Vecteur; dupe: out Natural; sorted: out Boolean);
        function "<"(left, right: in T_Link) return Boolean;
        procedure quicksort(vec: in out T_Vecteur; low: Natural := 0; high: Natural := Capacite-1);

    end Link;

end Vector;