%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
%% ex: ts=4 sw=4 et
%% -------------------------------------------------------------------
%%
%% rebar: Erlang Build Tools
%%
%% Copyright (c) 2009, 2010 Dave Smith (dizzyd@dizzyd.com)
%% Copyright (c) 2013 Andras Horvath (andras.horvath@erlang-solutions.com)
%%
%% Permission is hereby granted, free of charge, to any person obtaining a copy
%% of this software and associated documentation files (the "Software"), to deal
%% in the Software without restriction, including without limitation the rights
%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
%% copies of the Software, and to permit persons to whom the Software is
%% furnished to do so, subject to the following conditions:
%%
%% The above copyright notice and this permission notice shall be included in
%% all copies or substantial portions of the Software.
%%
%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
%% THE SOFTWARE.
%% -------------------------------------------------------------------
-module(rebar_cover_utils).

%% for internal use only
-export([init/3,
         perform_cover/4,
         close/1,
         exit/0]).

-include("rebar.hrl").

%% ====================================================================
%% Internal functions
%% ====================================================================

perform_cover(Config, BeamFiles, SrcModules, TargetDir) ->
    perform_cover(rebar_config:get(Config, cover_enabled, false),
                  Config, BeamFiles, SrcModules, TargetDir).

perform_cover(false, _Config, _BeamFiles, _SrcModules, _TargetDir) ->
    ok;
perform_cover(true, Config, BeamFiles, SrcModules, TargetDir) ->
    analyze(Config, BeamFiles, SrcModules, TargetDir).

close(not_enabled) ->
    ok;
close(F) ->
    ok = file:close(F).

exit() ->
    cover:stop().

init(false, _BeamFiles, _TargetDir) ->
    {ok, not_enabled};
init(true, BeamFiles, TargetDir) ->
    %% Attempt to start the cover server, then set its group leader to
    %% TargetDir/cover.log, so all cover log messages will go there instead of
    %% to stdout. If the cover server is already started, we'll kill that
    %% server and start a new one in order not to inherit a polluted
    %% cover_server state.
    {ok, CoverPid} = case whereis(cover_server) of
                         undefined ->
                             cover:start();
                         _         ->
                             cover:stop(),
                             cover:start()
                     end,

    {ok, F} = OkOpen = file:open(
                         filename:join([TargetDir, "cover.log"]),
                         [write]),

    group_leader(F, CoverPid),

    ?INFO("Cover compiling ~s\n", [rebar_utils:get_cwd()]),

    Compiled = [{Beam, cover:compile_beam(Beam)} || Beam <- BeamFiles],
    case [Module || {_, {ok, Module}} <- Compiled] of
        [] ->
            %% No modules compiled successfully...fail
            ?ERROR("Cover failed to compile any modules; aborting.~n", []),
            ?FAIL;
        _ ->
            %% At least one module compiled successfully

            %% It's not an error for cover compilation to fail partially,
            %% but we do want to warn about them
            PrintWarning =
                fun(Beam, Desc) ->
                        ?CONSOLE("Cover compilation warning for ~p: ~p",
                                 [Beam, Desc])
                end,
            _ = [PrintWarning(Beam, Desc) || {Beam, {error, Desc}} <- Compiled],
            OkOpen
    end;
init(Config, BeamFiles, TargetDir) ->
    init(rebar_config:get(Config, cover_enabled, false), BeamFiles, TargetDir).

analyze(_Config, [], _SrcModules, _TargetDir) ->
    ok;
analyze(Config, FilteredModules, SrcModules, TargetDir) ->
    %% Generate coverage info for all the cover-compiled modules
    Coverage = lists:flatten([analyze_mod(M)
                              || M <- FilteredModules,
                                 cover:is_compiled(M) =/= false]),

    %% Write index of coverage info
    write_index(lists:sort(Coverage), SrcModules, TargetDir),

    %% Write coverage details for each file
    lists:foreach(
      fun({M, _, _}) ->
              {ok, _} = cover:analyze_to_file(M,
                                              cover_file(M, TargetDir),
                                              [html])
      end, Coverage),

    Index = filename:join([rebar_utils:get_cwd(), TargetDir, "index.html"]),
    ?CONSOLE("Cover analysis: ~s\n", [Index]),

    %% Export coverage data, if configured
    case rebar_config:get(Config, cover_export_enabled, false) of
        true ->
            export_coverdata(TargetDir);
        false ->
            ok
    end,

    %% Print coverage report, if configured
    case rebar_config:get(Config, cover_print_enabled, false) of
        true ->
            print_coverage(lists:sort(Coverage));
        false ->
            ok
    end,

    %% Generate JSON Coverage Data, if configured
    case rebar_config:get(Config, cover_export_json, false) of
        true ->
            export_json_coverage(TargetDir, lists:sort(Coverage));
        false ->
            ok
    end.

analyze_mod(Module) ->
    case cover:analyze(Module, coverage, module) of
        {ok, {Module, {Covered, NotCovered}}} ->
            %% Modules that include the eunit header get an implicit
            %% test/0 fun, which cover considers a runnable line, but
            %% eunit:test(TestRepresentation) never calls.  Decrement
            %% NotCovered in this case.
            [align_notcovered_count(Module, Covered, NotCovered,
                                    is_eunitized(Module))];
        {error, Reason} ->
            ?ERROR("Cover analyze failed for ~p: ~p ~p\n",
                   [Module, Reason, code:which(Module)]),
            []
    end.

is_eunitized(Mod) ->
    has_eunit_test_fun(Mod) andalso
        has_header(Mod, "include/eunit.hrl").

has_eunit_test_fun(Mod) ->
    [F || {exports, Funs} <- Mod:module_info(),
          {F, 0} <- Funs, F =:= test] =/= [].

has_header(Mod, Header) ->
    Mod1 = case code:which(Mod) of
               cover_compiled ->
                   {file, File} = cover:is_compiled(Mod),
                   File;
               non_existing -> Mod;
               preloaded -> Mod;
               L -> L
           end,
    {ok, {_, [{abstract_code, {_, AC}}]}} =
        beam_lib:chunks(Mod1, [abstract_code]),
    [F || {attribute, 1, file, {F, 1}} <- AC,
          string:str(F, Header) =/= 0] =/= [].

align_notcovered_count(Module, Covered, NotCovered, false) ->
    {Module, Covered, NotCovered};
align_notcovered_count(Module, Covered, NotCovered, true) ->
    {Module, Covered, NotCovered - 1}.

write_index(Coverage, SrcModules, TargetDir) ->
    {ok, F} = file:open(filename:join([TargetDir, "index.html"]), [write]),
    ok = file:write(F, "<!DOCTYPE HTML><html>\n"
                    "<head><meta charset=\"utf-8\">"
                    "<title>Coverage Summary</title></head>\n"
                    "<body>\n"),
    IsSrcCoverage = fun({Mod,_C,_N}) -> lists:member(Mod, SrcModules) end,
    {SrcCoverage, TestCoverage} = lists:partition(IsSrcCoverage, Coverage),
    write_index_section(F, "Source", SrcCoverage),
    write_index_section(F, "Test", TestCoverage),
    ok = file:write(F, "</body></html>"),
    ok = file:close(F).

write_index_section(_F, _SectionName, []) ->
    ok;
write_index_section(F, SectionName, Coverage) ->
    %% Calculate total coverage
    {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) ->
                                                {CAcc + C, NAcc + N}
                                        end, {0, 0}, Coverage),
    TotalCoverage = percentage(Covered, NotCovered),

    %% Write the report
    ok = file:write(F, ?FMT("<h1>~s Summary</h1>\n", [SectionName])),
    ok = file:write(F, ?FMT("<h3>Total: ~s</h3>\n", [TotalCoverage])),
    ok = file:write(F, "<table><tr><th>Module</th><th>Coverage %</th></tr>\n"),

    FmtLink =
        fun(Module, Cov, NotCov) ->
                ?FMT("<tr><td><a href='~s.COVER.html'>~s</a></td><td>~s</td>\n",
                     [Module, Module, percentage(Cov, NotCov)])
        end,
    lists:foreach(fun({Module, Cov, NotCov}) ->
                          ok = file:write(F, FmtLink(Module, Cov, NotCov))
                  end, Coverage),
    ok = file:write(F, "</table>\n").

print_coverage(Coverage) ->
    {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) ->
                                                {CAcc + C, NAcc + N}
                                        end, {0, 0}, Coverage),
    TotalCoverage = percentage(Covered, NotCovered),

    %% Determine the longest module name for right-padding
    Width = lists:foldl(fun({Mod, _, _}, Acc) ->
                                case length(atom_to_list(Mod)) of
                                    N when N > Acc ->
                                        N;
                                    _ ->
                                        Acc
                                end
                        end, 0, Coverage) * -1,

    %% Print the output the console
    ?CONSOLE("~nCode Coverage:~n", []),
    lists:foreach(fun({Mod, C, N}) ->
                          ?CONSOLE("~*s : ~4s~n",
                                   [Width, Mod, percentage(C, N)])
                  end, Coverage),
    ?CONSOLE("~n~*s : ~s~n", [Width, "Total", TotalCoverage]).

export_json_coverage(TargetDir,Coverage) ->
    ?CONSOLE("~nCode Coverage export to json~n", []),
    lists:foreach(fun(ModuleCoverage) ->
                          export_json_coverage_to_file(
                            TargetDir,
                            ModuleCoverage)
                  end, Coverage).

export_json_coverage_to_file(TargetDir, {Module, Covered, NotCovered}) ->
    {ok, JsonFile} = file:open(json_file(TargetDir, Module), [write]),
    io:format(JsonFile,
              "{\"module\":~p,\"covered\":~p,\"not_covered\":~p}",
              [atom_to_list(Module), Covered, NotCovered]),
    ok = file:close(JsonFile).

json_file(TargetDir, Module) ->
    filename:join([TargetDir, atom_to_list(Module) ++ ".COVER.json"]).

cover_file(Module, TargetDir) ->
    filename:join([TargetDir, atom_to_list(Module) ++ ".COVER.html"]).

export_coverdata(TargetDir) ->
    ExportFile = filename:join(TargetDir, "cover.coverdata"),
    case cover:export(ExportFile) of
        ok ->
            ?CONSOLE("Coverdata export: ~s~n", [ExportFile]);
        {error, Reason} ->
            ?ERROR("Coverdata export failed: ~p~n", [Reason])
    end.

percentage(0, 0) ->
    "not executed";
percentage(Cov, NotCov) ->
    integer_to_list(trunc((Cov / (Cov + NotCov)) * 100)) ++ "%".