-- -----------------------------------------------------------------------------
-- Copyright (C) 2003-2019 Stichting Mapcode Foundation (http://www.mapcode.com)
-- 
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
-- 
--    http://www.apache.org/licenses/LICENSE-2.0
-- 
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-- -----------------------------------------------------------------------------

-- Mapcode test main program
with Ada.Command_Line, Ada.Text_Io,
     Ada.Strings.Utf_Encoding.Wide_Strings,
     Ada.Strings.Utf_Encoding.Wide_Wide_Strings;
with Ada.Environment_Variables;
with Mapcode_Utils.As_U, Mapcode_Utils.Str_Tools, Language_Utils;
use Mapcode_Utils;
with Countries, Mapcodes.Languages;
procedure T_Mapcode is
  use Mapcodes;

  Argument_Error : exception;

  Max_Precision : constant Mapcodes.Precisions := Mapcodes.Precisions'Last;

  procedure Usage is
  begin
    Ada.Text_Io.Put_Line (
      "Usage: " & Ada.Command_Line.Command_Name & " <command>");
    Ada.Text_Io.Put_Line (
      "  -h                                       // This help");
    Ada.Text_Io.Put_Line (
      "  -t <territory> [ <context> ]             // Territory info");
    Ada.Text_Io.Put_Line (
      "  -s <subdivision>                         // Same subdivisions");
    Ada.Text_Io.Put_Line (
      "  -S <name>                                // Search territory");
    Ada.Text_Io.Put_Line (
      "  -d  <territory_mapcode>                  // Decode");
    Ada.Text_Io.Put_Line (
      "  -c <lat> <lon> [ <options> ]             // Encode");
    Ada.Text_Io.Put_Line (
      "  -a  <territory_mapcode> [ <options> ]    // Alternative mapcodes");
    Ada.Text_Io.Put_Line (
      "  -l  [ <mapcode> [ <language> ] ]         // List or convert into a language");
    Ada.Text_Io.Put_Line (
      "  <territory_mapcode> ::= <territory>:<mapcode> | [ <territory> ] <mapcode>");
    Ada.Text_Io.Put_Line (
      "  <options>           ::= [ <territory> ] [ <selection> ] [ <precision> ]");
    Ada.Text_Io.Put_Line (
      "  <selection>         ::= [ all | local | short] // Default short");
    Ada.Text_Io.Put_Line (
      "                      // short: one mapcode (the shortest) of each territory");
    Ada.Text_Io.Put_Line (
      "                      // all: all the mapcodes of all territories");
    Ada.Text_Io.Put_Line (
      "                      // local: the shortest among all the mapcodes");
    Ada.Text_Io.Put_Line (
      "  <precision>         ::= P0 .. P8               // Default P0 or from input");
    Ada.Text_Io.Put_Line (
      "  <language>          ::= language name (any casing) or num (0 for Roman)");
    Ada.Text_Io.Put_Line (
      "                      // Input language is guessed, default output is Romaic");
  end Usage;

  function Lower_Str (Str : String) return String is
    Offset  : constant Integer   := Character'Pos('A') - Character'Pos('a');
    Result : String := Str;
  begin
    for C of Result loop
      C := (if C not in 'A' .. 'Z' then C
          else Character'Val (Character'Pos(C) - Offset));
    end loop;
    return Result;
  end Lower_Str;

  procedure Put_Territory (Territory, Context : in String;
                           Show_Subdivision : in Boolean) is
    Index : Territories;
  begin
    Ada.Text_Io.Put (Territory
                   & (if Context /= "" then " " else "")
                   & Context &  " ");
    Index := Get_Territory (Territory, Context);
    Ada.Text_Io.Put_Line ("=> " & Get_Territory_Number (Index)
      & ": " & Get_Territory_Alpha_Code (Index, Mapcodes.Local)
      & "/" & Get_Territory_Alpha_Code (Index, Mapcodes.International)
      & "/" & Get_Territory_Alpha_Code (Index, Mapcodes.Shortest)
      & "/" & Get_Territory_Fullname (Index) );
    if Is_Subdivision (Index) then
      Ada.Text_Io.Put_Line ("  Parent: "
          & Get_Territory_Alpha_Code (Get_Parent_Of (Index)));
    end if;
    if Show_Subdivision and then Has_Subdivision (Index) then
      Ada.Text_Io.Put_Line ("  Has subdivisions");
    end if;
  end Put_Territory;

  function Is_Command (Arg : in String) return Boolean is
    (Arg = "-h" or else Arg = "-t" or else Arg = "-s" or else Arg = "-S"
     or else Arg = "-d" or else Arg = "-c" or else Arg = "-a"
     or else Arg = "-l");

  function Image (F : Mapcodes.Real) return String is
  begin
    return F'Img;
  end Image;

  function Quote (Str : String) return String is
    (''' & Str & ''');

  function Get (Str : String) return Mapcodes.Real is
  begin
    return Mapcodes.Real'Value (Str);
  exception
    when Constraint_Error =>
      raise Argument_Error;
  end Get;

  I : Positive;
  Command, Arg1, Arg2 : As_U.Asu_Us;

  Coord : Mapcodes.Coordinate;
  Territory : As_U.Asu_Us;
  Shortest : Boolean;
  Sorted : Boolean;
  Precision : Precisions;
  Opt_Set, Pre_Set : Boolean;

  -- If Arg2 is a mapcode then parse Arg1=Ctx and Arg2=Map
  --  otherwise parse Arg1=[Ctx:]Map
  -- Locate "-" in Map to set Precision
  procedure Parse_Mapcode is
    Index : Natural;
    Tmp : As_U.Asu_Us;
  begin
    I := I + 1;
    Arg1 := As_U.Tus (Ada.Command_Line.Argument (I));
    Arg2.Set_Null;
    Tmp.Set_Null;
    if I < Ada.Command_Line.Argument_Count then
      Tmp := As_U.Tus (Ada.Command_Line.Argument (I + 1));
    end if;
    if Tmp.Locate (".") /= 0 then
      -- Arg2 is a mapcode
      Arg2 := Arg1;
      Arg1 := Tmp;
      I := I + 1;
    end if;
    -- Split <territory>:<mapcode> in Arg1
    if Arg2.Is_Null then
      Index := Arg1.Locate (":");
      if Index > 1 then
        Arg2 :=  Arg1.Head (Index - 1);
        Arg1.Delete (1, Index);
      end if;
    end if;
    -- Get precision from input
    Index := Str_Tools.Locate (Arg1.Image, "-");
    if Index > 0 then
      if Index = Arg1.Length or else Index < Arg1.Length - Max_Precision then
        raise Decode_Error;
      end if;
      Precision := Arg1.Length - Index;
    end if;
    Ada.Text_Io.Put_Line (Arg1.Image & " " & Arg2.Image);
  end Parse_Mapcode;

begin
  if Ada.Command_Line.Argument_Count = 0 then
    raise Argument_Error;
  end if;
  I := 1;
  while I <= Ada.Command_Line.Argument_Count loop
    Command := As_U.Tus (Ada.Command_Line.Argument (I));
    if Command.Image = "-h" then
      Usage;
    elsif Command.Image = "-t" then
      -- Display territory info of next argument(s)
      I := I + 1;
      Arg1 := As_U.Tus (Ada.Command_Line.Argument (I));
      if I < Ada.Command_Line.Argument_Count then
        Arg2 := As_U.Tus (Ada.Command_Line.Argument (I + 1));
        if Is_Command (Arg2.Image) then
          Arg2.Set_Null;
        else
          I := I + 1;
        end if;
      end if;
      Put_Territory (Arg1.Image, Arg2.Image, True);
    elsif Command.Image = "-s" then
      -- Subdirectories with same suffix
      I := I + 1;
      declare
        Brothers : constant Mapcodes.Territories_Array
                 := Mapcodes.Get_Subdivisions_With (
                        Ada.Command_Line.Argument (I));
      begin
        for Brother of Brothers loop
          Put_Territory (Mapcodes.Get_Territory_Alpha_Code (Brother), "",
                         False);
        end loop;
      end;
    elsif Command.Image = "-S" then
      -- Search country names
      I := I + 1;
      Territory.Set (Str_Tools.Upper_Str (Ada.Command_Line.Argument (I)));
      for J in Countries.Territories_Def'Range loop
        if Str_Tools.Locate (Str_Tools.Upper_Str
                               (Countries.Territories_Def(J).Name.Image),
                             Territory.Image) /= 0 then
          -- Territory number is Index - 1
          Put_Territory (Countries.Territories_Def(J).Code.Image, "", True);
        end if;
      end loop;
    elsif Command.Image = "-c"
    or else Command.Image = "-a" then
      -- Default precision for coding
      --  default precision for alternate mode will be deduced from input
      -- In any way it can be superseeded by argument
      Precision := 0;
      if Command.Image = "-c" then
        -- Encode a lat lon
        -- Get coord lat and lon
        I := I + 1;
        Arg1 := As_U.Tus (Ada.Command_Line.Argument (I));
        Coord.Lat := Get (Arg1.Image);
        I := I + 1;
        Arg2 := As_U.Tus (Ada.Command_Line.Argument (I));
        Coord.Lon := Get (Arg2.Image);
        Ada.Text_Io.Put_Line (Image (Coord.Lat)
                      & " " & Image (Coord.Lon));
      else
        -- Alternative mapcodes
        Parse_Mapcode;
        Coord := Decode (Arg1.Image, Arg2.Image);
      end if;
      -- Parse options: Territory, selection and precsion
      Territory := As_U.Asu_Null;
      Opt_Set := False;
      Pre_Set := False;
      -- Default selection: One (shortest) mapcode for each territory,
      --  not sorted
      Shortest := True;
      Sorted := False;
      for J in I + 1 .. Ada.Command_Line.Argument_Count loop
        Arg1 := As_U.Tus (Ada.Command_Line.Argument (J));
        exit when Is_Command (Arg1.Image);
        I := J;
        if Lower_Str (Arg1.Image) = "all" then
          if Opt_Set then
            raise Argument_Error;
          end if;
          -- All mapcodes for each territory, not sorted
          Shortest := False;
          Opt_Set := True;
        elsif Lower_Str (Arg1.Image) = "local" then
          if Opt_Set then
            raise Argument_Error;
          end if;
          -- One (shortest) mapcode for each territory,
          --  sorted i.o. to put the first one
          Sorted := True;
          Opt_Set := True;
        elsif Lower_Str (Arg1.Image) = "short" then
          if Opt_Set then
            raise Argument_Error;
          end if;
          Opt_Set := True;
        elsif Arg1.Length = 2
        and then Arg1.Element (1) = 'P'
        and then Arg1.Element (2) >= '0'
        and then Arg1.Element (2) <= Character'Val (Character'Pos ('0')
                                   + Max_Precision) then
          if Pre_Set then
            raise Argument_Error;
          end if;
          Precision := Precisions'Value (Arg1.Slice (2, 2));
          Pre_Set := True;
        else
          if not Territory.Is_Null then
            raise Argument_Error;
          end if;
          Territory := Arg1;
        end if;
      end loop;
      -- Put mapcodes
      declare
        procedure Put_Code (Code : Mapcodes.Mapcode_Info) is
        begin
          Ada.Text_Io.Put_Line ("=> "
            & Code.Territory_Alpha_Code.Image
            & " " &  Code.Mapcode.Image
            & " " & Quote (Code.Full_Mapcode.Image)
            & " " & Get_Territory_Number (Code.Territory));
        end Put_Code;
        -- Sort if Local
        Codes : constant Mapcodes.Mapcode_Infos
              := Encode (Coord, Territory.Image, Shortest, Precision, Sorted);
      begin
        if Sorted then
          -- Local <=> Sorted, put the first one
          -- First mapcode is the shortest, and then others of the same
          --  territory and then others...
          if Codes'Length /= 0 then
            Put_Code (Codes(Codes'First));
          end if;
        else
          for Code of Codes loop
            Put_Code (Code);
          end loop;
        end if;
      end;
      Ada.Text_Io.New_Line;
    elsif Command.Image = "-d" then
      -- Decode: next argument is mapcode, optionally preceeded by a context
      Parse_Mapcode;
      -- Decode
      Coord := Decode (Arg1.Image, Arg2.Image);
      Ada.Text_Io.Put_Line ("=> " & Image (Coord.Lat)
                          & " " & Image (Coord.Lon));
    elsif Command.Image = "-l" then
      -- Languge conversion
      if I + 1 <= Ada.Command_Line.Argument_Count then
        -- Text is set
        I := I + 1;
        Arg1 := As_U.Tus (Ada.Command_Line.Argument (I));
      else
      -- Text is in ENV (easier with a debugger)
      --  and output language will be default
        begin
          Arg1 := As_U.Tus (Ada.Environment_Variables.Value ("Mapcode"));
        exception
          when others =>
            Arg1.Set_Null;
        end;
      end if;
      if Arg1.Is_Null then
        -- No text and no ENV: list all languages
        for Lang in Mapcodes.Languages.Language_List loop
          declare
            Str : constant String
                := Integer'Image (Mapcodes.Languages.Language_List'Pos (Lang));
          begin
            Ada.Text_Io.Put_Line (
               (if Str'Length = 3 then Str (2 .. 3)
                else '0' & Str (2))
               & " " & Mapcode_Utils.Str_Tools.Mixed_Str (Lang'Img));
          end;
        end loop;
      else
        -- Text is set
        Arg2.Set_Null;
        if I + 1 <= Ada.Command_Line.Argument_Count then
          -- Optional output language
          Arg2 := As_U.Tus (Ada.Command_Line.Argument (I + 1));
          if Arg2.Length = 0 and then Arg2.Element (1) = '-' then
            Arg2.Set_Null;
          else
            I := I + 1;
          end if;
        end if;
        -- Set output language
        declare
          Language : Mapcodes.Languages.Language_List
                   := Mapcodes.Languages.Default_Language;
        begin
          if not Arg2.Is_Null
          and then Arg2.Element (1) >= '0' and then Arg2.Element (1) <= '9' then
            -- Argument is language num
            Language := Mapcodes.Languages.Language_List'Val (
              Natural'Value (Arg2.Image));
          elsif not Arg2.Is_Null then
            -- Argument is language name
            declare
              -- Convert to unicodes to get the language
              Wws : constant Wide_Wide_String
                  := Ada.Strings.Utf_Encoding.Wide_Wide_Strings.Decode (
                         Mapcode_Utils.Str_Tools.Upper_Str (Arg2.Image));
              Unicodes : Language_Utils.Unicode_Sequence (Wws'Range);
            begin
              for I in Wws'Range loop
                Unicodes(I) := Wide_Wide_Character'Pos(Wws(I));
              end loop;
              Language := Mapcodes.Languages.Get_Language (Unicodes);
            end;
          end if;
          Ada.Text_Io.Put_Line  (
            Ada.Strings.Utf_Encoding.Wide_Strings.Encode (
              Mapcodes.Languages.Convert (
                Ada.Strings.Utf_Encoding.Wide_Strings.Decode (Arg1.Image),
                Language)));
        exception
          when Mapcodes.Decode_Error
             | Mapcodes.Languages.Invalid_Text
             | Mapcodes.Languages.Unknown_Language =>
            raise;
          when others =>
            raise Argument_Error;
        end;
      end if;
    else
      raise Argument_Error;
    end if;
    I := I + 1;
  end loop;
  Ada.Command_Line.Set_Exit_Status (0);
exception
  when Mapcodes.Unknown_Territory =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error,
                          "Raised Unknown_Territory");
    Ada.Command_Line.Set_Exit_Status (1);
  when Mapcodes.Not_A_Subdivision =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error,
                          "Raised Not_A_Subdivision");
  when Mapcodes.Decode_Error =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error, "Raised Decode_Error");
    Ada.Command_Line.Set_Exit_Status (1);
  when Mapcodes.Languages.Invalid_Text =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error, "Raised Invalid_Text");
    Ada.Command_Line.Set_Exit_Status (1);
  when Mapcodes.Languages.Unknown_Language =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error, "Raised Unknown_Language");
    Ada.Command_Line.Set_Exit_Status (1);
  when Argument_Error =>
    Ada.Text_Io.Put_Line (Ada.Text_Io.Standard_Error,
                          "ERROR: Invalid Argument");
    Ada.Command_Line.Set_Exit_Status (2);
    Usage;
  when others =>
    Ada.Command_Line.Set_Exit_Status (2);
    raise;
end T_Mapcode;