phone

defmodule Helper.Area do
  @moduledoc false
  defmacro __using__(_) do
    quote do
      import Helper.Area

      def regex, do: ""
      def area_name, do: ""
      def area_type, do: ""
      def area_abbreviation, do: ""

      defoverridable regex: 0, area_name: 0, area_type: 0, area_abbreviation: 0

      def builder(number) do
        [_ | country] =
          __MODULE__
          |> Module.split()
          |> Enum.reverse()

        country =
          country
          |> Enum.reverse()
          |> Module.concat()

        [[_, code, area, number]] = Regex.scan(regex(), number)

        %{
          country: country.country(),
          a2: country.a2(),
          a3: country.a3(),
          international_code: code,
          number: number,
          area_code: area,
          area_name: area_name(),
          area_type: area_type(),
          area_abbreviation: area_abbreviation()
        }
      end
    end
  end

  defp generate_codes(codes) do
    [
      quote do
        def codes, do: unquote(codes)
      end
    ]
  end

  defp generate_errors do
    [
      quote do
        def build(_number), do: {:error, "Not a valid phone number."}

        def build!(_number), do: raise(ArgumentError, message: "Not a valid phone number.")

        def match?(_number), do: false
      end
    ]
  end

  defp generate_matcher(code) do
    quote do
      def match?(unquote(code) <> _ = number) do
        Regex.match?(regex(), number)
      end

      def build(unquote(code) <> _ = number) do
        if match?(number) do
          {:ok, builder(number)}
        else
          {:error, "Not a valid phone number."}
        end
      end

      def build!(unquote(code) <> _ = number) do
        if match?(number) do
          builder(number)
        else
          raise ArgumentError, message: "Not a valid phone number."
        end
      end
    end
  end

  defmacro matcher(codes) do
    generate_codes(codes) ++
      Enum.map(codes, fn code ->
        generate_matcher(code)
      end) ++ generate_errors()
  end
end