/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
#ifndef __SYS_LOG_FULL_H__
#define __SYS_LOG_FULL_H__

#include "os/mynewt.h"
#include "cbmem/cbmem.h"
#include "log_common/log_common.h"
#if MYNEWT_VAL(LOG_STATS)
#include "stats/stats.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

struct log;
struct log_entry_hdr;

/**
 * Used for walks and reads; indicates part of log to access.
 */
struct log_offset {
    /* If   lo_ts == -1: Only access last log entry;
     * Elif lo_ts == 0:  Don't filter by timestamp;
     * Else:             Only access entries whose ts >= lo_ts.
     */
    int64_t lo_ts;

    /* Only access entries whose index >= lo_index. */
    uint32_t lo_index;

    /* On read, lo_data_len gets populated with the number of bytes read. */
    uint32_t lo_data_len;

    /* Specific to walk / read function. */
    void *lo_arg;
};

#if MYNEWT_VAL(LOG_STORAGE_INFO)
/**
 * Log storage information
 */
struct log_storage_info {
    uint32_t size;
    uint32_t used;
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
    uint32_t used_unread;
#endif
};
#endif

typedef int (*log_walk_func_t)(struct log *, struct log_offset *log_offset,
        void *dptr, uint16_t len);

typedef int (*log_walk_body_func_t)(struct log *log,
        struct log_offset *log_offset, const struct log_entry_hdr *hdr,
        void *dptr, uint16_t len);

typedef int (*lh_read_func_t)(struct log *, void *dptr, void *buf,
        uint16_t offset, uint16_t len);
typedef int (*lh_read_mbuf_func_t)(struct log *, void *dptr, struct os_mbuf *om,
                                   uint16_t offset, uint16_t len);
typedef int (*lh_append_func_t)(struct log *, void *buf, int len);
typedef int (*lh_append_body_func_t)(struct log *log,
                                     const struct log_entry_hdr *hdr,
                                     const void *body, int body_len);
typedef int (*lh_append_mbuf_func_t)(struct log *, const struct os_mbuf *om);
typedef int (*lh_append_mbuf_body_func_t)(struct log *log,
                                          const struct log_entry_hdr *hdr,
                                          const struct os_mbuf *om);
typedef int (*lh_walk_func_t)(struct log *,
        log_walk_func_t walk_func, struct log_offset *log_offset);
typedef int (*lh_flush_func_t)(struct log *);
#if MYNEWT_VAL(LOG_STORAGE_INFO)
typedef int (*lh_storage_info_func_t)(struct log *, struct log_storage_info *);
#endif
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
typedef int (*lh_set_watermark_func_t)(struct log *, uint32_t);
#endif
typedef int (*lh_registered_func_t)(struct log *);

struct log_handler {
    int log_type;
    lh_read_func_t log_read;
    lh_read_mbuf_func_t log_read_mbuf;
    lh_append_func_t log_append;
    lh_append_body_func_t log_append_body;
    lh_append_mbuf_func_t log_append_mbuf;
    lh_append_mbuf_body_func_t log_append_mbuf_body;
    lh_walk_func_t log_walk;
    lh_flush_func_t log_flush;
#if MYNEWT_VAL(LOG_STORAGE_INFO)
    lh_storage_info_func_t log_storage_info;
#endif
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
    lh_set_watermark_func_t log_set_watermark;
#endif
    /* Functions called only internally (no API for apps) */
    lh_registered_func_t log_registered;
};

#if MYNEWT_VAL(LOG_VERSION) == 2
struct log_entry_hdr {
    int64_t ue_ts;
    uint32_t ue_index;
    uint8_t ue_module;
    uint8_t ue_level;
}__attribute__((__packed__));
#elif MYNEWT_VAL(LOG_VERSION) == 3
struct log_entry_hdr {
    int64_t ue_ts;
    uint32_t ue_index;
    uint8_t ue_module;
    uint8_t ue_level;
    uint8_t ue_etype;
}__attribute__((__packed__));
#else
#error "Unsupported log version"
#endif

#define LOG_ENTRY_HDR_SIZE (sizeof(struct log_entry_hdr))

#define LOG_MODULE_STR(module)      log_module_get_name(module)

#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_DEBUG
#define LOG_DEBUG(__l, __mod, __msg, ...) log_printf(__l, __mod, \
        LOG_LEVEL_DEBUG, __msg, ##__VA_ARGS__)
#else
#define LOG_DEBUG(__l, __mod, ...) IGNORE(__VA_ARGS__)
#endif

#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_INFO
#define LOG_INFO(__l, __mod, __msg, ...) log_printf(__l, __mod, \
        LOG_LEVEL_INFO, __msg, ##__VA_ARGS__)
#else
#define LOG_INFO(__l, __mod, ...) IGNORE(__VA_ARGS__)
#endif

#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_WARN
#define LOG_WARN(__l, __mod, __msg, ...) log_printf(__l, __mod, \
        LOG_LEVEL_WARN, __msg, ##__VA_ARGS__)
#else
#define LOG_WARN(__l, __mod, ...) IGNORE(__VA_ARGS__)
#endif

#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_ERROR
#define LOG_ERROR(__l, __mod, __msg, ...) log_printf(__l, __mod, \
        LOG_LEVEL_ERROR, __msg, ##__VA_ARGS__)
#else
#define LOG_ERROR(__l, __mod, ...) IGNORE(__VA_ARGS__)
#endif

#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_CRITICAL
#define LOG_CRITICAL(__l, __mod, __msg, ...) log_printf(__l, __mod, \
        LOG_LEVEL_CRITICAL, __msg, ##__VA_ARGS__)
#else
#define LOG_CRITICAL(__l, __mod, ...) IGNORE(__VA_ARGS__)
#endif

#if MYNEWT_VAL(LOG_STATS)
STATS_SECT_START(logs)
    STATS_SECT_ENTRY(writes)
    STATS_SECT_ENTRY(drops)
    STATS_SECT_ENTRY(errs)
    STATS_SECT_ENTRY(lost)
STATS_SECT_END

#define LOG_STATS_INC(log, name)        STATS_INC(log->l_stats, name)
#define LOG_STATS_INCN(log, name, cnt)  STATS_INCN(log->l_stats, name, cnt)
#else
#define LOG_STATS_INC(log, name)
#define LOG_STATS_INCN(log, name, cnt)
#endif

struct log {
    char *l_name;
    const struct log_handler *l_log;
    void *l_arg;
    STAILQ_ENTRY(log) l_next;
    log_append_cb *l_append_cb;
    uint8_t l_level;
#if MYNEWT_VAL(LOG_STATS)
    STATS_SECT_DECL(logs) l_stats;
#endif
};

/* Log system level functions (for all logs.) */
void log_init(void);
struct log *log_list_get_next(struct log *);

/*
 * Register per-user log module
 *
 * This function associates user log module with given name.
 *
 * If \p id is non-zero, module is registered with selected id.
 * If \p id is zero, module id is selected automatically (first available).
 *
 * Up to `LOG_MAX_USER_MODULES` (syscfg) modules can be registered with ids
 * starting from `LOG_MODULE_PERUSER`.
 *
 * @param id    Selected module id
 * @param name  Module name
 *
 * @return  module id on success, 0 on failure
 */
uint8_t log_module_register(uint8_t id, const char *name);

/*
 * Get name for module id
 *
 * This works for both system and user registered modules.
 *
 * @param id  Module id
 *
 * @return  module name or NULL if not a valid module
 */
const char *log_module_get_name(uint8_t id);

/* Log functions, manipulate a single log */
int log_register(char *name, struct log *log, const struct log_handler *,
                 void *arg, uint8_t level);

/**
 * @brief Configures the given log with the specified append callback.
 *
 * A log's append callback is executed each time an entry is appended to the
 * log.
 *
 * @param log                   The log to configure.
 * @param cb                    The callback to associate with the log.
 */
void log_set_append_cb(struct log *log, log_append_cb *cb);

/**
 * @brief Searches the list of registered logs for one with the specified name.
 *
 * @param name                  The name of the log to search for.
 *
 * @return                      The sought after log if found, NULL otherwise.
 */
struct log *log_find(const char *name);

/**
 * @brief Writes the raw contents of a flat buffer to the specified log.
 *
 * NOTE: The flat buffer must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  This padding is *not* reflected in the specified
 * length.  So, to log the string "abc", you should pass the following
 * arguments to this function:
 *
 *     data: <padding>abc   (total of `LOG_ENTRY_HDR_SIZE`+3 bytes.)
 *     len: 3
 *
 * @param log                   The log to write to.
 * @param module                The log module of the entry to write.
 * @param level                 The severity of the log entry to write.
 * @param etype                 The type of data being written; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param data                  The flat buffer to write.
 * @param len                   The number of bytes in the *message body*.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_typed(struct log *log, uint8_t module, uint8_t level,
                     uint8_t etype, void *data, uint16_t len);

/**
 * @brief Logs the contents of the provided mbuf, only freeing the mbuf on
 * failure.
 *
 * Logs the contents of the provided mbuf, only freeing the mbuf on failure.
 * On success, the mbuf remains allocated, but its structure may have been
 * modified by pullup operations.  The updated mbuf address is passed back to
 * the caller via a write to the supplied mbuf pointer-to-pointer.
 *
 * NOTE: The mbuf must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  So, to log the string "abc", you should pass an mbuf
 * with the following characteristics:
 *
 *     om_data: <padding>abc
 *     om_len: `LOG_ENTRY_HDR_SIZE` + 3
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param etype                 The type of data to write; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param om_ptr                Indirectly points to the mbuf to write.  This
 *                                  function updates the mbuf address if it
 *                                  changes.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_mbuf_typed_no_free(struct log *log, uint8_t module,
                                  uint8_t level, uint8_t etype,
                                  struct os_mbuf **om_ptr);

/**
 * @brief Logs the contents of the provided mbuf.
 *
 * Logs the contents of the provided mbuf.  This function always frees the mbuf
 * regardless of the outcome.
 *
 * NOTE: The mbuf must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  So, to log the string "abc", you should pass an mbuf
 * with the following characteristics:
 *
 *     om_data: <padding>abc
 *     om_len: `LOG_ENTRY_HDR_SIZE` + 3
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param etype                 The type of data to write; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param om                    The mbuf to write.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_mbuf_typed(struct log *log, uint8_t module, uint8_t level,
                          uint8_t etype, struct os_mbuf *om);

/**
 * @brief Writes the contents of a flat buffer to the specified log.
 *
 * @param log                   The log to write to.
 * @param module                The log module of the entry to write.
 * @param level                 The severity of the log entry to write.
 * @param etype                 The type of data being written; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param data                  The flat buffer to write.
 * @param len                   The number of bytes in the message body.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_body(struct log *log, uint8_t module, uint8_t level,
                    uint8_t etype, const void *body, uint16_t body_len);

/**
 * @brief Logs the contents of the provided mbuf, only freeing the mbuf on
 * failure.
 *
 * Logs the contents of the provided mbuf, only freeing the mbuf on failure.
 * On success, the mbuf remains allocated, but its structure may have been
 * modified by pullup operations.  The updated mbuf address is passed back to
 * the caller via a write to the supplied mbuf pointer-to-pointer.
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param etype                 The type of data to write; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param om_ptr                Indirectly points to the mbuf to write.  This
 *                                  function updates the mbuf address if it
 *                                  changes.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_mbuf_body_no_free(struct log *log, uint8_t module,
                                 uint8_t level, uint8_t etype,
                                 struct os_mbuf *om);

/**
 * @brief Logs the contents of the provided mbuf.
 *
 * Logs the contents of the provided mbuf.  This function always frees the mbuf
 * regardless of the outcome.
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param etype                 The type of data to write; one of the
 *                                  `LOG_ETYPE_[...]` constants.
 * @param om                    The mbuf to write.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_append_mbuf_body(struct log *log, uint8_t module, uint8_t level,
                         uint8_t etype, struct os_mbuf *om);

#if MYNEWT_VAL(LOG_CONSOLE)
struct log *log_console_get(void);
void log_console_init(void);
#endif

/**
 * @brief Writes the raw contents of a flat buffer to the specified log.
 *
 * NOTE: The flat buffer must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  This padding is *not* reflected in the specified
 * length.  So, to log the string "abc", you should pass the following
 * arguments to this function:
 *
 *     data: <padding>abc   (total of `LOG_ENTRY_HDR_SIZE`+3 bytes.)
 *     len: 3
 *
 * @param log                   The log to write to.
 * @param module                The log module of the entry to write.
 * @param level                 The severity of the log entry to write.
 * @param data                  The flat buffer to write.
 * @param len                   The number of byte in the *message body*.
 *
 * @return                      0 on success; nonzero on failure.
 */
static inline int
log_append(struct log *log, uint8_t module, uint8_t level, void *data,
           uint16_t len)
{
    return log_append_typed(log, module, level, LOG_ETYPE_STRING, data, len);
}

/**
 * @brief Logs the contents of the provided mbuf, only freeing the mbuf on
 * failure.
 *
 * Logs the contents of the provided mbuf, only freeing the mbuf on failure.
 * On success, the mbuf remains allocated, but its structure may have been
 * modified by pullup operations.  The updated mbuf address is passed back to
 * the caller via a write to the supplied mbuf pointer-to-pointer.
 *
 * NOTE: The mbuf must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  So, to log the string "abc", you should pass an mbuf
 * with the following characteristics:
 *
 *     om_data: <padding>abc
 *     om_len: `LOG_ENTRY_HDR_SIZE` + 3
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param om_ptr                Indirectly points to the mbuf to write.  This
 *                                  function updates the mbuf address if it
 *                                  changes.
 *
 * @return                      0 on success; nonzero on failure.
 */
static inline int
log_append_mbuf_no_free(struct log *log, uint8_t module, uint8_t level,
                        struct os_mbuf **om)
{
    return log_append_mbuf_typed_no_free(log, module, level, LOG_ETYPE_STRING,
                                         om);
}

/**
 * @brief Logs the contents of the provided mbuf.
 *
 * Logs the contents of the provided mbuf.  This function always frees the mbuf
 * regardless of the outcome.
 *
 * NOTE: The mbuf must have an initial padding of length
 * `LOG_ENTRY_HDR_SIZE`.  So, to log the string "abc", you should pass an mbuf
 * with the following characteristics:
 *
 *     om_data: <padding>abc
 *     om_len: `LOG_ENTRY_HDR_SIZE` + 3
 *
 * @param log                   The log to write to.
 * @param module                The module ID of the entry to write.
 * @param level                 The severity of the entry to write; one of the
 *                                  `LOG_LEVEL_[...]` constants.
 * @param om                    The mbuf to write.
 *
 * @return                      0 on success; nonzero on failure.
 */
static inline int
log_append_mbuf(struct log *log, uint8_t module, uint8_t level,
                struct os_mbuf *om)
{
    return log_append_mbuf_typed(log, module, level, LOG_ETYPE_STRING, om);
}

void log_printf(struct log *log, uint8_t module, uint8_t level,
        const char *msg, ...);
int log_read(struct log *log, void *dptr, void *buf, uint16_t off,
        uint16_t len);

/**
 * @brief Reads a single log entry header.
 *
 * @param log                   The log to read from.
 * @param dptr                  Medium-specific data describing the area to
 *                                  read from; typically obtained by a call to
 *                                  `log_walk`.
 * @param hdr                   The destination header to read into.
 *
 * @return                      0 on success; nonzero on failure.
 */
int log_read_hdr(struct log *log, void *dptr, struct log_entry_hdr *hdr);

/**
 * @brief Reads data from the body of a log entry into a flat buffer.
 *
 * @param log                   The log to read from.
 * @param dptr                  Medium-specific data describing the area to
 *                                  read from; typically obtained by a call to
 *                                  `log_walk`.
 * @param buf                   The destination buffer to read into.
 * @param off                   The offset within the log entry at which to
 *                                  start the read.
 * @param len                   The number of bytes to read.
 *
 * @return                      The number of bytes actually read on success;
 *                              -1 on failure.
 */
int log_read_body(struct log *log, void *dptr, void *buf, uint16_t off,
                  uint16_t len);
int log_read_mbuf(struct log *log, void *dptr, struct os_mbuf *om, uint16_t off,
                  uint16_t len);
/**
 * @brief Reads data from the body of a log entry into an mbuf.
 *
 * @param log                   The log to read from.
 * @param dptr                  Medium-specific data describing the area to
 *                                  read from; typically obtained by a call to
 *                                  `log_walk`.
 * @param om                    The destination mbuf to read into.
 * @param off                   The offset within the log entry at which to
 *                                  start the read.
 * @param len                   The number of bytes to read.
 *
 * @return                      The number of bytes actually read on success;
 *                              -1 on failure.
 */
int log_read_mbuf_body(struct log *log, void *dptr, struct os_mbuf *om,
                       uint16_t off, uint16_t len);
int log_walk(struct log *log, log_walk_func_t walk_func,
        struct log_offset *log_offset);

/**
 * @brief Applies a callback to each message in the specified log.
 *
 * Similar to `log_walk`, except it passes the message header and body
 * separately to the callback.
 *
 * @param log                   The log to iterate.
 * @param walk_body_func        The function to apply to each log entry.
 * @param log_offset            Specifies the range of entries to process.
 *                                  Entries not matching these criteria are
 *                                  skipped during the walk.
 *
 * @return                      0 if the walk completed successfully;
 *                              nonzero on error or if the walk was aborted.
 */
int log_walk_body(struct log *log, log_walk_body_func_t walk_body_func,
        struct log_offset *log_offset);
int log_flush(struct log *log);

#if MYNEWT_VAL(LOG_MODULE_LEVELS)
/**
 * @brief Retrieves the globally configured minimum log level for the specified
 * module ID.
 *
 * Writes with a level less than the module's minimum level are discarded.
 *
 * @param module                The module whose level should be retrieved.
 *
 * @return                      The configured minimum level, or 0
 *                                  (LOG_LEVEL_DEBUG) if unconfigured.
 */
uint8_t log_level_get(uint8_t module);

/**
 * @brief Sets the globally configured minimum log level for the specified
 * module ID.
 *
 * Writes with a level less than the module's minimum level are discarded.
 *
 * @param module                The module to configure.
 * @param level                 The minimum level to assign to the module
 *                                  (0-15, inclusive).
 */
int log_level_set(uint8_t module, uint8_t level);
#else
static inline uint8_t
log_level_get(uint8_t module)
{
    /* All levels enabled. */
    return 0;
}

static inline int
log_level_set(uint8_t module, uint8_t level)
{
    return SYS_ENOTSUP;
}
#endif

#if MYNEWT_VAL(LOG_STORAGE_INFO)
/**
 * Return information about log storage
 *
 * This return information about size and usage of storage on top of which log
 * instance is created.
 *
 * @param log   The log to query.
 * @param info  The destination to write information to.
 *
 * @return 0 on success, error code otherwise
 *
 */
int log_storage_info(struct log *log, struct log_storage_info *info);
#endif
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
/**
 * Set watermark on log
 *
 * This sets watermark on log item with given index. This information is used
 * to calculate size of entries which were logged after watermark item, i.e.
 * unread items. The watermark is stored persistently for each log.
 *
 * @param log    The log to set watermark on.
 * @param index  The index of a watermarked item.
 *
 * @return 0 on success, error code otherwise.
 */
int log_set_watermark(struct log *log, uint32_t index);
#endif

/* Handler exports */
#if MYNEWT_VAL(LOG_CONSOLE)
extern const struct log_handler log_console_handler;
#endif
extern const struct log_handler log_cbmem_handler;
#if MYNEWT_VAL(LOG_FCB)
extern const struct log_handler log_fcb_handler;
extern const struct log_handler log_fcb_slot1_handler;
#endif

/* Private */
#if MYNEWT_VAL(LOG_NEWTMGR)
int log_nmgr_register_group(void);
#endif

#ifdef __cplusplus
}
#endif

#endif /* __SYS_LOG_FULL_H__ */