with Ada.Text_IO;

procedure Pierre is
--  Je vais commencer par traiter la version récursive

--  ###############################VOTRE CODE##################################
--  function Palindrome(Mot : in String(Mot'First..Mot'Last)) return Boolean is
--  ###############################VOTRE CODE##################################

--  Ici, vous n'avez pas besoin de contraindre le type String. En fait, on se fout de la taille qu'il
--  fait étant donné qu'on va le traiter indépendamment de cette information. De plus, la syntaxe que
--  vous utilisez ici est une tautologie, vous dites en gros : tu vas recevoir une chaîne de caractères
--  dont la qui commence à son premier caractère et fini à son dernier caractère. Ada ne saura pas vraiment
--  quoi faire de cette information, et va donc râler avec une insulte du genre :
--  pierre.adb:20:44: constraint not allowed here
--  Pour éviter ca, on va l'écrire comme ça, tout simplement  (au passage, on peut se passer du in étant donné
--  qu'il s'agit d'une fonction, elle n'est donc pas susceptible de modifier Mot) :
    function Palindrome(Mot : String) return Boolean is
    Trouver : Boolean;
    begin
        --##############VOTRE CODE##################
        --if Mot'Length /= 0 or Mot'Length /= 1 then
        --##############VOTRE CODE##################

        -- Attention, ici vous avez inversé la logique du test : le cas trivial
        -- est celui où il reste un mot de longueur 0 ou 1, ici vous dites "si il
        -- y a un mot dont la longueur n'est ni 0 ni 1, on est dans le cas trivial"
        -- La bonne version est la suivante :
        if Mot'Length = 0 or Mot'Length = 1 then
            Trouver := True;
        else
            if Mot(Mot'First) = Mot(Mot'Last) then
                -- Ici il y avait une erreur de syntaxe, ce n'est pas directement
                -- First + 1 et Last + 1 mais Mot'First + 1 et Mot'Last - 1,
                -- mais j'ai supposé que vous ne l'aviez pas écrit par flemme étant
                -- donné que vous le faites correctement avec 'Length.
                Trouver := Palindrome(Mot(Mot'First + 1 .. Mot'Last - 1));
            -- Il y a le cas où le test Mot(Mot'First) = Mot(Mot'Last) est faux,
            -- dans ce cas la variable Trouver doit valoir False. Or, comme vous
            -- ne l'initialisez pas à la déclaration directement à False, il faut
            -- absolument rajouter un else, sinon le cas n'est pas géré :
            else
                Trouver := False;
            end if;
        end if;
        return Trouver;
    end Palindrome;


--  Ici, il y avait la même erreur que plus haut, dans la signature de la fonction. Je corrige ici aussi,
--  l'explication est similaire.
    function PalindromeIteratif(Mot : String) return Boolean is
    Trouver : Boolean := False;
    Compteur : Natural := 0;
    begin
    -- Ici, la logique ne convient pas, effectivement.
    -- Déjà, imaginons le mot suivant : baobab
    -- Votre fonction va entrer dans la boucle, on a bien
    -- Mot(Compteur) = Mot(Mot'Last - 1), donc Trouver va passer à True et ...
    -- votre boucle est terminée, la fonction vous dit que c'est un palindrome,
    -- game over, ce n'en est pas un.
    -- Ici, vous regardez à chaque fois Mot(Mot'Last - 1), donc vous comparez également
    -- tout le temps avec l'avant dernière lettre. Il faut : Mot(Mot'Last - Compteur)
    -- Ensuite, votre façon de calculer l'indice à examiner n'est pas bonne :
    -- en effet, en ADA on peut faire commencer un tableau à n'importe quel indice.
    -- Si un gars bizarre vous file une chaîne dont Mot'First vaut 4, par exemple,
    -- votre calcul (Mot'Last - Mot'First) / 2 (qu'au passage, on pourrait remplacer par
    -- Mot'Length / 2 ) va vous donner une boucle qui examine les éléments de l'indice 1
    -- à l'indice Mot'Length / 2. Or, l'indice 1 n'existe pas, la fonction va planter.
    -- Il vaut mieux calculer l'indice à examiner en faisant Mot(Mot'First + Compteur),
    -- et du coup votre incrémentation de compteur doit être faite après le test.

    while not Trouver and Compteur <= (Mot'Last - Mot'First) / 2 loop
            Compteur := Compteur + 1;
            -- Ce type de test est superflu : Mot(Compteur) = Mot(Mot'Last - 1) est déjà un booléen.
            -- vous pouvez donc écrire :
            -- Trouver := Mot(Compteur) = Mot(Mot'Last - 1)
            if Mot(Compteur) = Mot(Mot'Last - 1) then
                Trouver := True;
            else
                Trouver := False;
            end if;
        end loop;
        return Trouver;

    end PalindromeIteratif;

    -- Je vous propose la version suivante, qui est assez proche de ce que vous vouliez faire mais qui évite
    -- les quelques soucis que j'ai mentionné.
    function PalindromeIteratifCorrige(texte: String) return Boolean is
    Compteur : Integer := 0;
    Erreur : Boolean := False;
    begin
        if texte'Length = 0 then
            Erreur := False;
        else
            while not Erreur and Compteur <= texte'Length / 2 loop
                Erreur := not (texte(texte'First + Compteur) = texte(texte'Last - Compteur));
                Compteur := Compteur + 1;
            end loop;
        end if;
        return not Erreur;
    end PalindromeIteratifCorrige;

    test : String := "baobab";
begin
    Ada.Text_IO.Put_Line(Integer'Image(test'Length/2));
    if PalindromeIteratif(test) then
        Ada.Text_IO.Put_Line("C'est un palindrome");
    else
        Ada.Text_IO.Put_Line("Ce n'est pas un palindrome");
    end if;

end Pierre;