/*
 * Copyright (C) 2016 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.
 */

#include "nanomessage.h"

#include <inttypes.h>
#include <stdio.h>

#include "apptohostevent.h"
#include "log.h"
#include "logevent.h"
#include "resetreasonevent.h"
#include "sensorevent.h"

namespace android {

/* HardwareVersionInfo ********************************************************/

bool HardwareVersionInfo::Populate(const std::vector<uint8_t>& buffer) {
    if (buffer.size() != sizeof(VersionInfo)) {
        return false;
    }

    const uint8_t *data = buffer.data();
    const VersionInfo *source = reinterpret_cast<const VersionInfo *>(data);
    info = *source;
    return true;
}

std::string HardwareVersionInfo::ToString() const {
    const char format_string[] = "Hardware version info:\n"
        "    Hardware type: %04x\n"
        "    Hardware version: %04x\n"
        "    Bootloader version: %04x\n"
        "    Operating system version: %04x\n"
        "    Variant version: %08x\n";

    char buffer[1024];
    snprintf(buffer, sizeof(buffer), format_string,
        info.hardware_type,
        info.hardware_version,
        info.bootloader_version,
        info.operating_system_version,
        info.variant_version);
    return std::string(buffer);
}

/* WriteEventResponse *********************************************************/

std::string WriteEventResponse::ToString() const {
    const char format_string[] = "Write event accepted: %s\n";

    char buffer[128];
    snprintf(buffer, sizeof(buffer), format_string,
        response.accepted ? "true" : "false");
    return std::string(buffer);
}

bool WriteEventResponse::Populate(const std::vector<uint8_t>& buffer) {
    if (buffer.size() != sizeof(Response)) {
        return false;
    }

    const uint8_t *data = buffer.data();
    const Response *source = reinterpret_cast<const Response *>(data);
    response = *source;
    return true;

}

/* ReadEventRequest ***********************************************************/

std::vector<uint8_t> ReadEventRequest::GetBytes() const {
    std::vector<uint8_t> buffer(sizeof(Request));

    uint8_t *data = buffer.data();
    Request *req = reinterpret_cast<Request *>(data);
    *req = request;
    return buffer;
}

std::string ReadEventRequest::ToString() const {
    const char format_string[] = "Read event at time: %" PRIx64 "\n";

    char buffer[128];
    snprintf(buffer, sizeof(buffer), format_string,
        request.boot_time);
    return std::string(buffer);
}

/* ReadEventResponse **********************************************************/

std::string ReadEventResponse::ToString() const {
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "ReadEventResponse %u\n", GetEventType());
    return std::string(buffer);
}

std::unique_ptr<ReadEventResponse> ReadEventResponse::FromBytes(
        const std::vector<uint8_t>& buffer) {
    // The first 4 bytes of any event must be the event type - use it to figure
    // out which class to construct
    uint32_t event_type = ReadEventResponse::EventTypeFromBuffer(buffer);
    if (ReadEventResponse::IsSensorEvent(event_type)) {
        return SensorEvent::FromBytes(buffer);
    } else if (ReadEventResponse::IsAppToHostEvent(event_type)) {
        return AppToHostEvent::FromBytes(buffer);
    } else if (ReadEventResponse::IsResetReasonEvent(event_type)) {
        return ResetReasonEvent::FromBytes(buffer);
    } else if (ReadEventResponse::IsLogEvent(event_type)) {
        return LogEvent::FromBytes(buffer);
    } else {
        LOGW("Received unexpected/unsupported event type %u", event_type);
        return nullptr;
    }
}

bool ReadEventResponse::Populate(const std::vector<uint8_t>& buffer) {
    if (buffer.size() < sizeof(Event)) {
        return false;
    }

    event_data.resize(buffer.size());
    std::copy(buffer.begin(), buffer.end(), event_data.begin());
    return true;
}

bool ReadEventResponse::IsAppToHostEvent() const {
    return ReadEventResponse::IsAppToHostEvent(GetEventType());
}

bool ReadEventResponse::IsSensorEvent() const {
    return ReadEventResponse::IsSensorEvent(GetEventType());
}

bool ReadEventResponse::IsResetReasonEvent() const {
    return ReadEventResponse::IsResetReasonEvent(GetEventType());
}

bool ReadEventResponse::IsLogEvent() const {
    return ReadEventResponse::IsLogEvent(GetEventType());
}

uint32_t ReadEventResponse::GetEventType() const {
    return ReadEventResponse::EventTypeFromBuffer(event_data);
}

bool ReadEventResponse::IsSensorEvent(uint32_t event_type) {
    return (event_type >= static_cast<uint32_t>(EventType::FirstSensorEvent) &&
            event_type <= static_cast<uint32_t>(EventType::LastSensorEvent));
}

bool ReadEventResponse::IsAppToHostEvent(uint32_t event_type) {
    return (event_type == static_cast<uint32_t>(EventType::AppToHostEvent));
}

bool ReadEventResponse::IsResetReasonEvent(uint32_t event_type) {
    return (event_type == static_cast<uint32_t>(EventType::ResetReasonEvent));
}

bool ReadEventResponse::IsLogEvent(uint32_t event_type) {
    return (event_type == static_cast<uint32_t>(EventType::LogEvent));
}

uint32_t ReadEventResponse::EventTypeFromBuffer(const std::vector<uint8_t>& buffer) {
    if (buffer.size() < sizeof(uint32_t)) {
        LOGW("Invalid/short event of size %zu", buffer.size());
        return 0;
    }
    return *reinterpret_cast<const uint32_t *>(buffer.data());
}

/* ConfigureSensorRequest *****************************************************/

ConfigureSensorRequest::ConfigureSensorRequest() {
    config.event_type = static_cast<uint32_t>(EventType::ConfigureSensor);
}

uint32_t ConfigureSensorRequest::FloatRateToFixedPoint(float rate) {
    return rate * 1024.0f;
}

float ConfigureSensorRequest::FixedPointRateToFloat(uint32_t rate) {
    return rate / 1024.0f;
}

// TODO(aarossig): Consider writing a template function for this.
std::vector<uint8_t> ConfigureSensorRequest::GetBytes() const {
    std::vector<uint8_t> buffer(sizeof(Configuration));

    uint8_t *data = buffer.data();
    Configuration *configuration = reinterpret_cast<Configuration *>(data);
    *configuration = config;
    buffer.insert(buffer.end(), extra_data_.begin(), extra_data_.end());

    return buffer;
}

void ConfigureSensorRequest::SetAdditionalData(const std::vector<uint8_t>& data) {
    extra_data_ = data;
}

std::string ConfigureSensorRequest::ToString() const {
    const char format_string[] = "Sensor configuration:\n"
        "    latency: %" PRIx64 "\n"
        "    rate (fixed point): %08x\n"
        "    sensor_type: %02x\n"
        "    command: %02x\n"
        "    flags: %04x\n";

    char buffer[1024];
    snprintf(buffer, sizeof(buffer), format_string,
            config.latency,
            config.rate,
            config.sensor_type,
            config.command,
            config.flags);
    return std::string(buffer);
}

EventType ConfigureSensorRequest::GetEventType() const {
    return static_cast<EventType>(config.event_type);
}

/* BridgeVersionInfoRequest ***************************************************/

std::vector<uint8_t> BridgeVersionInfoRequest::GetBytes() const {
    struct VersionInfoRequestEvent : public Event {
        struct BrHostEventTx event_data;
    } __attribute__((packed));

    std::vector<uint8_t> buffer(sizeof(VersionInfoRequestEvent));

    std::fill(buffer.begin(), buffer.end(), 0);
    auto event = reinterpret_cast<VersionInfoRequestEvent *>(buffer.data());
    event->event_type = static_cast<uint32_t>(EventType::AppFromHostEvent);
    event->event_data.hdr.appId   = kAppIdBridge;
    event->event_data.hdr.dataLen = sizeof(BrHostEventData);
    event->event_data.data.msgId  = BRIDGE_HOST_EVENT_MSG_VERSION_INFO;

    return buffer;
}

EventType BridgeVersionInfoRequest::GetEventType() const {
    return EventType::AppFromHostEvent;
}

std::string BridgeVersionInfoRequest::ToString() const {
    return std::string("Bridge version info request\n");
}

}  // namespace android