% Licensed under the Apache License, Version 2.0 (the "License"); you may not
% use this file except in compliance with the License. You may obtain a copy of
% the License at
%
%   http://www.apache.org/licenses/LICENSE-2.0
%
% Unless required by applicable law or agreed to in writing, software
% distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
% WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
% License for the specific language governing permissions and limitations under
% the License.

-module(couch_log).

-behaviour(gen_server).

-compile([{parse_transform, lager_transform}]).

% public API
-export([start_link/0, stop/0]).
-export([debug/2, info/2, warn/2, error/2]).
-export([debug_on/0, info_on/0, warn_on/0, get_level/0, get_level_integer/0, set_level/1]).
-export([debug_on/1, info_on/1, warn_on/1, get_level/1, get_level_integer/1, set_level/2]).
-export([read/2]).

% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
         terminate/2, code_change/3]).


-define(LEVEL_ERROR, 4).
-define(LEVEL_WARN, 3).
-define(LEVEL_INFO, 2).
-define(LEVEL_DEBUG, 1).

-record(state, {
    log_file,
    level,
    sasl
}).

debug(Format, Args) ->
    lager:debug(Format, Args).

info(Format, Args) ->
    lager:info(Format, Args).

warn(Format, Args) ->
    lager:warning(Format, Args).

error(Format, Args) ->
    lager:error(Format, Args).


level_integer(error)    -> ?LEVEL_ERROR;
level_integer(warn)     -> ?LEVEL_WARN;
level_integer(info)     -> ?LEVEL_INFO;
level_integer(debug)    -> ?LEVEL_DEBUG;
level_integer(_Else)    -> ?LEVEL_ERROR. % anything else default to ERROR level

level_atom(?LEVEL_ERROR) -> error;
level_atom(?LEVEL_WARN) -> warn;
level_atom(?LEVEL_INFO) -> info;
level_atom(?LEVEL_DEBUG) -> debug.

debug_on() ->
    get_level_integer() =< ?LEVEL_DEBUG.

info_on() ->
    get_level_integer() =< ?LEVEL_INFO.

warn_on() ->
    get_level_integer() =< ?LEVEL_WARN.

debug_on(Module) ->
    get_level_integer(Module) =< ?LEVEL_DEBUG.

info_on(Module) ->
    get_level_integer(Module) =< ?LEVEL_INFO.

warn_on(Module) ->
    get_level_integer(Module) =< ?LEVEL_WARN.

set_level(LevelAtom) ->
    set_level_integer(level_integer(LevelAtom)).

set_level(Module, LevelAtom) ->
    set_level_integer(Module, level_integer(LevelAtom)).

get_level() ->
    level_atom(get_level_integer()).

get_level(Module) ->
    level_atom(get_level_integer(Module)).

get_level_integer() ->
    try
        ets:lookup_element(?MODULE, level, 2)
    catch error:badarg ->
        ?LEVEL_ERROR
    end.

get_level_integer(Module0) ->
    Module = atom_to_list(Module0),
    try
        [{_Module, Level}] = ets:lookup(?MODULE, Module),
        Level
    catch error:_ ->
        get_level_integer()
    end.

set_level_integer(Int) ->
    gen_event:call(error_logger, couch_log, {set_level_integer, Int}).

set_level_integer(Module, Int) ->
    gen_event:call(error_logger, couch_log, {set_level_integer, Module, Int}).


start_link() ->
    gen_server:start_link({local, couch_log}, couch_log, [], []).

stop() ->
    couch_event_sup:stop(couch_log).

init([]) ->
    % read config and register for configuration changes
    ok = couch_config:register(fun
                ("log", "file") ->
                    gen_server:cast(?MODULE, config_update);
                ("log", "level") ->
                    gen_server:cast(?MODULE, config_update);
                ("log", "include_sasl") ->
                    gen_server:cast(?MODULE, {config_update, include_sasl});
                ("log_level_by_module", _) ->
                    gen_server:cast(?MODULE,
                                    {config_update, log_level_by_module})
            end),


    Filename = log_file(),
    ALevel = list_to_atom(couch_config:get("log", "level", "info")),
    Level = level_integer(ALevel),
    Sasl = couch_config:get("log", "include_sasl", "true") =:= "true",
    LevelByModule = couch_config:get("log_level_by_module"),

    %% maybe start the log file backend
    maybe_start_logfile_backend(Filename, ALevel),

    %% initialise the ets table if needed
    case ets:info(?MODULE) of
        undefined -> ets:new(?MODULE, [named_table]);
        _ -> ok
    end,

    %% set the default level
    ets:insert(?MODULE, {level, Level}),

    %% initialise the log level by modules
    lists:foreach(fun({Module, ModuleLevel}) ->
        ModuleLevelInteger = level_integer(list_to_atom(ModuleLevel)),
        ets:insert(?MODULE, {Module, ModuleLevelInteger})
    end, LevelByModule),

    %% set default log level
    set_loglevel(Filename, ALevel),

    {ok, #state{log_file=Filename, level = Level, sasl = Sasl}}.

handle_call({set_level_integer, NewLevel}, _From, State) ->
    ets:insert(?MODULE, {level, NewLevel}),
    {ok, ok, State#state{level = NewLevel}};

handle_call({set_level_integer, Module, NewLevel}, _From, State) ->
    ets:insert(?MODULE, {Module, NewLevel}),
    {ok, ok, State#state{level = NewLevel}}.

handle_cast(config_update, #state{log_file=OldFilename}=State) ->
    Filename = log_file(),
    ALevel = list_to_atom(couch_config:get("log", "level", "info")),
    Level = level_integer(ALevel),

    %% set default module
    ets:insert(?MODULE, {level, Level}),

    %% should we restart the file backend with a new config?
    if OldFilename =/= Filename ->
            restart_logfile_backend(OldFilename, Filename, ALevel);
        true -> ok
    end,

    %% set log level
    set_loglevel(Filename, ALevel),

    {noreply, State#state{log_file=Filename, level = Level}};

handle_cast({config_update, include_sasl}, State) ->
    Sasl = couch_config:get("log", "include_sasl", "true") =:= "true",
    {noreply, State#state{sasl=Sasl}};
handle_cast({config_update, log_level_by_module}, State) ->
    LevelByModule = couch_config:get("log_level_by_module"),
    lists:foreach(fun({Module, ModuleLevel}) ->
        ModuleLevelInteger = level_integer(list_to_atom(ModuleLevel)),
        ets:insert(?MODULE, {Module, ModuleLevelInteger})
    end, LevelByModule),

    {noreply, State}.

handle_info(_Info, State) ->
    {ok, State}.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

terminate(_Arg, _State) ->
    ok.


% Read Bytes bytes from the end of log file, jumping Offset bytes towards
% the beginning of the file first.
%
%  Log File    FilePos
%  ----------
% |          |  10
% |          |  20
% |          |  30
% |          |  40
% |          |  50
% |          |  60
% |          |  70 -- Bytes = 20  --
% |          |  80                 | Chunk
% |          |  90 -- Offset = 10 --
% |__________| 100

read(Bytes, Offset) ->
    LogFileName = log_file(),
    LogFileSize = filelib:file_size(LogFileName),
    MaxChunkSize = list_to_integer(
        couch_config:get("httpd", "log_max_chunk_size", "1000000")),
    case Bytes > MaxChunkSize of
    true ->
        throw({bad_request, "'bytes' cannot exceed " ++
            integer_to_list(MaxChunkSize)});
    false ->
        ok
    end,

    {ok, Fd} = file:open(LogFileName, [read]),
    Start = lists:max([LogFileSize - Bytes - Offset, 0]),

    % TODO: truncate chopped first line
    % TODO: make streaming

    {ok, Chunk} = file:pread(Fd, Start, Bytes),
    ok = file:close(Fd),
    Chunk.


maybe_start_logfile_backend(Filename, Level) ->
    Started = case application:get_env(lager, handlers) of
        undefined -> false;
        {ok, Handlers} ->
            LogFiles = lists:foldl(fun
                    ({lager_file_backend, Config}, Acc) ->
                        [hfile(Config) | Acc];
                    (_, Acc) ->
                        Acc
                end, [], Handlers),
            lists:member(Filename, LogFiles)
    end,

    case Started of
        true -> ok;
        false ->
            Config = [{file, Filename},
                      {level, Level},
                      {formatter, lager_default_formatter},
                      {formatter_config,
                       ["[", time, "] [", pid, "] [", severity, "] ",
                        message, "\n"]}],
            HandlerId = {lager_file_backend, Filename},
            {ok, _} = supervisor:start_child(lager_handler_watcher_sup,
                                             [lager_event, HandlerId, Config])
    end.


restart_logfile_backend(OldFilename, Filename, Level) ->
    ok = gen_event:delete_handler(lager_event, {lager_file_backend,
                                                OldFilename}, []),

    %% restart a new handler
    Config = [{file, Filename},
              {level, Level},
              {formatter, lager_default_formatter},
              {formatter_config,
               ["[", time, "] [", pid, "] [", severity, "] ", message, "\n"]}],
    HandlerId = {lager_file_backend, Filename},
    {ok, _} = supervisor:start_child(lager_handler_watcher_sup,
                                     [lager_event, HandlerId, Config]),
    ok.

set_loglevel(Filename, ALevel) ->
    %% set default log level
    lager:set_loglevel(lager_console_backend, ALevel),
    lager:set_loglevel(lager_file_backend, Filename, ALevel),

    %% set the log level for other handlers
    case application:get_env(lager, handlers) of
        undefined -> ok;
        {ok, Handlers} ->
            lists:foreach(fun(Handler) ->
                        lager:set_loglevel(Handler, ALevel)
                end, Handlers)
    end.

log_file() ->
    DefaultLogFile = case application:get_env(couch, log_file) of
        undefined -> "couchdb.log";
        FName -> FName
    end,
    couch_config:get("log", "file", DefaultLogFile).

hfile({FileName, LogLevel}) when is_list(FileName), is_atom(LogLevel) ->
    %% backwards compatability hack
    FileName;
hfile({FileName, LogLevel, _Size, _Date, _Count})
        when is_list(FileName), is_atom(LogLevel) ->
    %% backwards compatability hack
    FileName;
hfile([{FileName, LogLevel, _Size, _Date, _Count}, {Formatter, _FormatterConfig}])
    when is_list(FileName), is_atom(LogLevel), is_atom(Formatter) ->
    %% backwards compatability hack
    FileName;
hfile([LogFile,{Formatter}]) ->
    %% backwards compatability hack
    hfile([LogFile,{Formatter,[]}]);
hfile([{FileName, LogLevel}, {Formatter, _FormatterConfig}])
    when is_list(FileName), is_atom(LogLevel), is_atom(Formatter) ->
    %% backwards compatability hack
   FileName;
hfile(LogFileConfig) when is_list(LogFileConfig) ->
    proplists:get_value(file, LogFileConfig).