/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * 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.
 */

#ifndef ANDROID_MEDIA_NBLOG_WRITER_H
#define ANDROID_MEDIA_NBLOG_WRITER_H

#include <stdarg.h>
#include <stddef.h>

#include <binder/IMemory.h>
#include <media/nblog/Events.h>
#include <utils/Mutex.h>
#include <utils/RefBase.h>

class audio_utils_fifo;
class audio_utils_fifo_writer;

namespace android {

class IMemory;

namespace NBLog {

class Entry;
struct Shared;

// NBLog Writer Interface

// Writer is thread-safe with respect to Reader, but not with respect to multiple threads
// calling Writer methods.  If you need multi-thread safety for writing, use LockedWriter.
class Writer : public RefBase {
public:
    Writer() = default;         // dummy nop implementation without shared memory

    // Input parameter 'size' is the desired size of the timeline in byte units.
    // The size of the shared memory must be at least Timeline::sharedSize(size).
    Writer(void *shared, size_t size);
    Writer(const sp<IMemory>& iMemory, size_t size);

    ~Writer() override;

    // FIXME needs comments, and some should be private
    void    log(const char *string);
    void    logf(const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
    void    logTimestamp();
    void    logFormat(const char *fmt, log_hash_t hash, ...);
    void    logEventHistTs(Event event, log_hash_t hash);

    // Log data related to Event E. See the event-to-type mapping for the type of data
    // corresponding to the event. For example, if you see a mapping statement:
    //     MAP_TYPE_TO_EVENT(E, T);
    // then the usage of this method would be:
    //     T data = doComputation();
    //     tlNBLogWriter->log<NBLog::E>(data);
    template<Event E>
    void    log(typename get_mapped<E>::type data) {
        log(E, &data, sizeof(data));
    }

    virtual bool    isEnabled() const;

    // return value for all of these is the previous isEnabled()
    virtual bool    setEnabled(bool enabled);   // but won't enable if no shared memory
    bool            enable()  { return setEnabled(true); }
    bool            disable() { return setEnabled(false); }

    sp<IMemory>     getIMemory() const { return mIMemory; }

    // Public logging function implementations should always use one of the
    // two log() function calls below to write to shared memory.
protected:
    // Writes a single Entry to the FIFO if the writer is enabled.
    // This is protected and virtual because LockedWriter uses a lock to protect
    // writing to the FIFO before writing to this function.
    virtual void log(const Entry &entry, bool trusted = false);

private:
    // 0 <= length <= kMaxLength
    // Log a single Entry with corresponding event, data, and length.
    void    log(Event event, const void *data, size_t length);

    void    logvf(const char *fmt, va_list ap);

    // helper functions for logging parts of a formatted entry
    void    logStart(const char *fmt);
    void    logTimestampFormat();
    void    logVFormat(const char *fmt, log_hash_t hash, va_list ap);

    Shared* const   mShared{};          // raw pointer to shared memory
    sp<IMemory>     mIMemory{};         // ref-counted version, initialized in constructor
                                        // and then const
    audio_utils_fifo * const mFifo{};               // FIFO itself, non-NULL
                                                    // unless constructor fails
                                                    // or dummy constructor used
    audio_utils_fifo_writer * const mFifoWriter{};  // used to write to FIFO, non-NULL
                                                    // unless dummy constructor used
    bool            mEnabled = false;   // whether to actually log

    // cached pid and process name to use in %p format specifier
    // total tag length is mPidTagSize and process name is not zero terminated
    char   *mPidTag{};
    size_t  mPidTagSize = 0;
};

// ---------------------------------------------------------------------------

// Similar to Writer, but safe for multiple threads to call concurrently
class LockedWriter : public Writer {
public:
    LockedWriter() = default;
    LockedWriter(void *shared, size_t size);

    bool    isEnabled() const override;
    bool    setEnabled(bool enabled) override;

private:
    // Lock needs to be obtained before writing to FIFO.
    void log(const Entry &entry, bool trusted = false) override;

    mutable Mutex   mLock;
};

}   // namespace NBLog
}   // namespace android

#endif  // ANDROID_MEDIA_NBLOG_WRITER_H