defmodule ExIntegrationCoveralls.Stats do
  @moduledoc """
  Provide calculation logics of coverage stats.
  """
  alias ExIntegrationCoveralls.Cover
  alias ExIntegrationCoveralls.PathReader

  defmodule Source do
    @moduledoc """
    Stores count information for a file and all source lines.
    """

    @derive [Poison.Encoder]
    defstruct filename: "", coverage: 0, sloc: 0, hits: 0, misses: 0, source: []
  end

  defmodule Line do
    @moduledoc """
    Stores count information and source for a single line.
    """

    @derive [Poison.Encoder]
    defstruct coverage: nil, source: ""
  end

  @doc """
  Report the statistical information for the specified module.

  ## Parameters
  - compile_time_source_lib_abs_path: source code project abs path in compile-time machine.
  - source_lib_absolute_path: source code project abs path in run-time machine.

  ## Returns
  Return value like this:

      [
        %{
          coverage: [0, 1, nil, nil],
          name: "lib/hello.ex",
          source: "defmodule Test do\\n  def test do\\n  end\\nend"
        }
      ]
  """
  def report(modules, compile_time_source_lib_abs_path, source_lib_absolute_path) do
    calculate_stats(modules, compile_time_source_lib_abs_path)
    |> generate_coverage(source_lib_absolute_path)
    |> generate_source_info(source_lib_absolute_path)
  end

  @doc """
  Calculate the statistical information for the specified list of modules.
  It uses :cover.analyse for getting the information.

  ## Parameters
  - modules: Cover.modules() return value

  ## Returns
  a Map stores the number of executions of executable line in the source file.

  ## Examples

      %{
        "test/fixtures/test1.ex" => %{1 => 0, 2 => 1},
        "test/fixtures/test2.ex" => %{1 => 0, 2 => 0}
      }
  """
  def calculate_stats(modules, source_lib_absolute_path \\ File.cwd!()) do
    Enum.reduce(modules, Map.new(), fn module, dict ->
      {:ok, lines} = Cover.analyze(module)
      # calc the number of executions
      analyze_lines(lines, dict, source_lib_absolute_path)
    end)
  end

  defp analyze_lines(lines, module_hash, source_lib_absolute_path) do
    Enum.reduce(lines, module_hash, fn {{module, line}, count}, module_hash ->
      add_counts(module_hash, module, line, count, source_lib_absolute_path)
    end)
  end

  defp add_counts(module_hash, module, line, count, source_lib_absolute_path) do
    path = Cover.module_path(module, source_lib_absolute_path)
    count_hash = Map.get(module_hash, path, Map.new())

    Map.put(
      module_hash,
      path,
      Map.put(count_hash, line, max(Map.get(count_hash, line, 0), count))
    )
  end

  @doc """
  Read source code
  """
  def read_source(file_path) do
    file_path |> File.read!() |> trim_empty_prefix_and_suffix
  end

  @doc """
  Returns total line counts of the specified source file.
  """
  def get_source_line_count(file_path) do
    read_source(file_path) |> count_lines
  end

  @doc """
  Remove the front and back blank lines
  """
  def trim_empty_prefix_and_suffix(string) do
    string = Regex.replace(~r/\n\z/m, string, "")
    Regex.replace(~r/\A\n/m, string, "")
  end

  defp count_lines(string) do
    1 + (Regex.scan(~r/\n/i, string) |> length)
  end

  @doc """
  Generate coverage, based on the pre-calculated statistic information.

  ## Parameters
  - hash: calculate_stats() return value
  - base_path: the source code project absolute path

  ## Returns
  A tuple array. The first element of the tuple is the source code path
  The second element of the tuple stores the number of times each row was executed.
  The nil means it's not an executable line.
  Non-negative numbers represent the number of times each line  of source code is executed.

  ## Examples

      [{"lib/hello.ex", [ nil, 0, nil, 0, nil, 1]}, ...]
  """
  def generate_coverage(hash, base_path \\ File.cwd!()) do
    keys = Map.keys(hash)

    Enum.map(keys, fn file_path ->
      total = get_source_line_count(PathReader.expand_path(file_path, base_path))
      {file_path, do_generate_coverage(Map.fetch!(hash, file_path), total, [])}
    end)
  end

  defp do_generate_coverage(_hash, 0, acc), do: acc

  defp do_generate_coverage(hash, index, acc) do
    count = Map.get(hash, index, nil)
    do_generate_coverage(hash, index - 1, [count | acc])
  end

  @doc """
  Generate objects which stores source-file and coverage stats information.

  ## Parameters
  - coverage: generate_coverage() return value

  ## Returns
  A map array.

  ## Examples
  Return value like this:

      [
        %{
          coverage: [0, 1, nil, nil],
          name: "lib/hello.ex",
          source: "defmodule Test do\\n  def test do\\n  end\\nend"
        }
      ]
  """
  def generate_source_info(coverage, base_path \\ File.cwd!()) do
    Enum.map(coverage, fn {file_path, stats} ->
      %{
        name: file_path,
        source: read_source(PathReader.expand_path(file_path, base_path)),
        coverage: stats
      }
    end)
  end

  @doc """
  Organize coverage data in a human-readable way.

  ## Parameters
  - stats: generate_source_info() return value

  ## Return
  A map.

  ## Examples
  Return value link this:

      %{
        coverage: 50,
        files: [
          %ExIntegrationCoveralls.Stats.Source{
            coverage: 50,
            filename: "test/fixtures/test.ex",
            hits: 1,
            misses: 1,
            sloc: 2,
            source: [
              %ExIntegrationCoveralls.Stats.Line{coverage: 0, source: "defmodule Test do"},
              %ExIntegrationCoveralls.Stats.Line{coverage: 1, source: "  def test do"},
              %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  end"},
              %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "end"}
            ]
          }
        ],
        hits: 1,
        misses: 1,
        sloc: 2
      }
  """
  def transform_cov(stats) do
    stats = Enum.sort(stats, fn x, y -> x[:name] <= y[:name] end)

    files = Enum.map(stats, &populate_file/1)
    {relevant, hits, misses} = Enum.reduce(files, {0, 0, 0}, &reduce_file_counts/2)
    covered = relevant - misses

    %{
      coverage: get_coverage(relevant, covered),
      sloc: relevant,
      hits: hits,
      misses: misses,
      files: files
    }
  end

  defp populate_file(stat) do
    coverage = stat[:coverage]
    source = map_source(stat[:source], coverage)
    relevant = Enum.count(coverage, fn e -> e != nil end)
    hits = Enum.reduce(coverage, 0, fn e, acc -> (e || 0) + acc end)
    misses = Enum.count(coverage, fn e -> e == 0 end)
    covered = relevant - misses

    %Source{
      filename: stat[:name],
      coverage: get_coverage(relevant, covered),
      sloc: relevant,
      hits: hits,
      misses: misses,
      source: source
    }
  end

  defp map_source(source, coverage) do
    source
    |> String.split("\n")
    |> Enum.with_index()
    |> Enum.map(&populate_source(&1, coverage))
  end

  defp populate_source({line, i}, coverage) do
    %Line{coverage: Enum.at(coverage, i), source: line}
  end

  defp get_coverage(relevant, covered) do
    value =
      case relevant do
        0 -> 100.0
        _ -> covered / relevant * 100
      end

    if value == trunc(value) do
      trunc(value)
    else
      Float.round(value, 1)
    end
  end

  defp reduce_file_counts(%{sloc: sloc, hits: hits, misses: misses}, {s, h, m}) do
    {s + sloc, h + hits, m + misses}
  end
end