/*
 * 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 "stack.h"

#include <gapic/log.h>

#define __STDC_FORMAT_MACROS
#include <inttypes.h>

#define DEBUG_STACK(...)

namespace gapir {

bool Stack::pushCheck(const char * what) {
    if (!mValid) {
        GAPID_WARNING("%s on invalid stack", what);
        return false;
    }

    if (mTop > mStack.size() - 1) {
        mValid = false;
        GAPID_WARNING("%s with invalid stack head, offset: %d", what, mTop);
        return false;
    }
    return true;
}

bool Stack::popCheck(const char * what) {
    if (!mValid) {
        GAPID_WARNING("%s on invalid stack", what);
        return false;
    }

    if (mTop == 0 || mTop > mStack.size()) {
        mValid = false;
        GAPID_WARNING("%s with invalid stack head, offset: %d", what, mTop);
        return false;
    }
    return true;
}

const char* Stack::Entry::debugInfo(const MemoryManager* memoryManager) const {
    static const size_t size = 256;
    static char buf[size];
    switch (mType) {
    case BaseType::Bool:
        snprintf(buf, size, "bool<%d>", value<bool>());
        break;
    case BaseType::Int8:
        snprintf(buf, size, "int8<%" PRId8 ">", value<int8_t>());
        break;
    case BaseType::Int16:
        snprintf(buf, size, "int16<%" PRId16 ">", value<int16_t>());
        break;
    case BaseType::Int32:
        snprintf(buf, size, "int32<%" PRId32 ">", value<int32_t>());
        break;
    case BaseType::Int64:
        snprintf(buf, size, "int64<%" PRId64 ">", value<int64_t>());
        break;
    case BaseType::Uint8:
        snprintf(buf, size, "uint8<%" PRIu8 ">", value<uint8_t>());
        break;
    case BaseType::Uint16:
        snprintf(buf, size, "uint16<%" PRIu16 ">", value<uint16_t>());
        break;
    case BaseType::Uint32:
        snprintf(buf, size, "uint32<%" PRIu32 ">", value<uint32_t>());
        break;
    case BaseType::Uint64:
        snprintf(buf, size, "uint64<%" PRIu64 ">", value<uint64_t>());
        break;
    case BaseType::Float:
        snprintf(buf, size, "float<%f>", value<float>());
        break;
    case BaseType::Double:
        snprintf(buf, size, "double<%f>", value<double>());
        break;
    case BaseType::AbsolutePointer: {
        const void* pointer = value<void*>();
        if (memoryManager->isNotObservedAbsoluteAddress(pointer)) {
            snprintf(buf, size, "absolute-ptr<%p> SPECIAL", value<void*>());
        } else {
            snprintf(buf, size, "absolute-ptr<%p> valid", value<void*>());
        }
        break;
    }
    case BaseType::ConstantPointer: {
        uint32_t offset = value<uint32_t>();
        const void* pointer = memoryManager->constantToAbsolute(offset);
        if (memoryManager->isConstantAddress(pointer)) {
            snprintf(buf, size, "constant-ptr<0x%x> valid (%p)", offset, pointer);
        } else {
            snprintf(buf, size, "constant-ptr<0x%x> INVALID (%p)", offset, pointer);
        }
        break;
    }
    case BaseType::VolatilePointer: {
        uint32_t offset = value<uint32_t>();
        const void* pointer = memoryManager->volatileToAbsolute(offset);
        if (memoryManager->isVolatileAddress(pointer)) {
            snprintf(buf, size, "volatile-ptr<0x%x> valid (%p)", offset, pointer);
        } else {
            snprintf(buf, size, "volatile-ptr<0x%x> INVALID (%p)", offset, pointer);
        }
        break;
    }
    default:
        snprintf(buf, size, "unknown type<%d>", int(mType));
        break;
    }
    return buf;
}

Stack::Stack(uint32_t size, const MemoryManager* memoryManager) :
        mValid(true), mTop(0), mStack(size), mMemoryManager(memoryManager) {
}

void Stack::printStack() const {
    GAPID_DEBUG("Stack size: %u", mTop);
    for (uint32_t i = 0; i < mTop; ++i) {
        GAPID_DEBUG("(%d) %s", i, mStack[i].debugInfo(mMemoryManager));
    }
}

BaseType Stack::getTopType() {
    if (!mValid) {
        GAPID_WARNING("GetTopType on invalid stack");
        return BaseType::Bool;
    }

    if (mTop == 0 || mTop > mStack.size()) {
        mValid = false;
        GAPID_WARNING("GetTopType with invalid stack head: %u (size: %zu)", mTop, mStack.size());
        return BaseType::Bool;
    }

    return mStack[mTop - 1].type();
}

void Stack::pushFrom(BaseType type, const void* data) {
    if (!pushCheck("pushFrom")) {
        return;
    }

    if (data == nullptr) {
        GAPID_WARNING("pushFrom nullptr");
        mValid = false;
        return;
    }

    mStack[mTop].set(type, data);
    DEBUG_STACK("+%s pushFrom(%p)\n", mStack[mTop].debugInfo(mMemoryManager), data);
    mTop++;
}

void Stack::popTo(void* address) {
    if (!popCheck("popTo")) {
        return;
    }

    switch (getTopType()) {
        case BaseType::ConstantPointer:
        case BaseType::VolatilePointer: {
            void* pointer = pop<void*>();
            // Note we are copying the pointer not what is pointed to.
            memcpy(address, &pointer, sizeof(pointer));
            return;
        }
        default:
            mTop--;
            DEBUG_STACK("-%s popTo(%p)\n", mStack[mTop].debugInfo(mMemoryManager), address);
            memcpy(address, mStack[mTop].valuePtr(), baseTypeSize(mStack[mTop].type()));
            return;
    }
}

void Stack::discard(uint32_t count) {
    if (!mValid) {
        GAPID_WARNING("Discard on invalid stack");
        return;
    }

    if (count > mTop) {
        mValid = false;
        GAPID_WARNING("Discarding more element (%u) then in the stack (%u)", count, mTop);
        return;
    }

    for (uint32_t i = 0; i < count; i++) {
        DEBUG_STACK("-%s discard()\n", mStack[mTop - i - 1].debugInfo(mMemoryManager));
    }

    mTop -= count;
}

void Stack::clone(uint32_t n) {
    if (!mValid) {
        GAPID_WARNING("Clone on invalid stack");
        return;
    }

    if (mTop >= mStack.size()) {
        mValid = false;
        GAPID_WARNING("Cloning to full stack");
        return;
    }

    if (mTop < n + 1) {
        mValid = false;
        GAPID_WARNING("Cloning from invalid index: %u (head: %u)", n, mTop);
        return;
    }

    mStack[mTop] = mStack[mTop - n - 1];
    DEBUG_STACK("+%s clone(%d)\n", mStack[mTop].debugInfo(mMemoryManager), n);
    mTop++;
}

const void* Stack::checkAndGetTopPointer(const char* what) {
    auto type = mStack[mTop].type();
    switch (type) {
        case BaseType::AbsolutePointer: {
            return mStack[mTop].value<const void*>();
        }
        case BaseType::ConstantPointer: {
            uint32_t offset = mStack[mTop].value<uint32_t>();
            const void* pointer = mMemoryManager->constantToAbsolute(offset);
            if (!mMemoryManager->isConstantAddress(pointer)) {
                GAPID_WARNING("%s: Invalid constant address %p offset %u", what, pointer, offset);
                mValid = false;
                return nullptr;
            }
            return pointer;
        }
        case BaseType::VolatilePointer: {
            uint32_t offset = mStack[mTop].value<uint32_t>();
            void* pointer = mMemoryManager->volatileToAbsolute(offset);
            if (!mMemoryManager->isVolatileAddress(pointer)) {
                GAPID_WARNING("%s Invalid volatile address %p offset %u", what, pointer, offset);
                mValid = false;
                return nullptr;
            }
            return pointer;
        }
        default:
            GAPID_WARNING("%s top was not a pointer type: %s", what, baseTypeName(type));
            mValid = false;
            return nullptr;
    }
    return nullptr;
}

bool Stack::checkTopForInvalidPointer(const char* what) {
    auto type = mStack[mTop].type();
    switch (type) {
        case BaseType::ConstantPointer:
        case BaseType::VolatilePointer: {
            checkAndGetTopPointer(what);
            return isValid();
        }
        default:
            return true;
    }
}

}  // namespace gapir