defmodule Flagsmith.Engine do
  require Logger

  alias Flagsmith.Schemas.{
    Environment,
    Traits,
    Segments,
    Identity,
    Features
  }

  alias Traits.Trait
  alias Flagsmith.Schemas.Types
  @condition_operators Flagsmith.Schemas.Types.Operator.values(:atoms)

  @moduledoc false

  @doc """
  Generate a valid environment struct from a json string or map.
  """
  @spec parse_environment(data :: map() | String.t()) ::
          {:ok, Environment.t()} | {:error, Ecto.Changeset.t()} | {:error, term()}
  def parse_environment(data) when is_map(data) and not is_struct(data),
    do: Environment.cast(data)

  def parse_environment(data) when is_binary(data) do
    case Jason.decode(data) do
      {:ok, decoded} -> parse_environment(decoded)
      {:error, _} = error -> error
    end
  end

  @doc """
  Get the feature states of an `t:Flagsmith.Schemas.Environment.t/0`.
  """
  @spec get_environment_feature_states(Environment.t()) :: list(Environment.FeatureState.t())
  def get_environment_feature_states(%Environment{
        feature_states: feature_states,
        project: %Environment.Project{hide_disabled_flags: hide_disabled_flags}
      }) do
    case hide_disabled_flags do
      false -> feature_states
      true -> Enum.filter(feature_states, & &1.enabled)
    end
  end

  @doc """
  Get a specific feature state for a given feature_name in a given 
  `t:Flagsmith.Schemas.Environment.t/0`.
  """
  @spec get_environment_feature_state(Environment.t(), name :: String.t()) ::
          Environment.FeatureState.t() | nil
  def get_environment_feature_state(%Environment{feature_states: fs}, name),
    do: Enum.find(fs, fn %{feature: %{name: f_name}} -> f_name == name end)

  @doc """
  Get list of feature states for a given `t:Flagsmith.Schemas.Identity.t/0` in a 
  given `t:Flagsmith.Schemas.Environment.t/0`.
  """
  @spec get_identity_feature_states(
          Environment.t(),
          Identity.t(),
          override_traits :: list(Traits.Trait.t())
        ) :: list(Environment.FeatureState.t())
  def get_identity_feature_states(
        %Environment{
          feature_states: fs,
          project: %Environment.Project{segments: segments}
        } = env,
        %Identity{identity_features: identity_features} = identity,
        override_traits \\ []
      ) do
    with identity <- Identity.set_env_key(identity, env),
         segment_features <-
           get_identity_applicable_segments(segments, identity, override_traits),
         prioritized <- clean_segments_by_priority(segment_features),
         replaced <- replace_segment_features(fs, prioritized),
         pre_features <- replace_identity_features(replaced, identity_features),
         final_features <- replace_multivariates(pre_features, identity) do
      final_features
    end
  end

  @doc """
  Get list of segments for a given `t:Flagsmith.Schemas.Identity.t/0` in a 
  given `t:Flagsmith.Schemas.Environment.t/0`.
  """
  @spec get_identity_segments(
          Environment.t(),
          Identity.t(),
          override_traits :: list(Traits.Trait.t())
        ) :: list(Segments.IdentitySegment.t())
  def get_identity_segments(
        %Environment{
          project: %Environment.Project{segments: segments}
        } = env,
        identity,
        override_traits \\ []
      ) do
    with identity <- Identity.set_env_key(identity, env),
         segments <-
           get_identity_applicable_segments(segments, identity, override_traits),
         replaced <- Enum.map(segments, &Segments.IdentitySegment.from_segment/1) do
      replaced
    end
  end

  defp clean_segments_by_priority(segments) do
    # keep an ordered table by index so we can retrieve the segments in order
    # at the end when manipulating them
    table_segments = :ets.new(:temp_segments, [:ordered_set])
    # keep a table to track the feature_states by name so we can compare in case
    # of same name fs_s
    table_features = :ets.new(:temp_track, [])

    # reduce through all the segments, using an accumulator for keeping track of the
    # current index of the segment
    Enum.reduce(segments, 0, fn %Segments.Segment{feature_states: segment_fs} = segment, index ->
      # for each segment, iterate through those segment's feature states
      Enum.each(segment_fs, fn %Environment.FeatureState{feature: feature} = fs ->
        # lookup on the tracking table if we have an item by the feature name
        case :ets.lookup(table_features, feature.name) do
          [] ->
            # if we don't, then we insert the initial one, keyed by name, and with
            # the full feature_state, index, and an empty list
            :ets.insert(table_features, {feature.name, fs, index, []})

          # if we do then we check if the existing one in the table is higher
          # priority than the current one being iterated
          [{_, %Environment.FeatureState{} = existing, existing_index, to_rem}] ->
            case Environment.FeatureState.is_higher_priority?(existing, fs) do
              true ->
                # if it's then it means the current one, will need to be removed
                # and as such we add the current iteration index to the list to
                # remove but keep the other tuple elements as they were
                :ets.insert(
                  table_features,
                  {feature.name, existing, existing_index, [index | to_rem]}
                )

              false ->
                # if it's not, then we re-insert the tuple (since it's a set table
                # using the same key, feature.name, will replace the existing item)
                # but we now substitute the feature state by the current one,
                # the index by the current one, and instead add the existing one
                # (the one that was previously the highest priority one) to the list
                # to be removed
                :ets.insert(
                  table_features,
                  {feature.name, fs, index, [existing_index | to_rem]}
                )
            end
        end
      end)

      # finally we insert the segment, keyed by the index (so it keeps the order as
      # the segments table is an ordered set), but unmodified
      # this first iteration is just to find any duplicate feature states
      :ets.insert(table_segments, {index, segment})

      # lastly we increment the accumulator by one so next iteration has the correct
      # index
      index + 1
    end)

    # now we convert the tracking table into a list and iterate through it
    :ets.tab2list(table_features)
    |> Enum.each(fn
      {_name, _, _index, []} ->
        # feature state has no conflicting states because the to remove list is empty
        :ok

      {name, %Environment.FeatureState{featurestate_uuid: uuid}, _index, to_remove} ->
        # since we have the name, full feature state, and a list of indexes
        # corresponding to segments that had this same feature state but with lower
        # priority we iterate the list of the indexes
        Enum.each(to_remove, fn index ->
          # we grab the segment for that index from the segments table
          [{_, %Segments.Segment{feature_states: segment_fs} = segment}] =
            :ets.lookup(table_segments, index)

          # and now we filter the feature states of that segment, that match the name
          # of this one, but not the uuid
          new_segment_fs =
            Enum.reject(segment_fs, fn %Environment.FeatureState{feature: feature} = fs ->
              feature.name == name && uuid != fs.featurestate_uuid
            end)

          # and lastly we replace that segment in the segments table, with the new
          # filtered feature states
          :ets.insert(table_segments, {index, %{segment | feature_states: new_segment_fs}})
        end)
    end)

    # lastly we fold through the right side (since it's an ordered set, it will go
    # from smaller to bigger, and folding through the right starts at the end)
    # and we just accumulate all segments into a new list
    # since the segments in this table were updated in the last step we get the
    # "cleaned" of duplicate features list of segments in the same original order
    final_segments =
      :ets.foldr(fn {_index, segment}, acc -> [segment | acc] end, [], table_segments)

    :ets.delete(table_segments)
    :ets.delete(table_features)

    final_segments
  end

  defp replace_multivariates(features, %Identity{} = identity) do
    features
    |> Enum.map(fn %{feature: %{type: type}} = feature_state ->
      case type do
        "MULTIVARIATE" ->
          uuid = Environment.FeatureState.get_hashing_id(feature_state)

          mv_fs = Map.get(feature_state, :multivariate_feature_state_values, [])

          percentage = percentage_from_ids([uuid, Identity.composite_key(identity)])

          case find_first_multivariate(mv_fs, percentage) do
            {:ok, new_value} -> %{feature_state | feature_state_value: new_value}
            _ -> feature_state
          end

        _ ->
          feature_state
      end
    end)
  end

  defp find_first_multivariate(mvs, percentage) do
    mvs
    |> Enum.sort_by(fn %{id: id, mv_fs_value_uuid: uuid} ->
      case id do
        nil -> uuid
        _ -> id
      end
    end)
    |> Enum.reduce_while(0, fn %{percentage_allocation: p_allot} = mv, start_perc ->
      limit = p_allot + start_perc

      case start_perc <= percentage and percentage < limit do
        true -> {:halt, Environment.FeatureState.extract_multivariate_value(mv)}
        _ -> {:cont, limit}
      end
    end)
  end

  @doc """
  Get feature state with a given feature_name for a given `t:Flagsmith.Schemas.Identity.t/0`
  and `t:Flagsmith.Schemas.Environment.t/0`.
  """
  @spec get_identity_feature_state(
          Environment.t(),
          Identity.t(),
          name :: String.t(),
          override_traits :: list(Traits.Trait.t())
        ) :: Environment.FeatureState.t() | nil
  def get_identity_feature_state(
        %Environment{} = env,
        %Identity{} = identity,
        name,
        override_traits \\ []
      ) do
    env
    |> get_identity_feature_states(identity, override_traits)
    |> Enum.find(fn %{feature: %{name: f_name}} -> f_name == name end)
  end

  @doc """
  Filters a list of segments accordingly to if they match an identity and traits
  (optionally using a list of traits to override those in the identity)
  """
  @spec get_identity_applicable_segments(
          segments :: list(Segments.Segment.t()),
          Identity.t(),
          override_traits :: list(Traits.Trait.t())
        ) :: list(Segments.Segment.t())
  def get_identity_applicable_segments(segments, identity, override_traits) do
    Enum.filter(segments, fn segment ->
      evaluate_identity_in_segment(identity, segment, override_traits)
    end)
  end

  @doc """
  Returns a list of `t:Flagsmith.Schemas.Environment.FeatureState.t/0` where any that
  has the same name as in the segments provided is replaced by the feature state there
  specified (if any).
  """
  @spec replace_segment_features(
          original :: list(Environment.FeatureState.t()),
          to_replace :: list(Segments.Segment.t())
        ) :: list(Environment.FeatureState.t())
  def replace_segment_features(original, to_replace) do
    Enum.reduce(to_replace, original, fn %{feature_states: segment_fs}, acc ->
      inverted = Enum.reverse(segment_fs)

      Enum.map(acc, fn %{feature: %{name: feature_name}} = flag ->
        Enum.find(inverted, flag, fn %{feature: %{name: replacement_name}} ->
          replacement_name == feature_name
        end)
      end)
    end)
  end

  @doc """
  Returns a list with elements of any of `t:Flagsmith.Schemas.Environment.FeatureState.t/0`
  or `t:Flagsmith.Schemas.Features.FeatureState.t/0` where any that has the same name
  as in any of the identity `t:Flagsmith.Schemas.Features.FeatureState.t/0` provided
  is replaced by that feature.
  """
  @spec replace_identity_features(
          original :: list(Environment.FeatureState.t()),
          to_replace :: list(Features.FeatureState.t())
        ) :: list(Environment.FeatureState.t() | Features.FeatureState.t())
  def replace_identity_features(original, to_replace) do
    Enum.reduce(to_replace, original, fn %{feature: %{name: replacement_name}} = replacement_flag,
                                         acc ->
      Enum.map(acc, fn %{feature: %{name: feature_name}} = flag ->
        case feature_name == replacement_name do
          true -> replacement_flag
          false -> flag
        end
      end)
    end)
  end

  @doc """
  True if an identity is deemed matching a segment conditions & rules, false otherwise.
  """
  @spec evaluate_identity_in_segment(Identity.t(), Segments.Segment.t(), list(Traits.Trait.t())) ::
          boolean()

  # if there's no rules we say it doesn't match but I'm not sure this is how it
  # should be
  def evaluate_identity_in_segment(_, %Segments.Segment{rules: []}, _),
    do: false

  def evaluate_identity_in_segment(
        %Identity{traits: identity_traits} = identity,
        %Segments.Segment{id: segment_id, rules: rules},
        override_traits
      ) do
    traits =
      case override_traits do
        [_ | _] -> override_traits
        _ -> identity_traits
      end

    Enum.all?(rules, fn rule ->
      traits_match_segment_rule(traits, rule, segment_id, Identity.composite_key(identity))
    end)
  end

  @doc """
  True if the segment rule conditions all match (or there's no conditions) and all
  nested rules too (or there's no rules), false otherwise.

  """
  @spec traits_match_segment_rule(
          list(Traits.Trait.t()),
          Segments.Segment.Rule.t(),
          non_neg_integer(),
          String.t()
        ) :: boolean()
  def traits_match_segment_rule(
        traits,
        %Segments.Segment.Rule{type: type, rules: rules, conditions: conditions},
        segment_id,
        identifier
      ) do
    matching_function = Types.Segment.Type.enum_matching_function(type)

    (length(conditions) == 0 or
       matching_function.(conditions, fn condition ->
         traits_match_segment_condition(
           traits,
           condition,
           segment_id,
           identifier
         )
       end)) and
      (length(rules) == 0 or
         matching_function.(rules, fn rule ->
           traits_match_segment_rule(traits, rule, segment_id, identifier)
         end))
  end

  @doc """
  True if according to the type of condition operator the comparison is true, false
  otherwise. With exception for PERCENTAGE_SPLIT operator all others are matched against
  the traits passed in.
  """
  @spec traits_match_segment_condition(
          list(Traits.Trait.t()),
          Segments.Segment.Condition.t(),
          non_neg_integer(),
          String.t()
        ) :: boolean()
  def traits_match_segment_condition(
        _traits,
        %Segments.Segment.Condition{operator: :PERCENTAGE_SPLIT, value: value},
        segment_id,
        identifier
      ) do
    with {_, {float, _}} <- {:float_parse, Float.parse(value)},
         {_, percentage} <-
           {:percentage, percentage_from_ids([segment_id, identifier], 1)} do
      percentage <= float
    else
      {_what, _} ->
        false
    end
  end

  def traits_match_segment_condition(
        traits,
        %Segments.Segment.Condition{operator: :IS_SET, property_: prop},
        _segment_id,
        _identifier
      ) do
    Enum.any?(traits, fn %Traits.Trait{trait_key: t_key} -> t_key == prop end)
  end

  def traits_match_segment_condition(
        traits,
        %Segments.Segment.Condition{operator: :IS_NOT_SET, property_: prop},
        _segment_id,
        _identifier
      ) do
    Enum.all?(traits, fn %Traits.Trait{trait_key: t_key} -> t_key != prop end)
  end

  def traits_match_segment_condition(
        traits,
        %Segments.Segment.Condition{operator: operator, value: value, property_: prop},
        _segment_id,
        _identifier
      ) do
    Enum.any?(traits, fn %Traits.Trait{
                           trait_key: t_key,
                           trait_value: t_value
                         } ->
      case prop == t_key do
        true -> trait_match(operator, value, t_value)
        _ -> false
      end
    end)
  end

  @doc """
  Given a list of ids in either and optionally a number of to duplicate them n times,
  compute a value representing a percentage to which those ids when hashed match.
  Refer to https://github.com/Flagsmith/flagsmith-engine/blob/c34b4baeea06d31d221433053b64c1e855fd8d4d/flag_engine/utils/hashing.py#L5
  """
  @spec percentage_from_ids(list(String.t() | non_neg_integer()), non_neg_integer()) :: float()
  def percentage_from_ids(original_ids, iterations \\ 1) do
    with {_, as_strings} <- {:strings, Enum.map(original_ids, &id_to_string/1)},
         {_, ids} <- {:ids, List.duplicate(as_strings, iterations)},
         {_, stringed} <- {:join, List.flatten(ids) |> Enum.join(",")},
         {_, hashed} <- {:hash, Flagsmith.Engine.HashingBehaviour.hash(stringed)},
         {_, {int, _}} <- {:int_parse, Integer.parse(hashed, 16)} do
      case Integer.mod(int, 9999) / 9998 * 100 do
        100.0 ->
          percentage_from_ids(original_ids, iterations + 1)

        percentage ->
          percentage
      end
    else
      {_, _} = error -> {:error, error}
    end
  end

  defp id_to_string(ids) when is_list(ids), do: Enum.map(ids, &id_to_string/1)
  defp id_to_string(int) when is_integer(int), do: Integer.to_string(int)
  defp id_to_string(bin) when is_binary(bin), do: bin
  defp id_to_string(atom) when is_atom(atom), do: Atom.to_string(atom)

  @doc """
  Given an `t:Flagsmith.Schemas.Types.Operator.t/0`, a cast or uncast segment value, and a cast trait 
  value, evaluate if the trait value matches to the segment value.
  """
  @spec trait_match(
          condition :: Types.Operator.t(),
          segment_value :: String.t() | Trait.Value.t(),
          trait :: Trait.Value.t()
        ) :: boolean()
  def trait_match(condition, %Trait.Value{type: :semver, value: value}, %Trait.Value{
        type: :semver,
        value: t_value
      }) do
    case Version.compare(t_value, value) do
      :gt -> condition in [:GREATER_THAN, :GREATER_THAN_INCLUSIVE, :NOT_EQUAL]
      :lt -> condition in [:LESS_THAN, :LESS_THAN_INCLUSIVE, :NOT_EQUAL]
      :eq -> condition in [:GREATER_THAN_INCLUSIVE, :LESS_THAN_INCLUSIVE, :EQUAL]
    end
  end

  def trait_match(:NOT_CONTAINS, %Trait.Value{type: :string, value: value}, %Trait.Value{
        type: :string,
        value: t_value
      }),
      do: not String.contains?(t_value, value)

  def trait_match(:CONTAINS, %Trait.Value{value: value}, %Trait.Value{value: t_value}),
    do: String.contains?(t_value, value)

  def trait_match(:REGEX, %Trait.Value{type: :string, value: value}, %Trait.Value{
        type: :string,
        value: t_value
      }) do
    case Regex.compile(value) do
      {:ok, regex} ->
        String.match?(t_value, regex)

      _ ->
        false
    end
  end

  def trait_match(:GREATER_THAN, %Trait.Value{value: value}, %Trait.Value{
        type: type,
        value: t_value
      }) do
    case type do
      :decimal -> Decimal.compare(t_value, value) == :gt
      _ -> t_value > value
    end
  end

  def trait_match(
        :GREATER_THAN_INCLUSIVE,
        %Trait.Value{value: value},
        %Trait.Value{type: type, value: t_value}
      ) do
    case type do
      :decimal -> Decimal.compare(t_value, value) in [:gt, :eq]
      _ -> t_value >= value
    end
  end

  def trait_match(:LESS_THAN, %Trait.Value{value: value}, %Trait.Value{type: type, value: t_value}) do
    case type do
      :decimal -> Decimal.compare(t_value, value) == :lt
      _ -> t_value < value
    end
  end

  def trait_match(:LESS_THAN_INCLUSIVE, %Trait.Value{value: value}, %Trait.Value{
        type: type,
        value: t_value
      }) do
    case type do
      :decimal -> Decimal.compare(t_value, value) in [:lt, :eq]
      _ -> t_value <= value
    end
  end

  def trait_match(:EQUAL, %Trait.Value{value: value}, %Trait.Value{type: type, value: t_value}) do
    case type do
      :decimal -> Decimal.equal?(t_value, value)
      _ -> t_value == value
    end
  end

  def trait_match(:NOT_EQUAL, %Trait.Value{value: value}, %Trait.Value{type: type, value: t_value}) do
    case type do
      :decimal -> not Decimal.equal?(t_value, value)
      _ -> t_value != value
    end
  end

  def trait_match(:IN, condition_value, %Trait.Value{type: :string, value: t_value}) do
    Enum.member?(String.split(condition_value, ","), t_value)
  end

  def trait_match(:IN, condition_value, %Trait.Value{
        type: :decimal,
        value: %Decimal{exp: 0} = t_value
      }) do
    Enum.member?(String.split(condition_value, ","), t_value |> Decimal.to_string())
  end

  def trait_match(:MODULO, condition_value, %Trait.Value{value: value}) do
    with true <- is_binary(condition_value),
         %Decimal{} <- value,
         [mod, result] <- String.split(condition_value, "|"),
         %Decimal{} = mod_val <- Decimal.new(mod),
         %Decimal{} = result_val <- Decimal.new(result),
         %Decimal{} = remainder <- Decimal.rem(value, mod_val) do
      Decimal.equal?(remainder, result_val)
    else
      _ ->
        false
    end
  rescue
    Decimal.Error ->
      Logger.warn(
        "invalid MODULO segment rule or trait value :: rule: #{inspect(condition_value)} :: value: #{inspect(value)}"
      )

      false
  end

  def trait_match(condition, not_cast, %Trait.Value{} = t_value_struct)
      when condition in @condition_operators and not is_struct(not_cast) and not is_map(not_cast) do
    case Trait.Value.is_semver(not_cast) do
      true ->
        {:ok, cast} = Trait.Value.create_semver(not_cast)
        {:ok, new_t_value_struct} = Trait.Value.create_semver(t_value_struct.value)

        trait_match(condition, cast, new_t_value_struct)

      false ->
        case cast_value(t_value_struct, not_cast) do
          {:ok, cast} ->
            trait_match(condition, cast, t_value_struct)

          _ ->
            false
        end
    end
  end

  def trait_match(_, _, _), do: false

  defp cast_value(%Trait.Value{} = trait_value, to_convert) do
    with {:ok, converted} <- Trait.Value.convert_value_to(trait_value, to_convert) do
      Trait.Value.cast(converted)
    end
  end
end