defmodule Timex.Timezone.Local do
  @moduledoc """
  This module is responsible for determining the timezone configuration of the
  local machine. It determines this from a number of sources, depending on platform,
  but the order of precedence is as follows:

  ALL:
  - TZ environment variable. Ignored if nil/empty

  OSX:
  - /etc/localtime
  - systemsetup -gettimezone (if admin rights are present)

  UNIX:
  - /etc/timezone
  - /etc/sysconfig/clock
  - /etc/conf.d/clock
  - /etc/localtime
  - /usr/local/etc/localtime

  Windows:
  - SYSTEM registry for the currently configured TimeZoneInformation

  Each location is tried, and if an error is encountered, the next is attempted,
  until either a successful lookup is performed, or we run out of locations to check.
  """
  alias Timex.Timezone.Utils
  alias Timex.Parse.ZoneInfo.Parser

  @_ETC_TIMEZONE "/etc/timezone"
  @_ETC_SYS_CLOCK "/etc/sysconfig/clock"
  @_ETC_CONF_CLOCK "/etc/conf.d/clock"
  @_ETC_LOCALTIME "/etc/localtime"
  @_USR_ETC_LOCALTIME "/usr/local/etc/localtime"

  @type gregorian_seconds :: non_neg_integer

  @doc """
  Looks up the local timezone configuration. Returns the name of a timezone
  in the Olson database.

  If no reference time is provided (in gregorian seconds), the current time in UTC will be used.
  If one is provided, the reference time will be used to find the local timezone for that reference time,
  if it exists.
  """
  @spec lookup() :: String.t() | {:error, term}

  def lookup() do
    case Application.get_env(:timex, :local_timezone) do
      nil ->
        tz =
          case :os.type() do
            {:unix, :darwin} -> localtz(:osx)
            {:unix, _} -> localtz(:unix)
            {:win32, :nt} -> localtz(:win)
            _ -> {:error, :time_zone_not_found}
          end

        with tz when is_binary(tz) <- tz do
          Application.put_env(:timex, :local_timezone, tz)
          tz
        else
          {:error, _} ->
            {:error, :time_zone_not_found}
        end

      tz when is_binary(tz) ->
        tz
    end
  end

  # Get the locally configured timezone on OSX systems
  @spec localtz(:osx | :unix | :win) :: String.t() | no_return
  defp localtz(:osx) do
    # Allow TZ environment variable to override lookup
    tz =
      case System.get_env("TZ") do
        nil ->
          # Most accurate local timezone will come from /etc/localtime,
          # since we can lookup proper timezones for arbitrary dates
          read_timezone_data(nil, @_ETC_LOCALTIME)

        ":" <> path ->
          read_timezone_data(nil, path)

        tz ->
          {:ok, tz}
      end

    case tz do
      {:ok, tz} ->
        tz

      _ ->
        # Fallback and ask systemsetup
        {tz, 0} = System.cmd("systemsetup", ["-gettimezone"])

        tz =
          tz
          |> String.trim("\n")
          |> String.replace("Time Zone: ", "")

        if String.length(tz) > 0 do
          tz
        else
          {:error, :time_zone_not_found}
        end
    end
  end

  # Get the locally configured timezone on *NIX systems
  defp localtz(:unix) do
    tz =
      case System.get_env("TZ") do
        # Not found
        nil ->
          nil

        ":" <> path ->
          read_timezone_data(nil, path)

        tz ->
          {:ok, tz}
      end

    case tz do
      {:ok, tz} ->
        tz

      _ ->
        # Since that failed, check distro specific config files
        # containing the timezone name. To clean up the code here
        # we're using pipes, even though we may find the value we
        # are looking for on the first try. The way the function
        # defs are set up, if we find a value, it's just passed
        # along through the pipe until we're done. If we don't,
        # this will try each fallback location in order.
        with {:ok, tz} <-
               read_timezone_data(nil, @_ETC_LOCALTIME)
               |> read_timezone_data(@_USR_ETC_LOCALTIME)
               |> read_timezone_data(@_ETC_SYS_CLOCK)
               |> read_timezone_data(@_ETC_CONF_CLOCK)
               |> read_timezone_data(@_ETC_TIMEZONE) do
          tz
        else
          _ ->
            {:error, :time_zone_not_found}
        end
    end
  end

  # Get the locally configured timezone on Windows systems
  @local_tz_key ~c"SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation"
  @sys_tz_key ~c"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones"
  @tz_key_name ~c"TimeZoneKeyName"
  # We ignore the reference date here, since there is no way to lookup
  # transition times for historical/future dates
  defp localtz(:win) do
    # Windows has many of its own unique time zone names, which can
    # also be translated to the OS's language.
    {:ok, handle} = :win32reg.open([:read])
    :ok = :win32reg.change_key(handle, ~c"\\local_machine\\#{@local_tz_key}")
    {:ok, values} = :win32reg.values(handle)

    if List.keymember?(values, @tz_key_name, 0) do
      # Extract the time zone name that windows has recorded
      {@tz_key_name, time_zone_name} = List.keyfind(values, @tz_key_name, 0)
      # Windows 7/Vista
      # On some systems the string value might be padded with excessive \0 bytes, trim them
      time_zone_name
      |> Enum.take_while(fn
        ?\0 -> false
        _ -> true
      end)
      |> IO.iodata_to_binary()
      |> Utils.to_olson()
    else
      # Windows 2000 or XP
      # This is the localized name:
      localized = List.keyfind(values, ~c"StandardName", 0)
      # Open the list of timezones to look up the real name:
      :ok = :win32reg.change_key(handle, @sys_tz_key)
      {:ok, subkeys} = :win32reg.sub_keys(handle)
      # Iterate over each subkey (timezone), and match against the localized name
      tzone =
        Enum.find(subkeys, fn subkey ->
          :ok = :win32reg.change_key(handle, subkey)
          {:ok, values} = :win32reg.values(handle)

          case List.keyfind(values, ~c"Std", 0) do
            {_, zone} when zone == localized -> zone
            _ -> nil
          end
        end)

      # If we don't have a timezone yet, we've failed,
      # Otherwise, we need to lookup the final timezone name
      # in the dictionary of unique Windows timezone names
      cond do
        tzone == nil ->
          raise "Could not find Windows time zone configuration!"

        tzone ->
          timezone = tzone |> IO.iodata_to_binary()

          case Utils.to_olson(timezone) do
            nil ->
              # Try appending "Standard Time"
              case Utils.to_olson("#{timezone} Standard Time") do
                nil -> {:error, :time_zone_not_found}
                final -> final
              end

            final ->
              final
          end
      end
    end
  end

  # Attempt to read timezone data from /etc/timezone
  @spec read_timezone_data({:ok, String.t()} | nil, String.t()) ::
          {:ok, String.t()} | nil | no_return
  defp read_timezone_data(result, file)

  # If we've found a timezone, just keep on piping it through
  defp read_timezone_data({:ok, _} = result, _),
    do: result

  # Otherwise, read the next fallback location
  defp read_timezone_data(_, @_ETC_TIMEZONE) do
    case File.read(@_ETC_TIMEZONE) do
      {:ok, name} ->
        {:ok, String.trim(name)}

      {:error, _} ->
        nil
    end
  end

  defp read_timezone_data(_, file)
       when file == @_ETC_SYS_CLOCK or file == @_ETC_CONF_CLOCK do
    if File.exists?(file) do
      match =
        file
        |> File.stream!()
        |> Stream.filter(fn line -> Regex.match?(~r/(^ZONE=)|(^TIMEZONE=)/, line) end)
        |> Enum.to_list()
        |> List.first()

      case match do
        nil ->
          nil

        m ->
          with [tz | _] <-
                 String.split(m, :binary.compile_pattern(["ZONE=", "TIMEZONE=", "\"", "'"]),
                   trim: true
                 ) do
            {:ok, String.replace(tz, " ", "_")}
          else
            _ ->
              nil
          end
      end
    else
      nil
    end
  end

  defp read_timezone_data(_, file)
       when file == @_ETC_LOCALTIME or file == @_USR_ETC_LOCALTIME do
    if File.exists?(file) do
      name =
        file
        |> get_real_path()
        |> String.replace(~r(^.*/zoneinfo/), "")

      case name do
        ^file ->
          nil

        _ ->
          {:ok, name}
      end
    end
  end

  defp get_real_path(path) do
    case File.lstat!(path) do
      %File.Stat{type: :symlink} ->
        File.read_link!(path)

      %File.Stat{type: :regular} ->
        path
    end
  end

  @doc """
  Given a binary representing the data from a tzfile (not the source version),
  parses out the timezone for the current date/time in UTC.
  """
  @spec parse_tzfile(binary) :: {:ok, String.t()} | {:error, term}
  def parse_tzfile(tzdata) do
    Parser.parse(tzdata)
  end
end