with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

package Argument_Parser is

   type Option is interface;

   function Parse (I : String) return Option is abstract;

   type Argument_Parser is tagged private;

   function Parse (T : Argument_Parser) return Boolean;

   function Find (T : Argument_Parser; Key : String) return Option'Class;

   type Count is range 0 .. 2**31 - 1;

   procedure Add_Positional (
      Parser : in out Argument_Parser;
      Input_Type : Option'Class;
      Key : string;
      Collect_Further_Inputs : Boolean := False);

   procedure Add_Boolean_Option (
      Parser : in out Argument_Parser;
      Short_String : string;
      Long_String : string);

   procedure Add_Count_Option (
      Parser : in out Argument_Parser;
      Short_String : string;
      Long_String : string;
      Start_Count : Count := 0);

   procedure Add_Option (
      Parser : in out Argument_Parser;
      Input_Type : Option'Class;
      Short_String : string;
      Long_String : string);

   type String_Option is new Option with
      record
         Value : Unbounded_String;
      end record;

   overriding
   function Parse (I : String) return String_Option;

   function Value (O : String_Option) return String;

   type Integer_Option is new Option with
      record
         Value : Integer;
      end record;

   overriding
   function Parse (I : String) return Integer_Option;

   function Value (O : Integer_Option) return Integer;

   type Float_Option is new Option with
      record
         Value : Float;
      end record;

   overriding
   function Parse (I : String) return Float_Option;

   function Value (O : Float_Option) return Float;

private

   type Argument_Parser is tagged null record;

end Argument_Parser;