// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <algorithm>

#include "types.h"

using std::string;
using std::vector;

const std::map<string, string> rust_overrides = {
    {"any[]IN", "*const u8"},
    {"any[]OUT", "*mut u8"},
    {"any[]INOUT", "*mut u8"}};

const std::map<string, string> rust_primitives = {
    {"int8_t", "i8"},
    {"int16_t", "i16"},
    {"int32_t", "i32"},
    {"int64_t", "i64"},
    {"uint8_t", "u8"},
    {"uint16_t", "u16"},
    {"uint32_t", "u32"},
    {"uint64_t", "u64"},
    {"size_t", "usize"},
    {"uintptr_t", "usize"},
    {"int", "isize"},
    {"char", "u8"},
    {"float", "f32"},
    {"double", "f64"},
};

const std::map<string, string> rust_reserved_words = {
    {"proc", "proc_"},
};

bool has_attribute(const char* attr, const vector<string>& attrs) {
    return std::find(attrs.begin(), attrs.end(), attr) != attrs.end();
}

void dump_attributes(const vector<string>& attrs) {
    for (auto& a : attrs) {
        fprintf(stderr, "%s ", a.c_str());
    }
    fprintf(stderr, "\n");
}

string ArraySpec::kind_str() const {
    switch (kind) {
    case IN:
        return "IN";
    case OUT:
        return "OUT";
    default:
        return "INOUT";
    }
}

string ArraySpec::kind_lowercase_str() const {
    switch (kind) {
    case IN:
        return "in";
    case OUT:
        return "out";
    default:
        return "inout";
    }
}

bool ArraySpec::assign_kind(const vector<string>& attrs) {
    if (has_attribute("IN", attrs)) {
        kind = ArraySpec::IN;
    } else if (has_attribute("OUT", attrs)) {
        kind = ArraySpec::OUT;
    } else if (has_attribute("INOUT", attrs)) {
        kind = ArraySpec::INOUT;
    } else {
        return false;
    }
    return true;
}

string ArraySpec::to_string() const {
    return "[]" + kind_str();
}

const string map_override(const string& name, const std::map<string, string>& overrides) {
    auto ft = overrides.find(name);
    return (ft == overrides.end()) ? name : ft->second;
}

string TypeSpec::to_string() const {
    return type + (arr_spec ? arr_spec->to_string() : string());
}

string TypeSpec::as_cpp_declaration(bool is_wrapped) const {
    if (!arr_spec) {
        return type + " " + name;
    }

    if (is_wrapped &&
        arr_spec->kind == ArraySpec::OUT && arr_spec->count == 1 &&
        type == "zx_handle_t") {
        return "user_out_handle* " + name;
    }

    string modifier = arr_spec->kind == ArraySpec::IN ? "const " : "";
    string ptr_type = type == "any" ? "void" : type;

    if (is_wrapped) {
        // This policy strings here matches the enum defined in the
        // kernel's user_ptr.h.
        string policy = arr_spec->kind_lowercase_str();
        return "user_" + policy + "_ptr<" + modifier + ptr_type + "> " + name;
    }
    return modifier + ptr_type + "* " + name;
}

string TypeSpec::as_rust_declaration() const {
    auto overridden = map_override(to_string(), rust_overrides);
    auto scalar_type = map_override(type, rust_primitives);
    auto safe_name = map_override(name, rust_reserved_words);

    if (overridden != to_string()) {
        return safe_name + ": " + overridden;
    } else if (!arr_spec) {
        return safe_name + ": " + scalar_type;
    } else {
        string ret = safe_name + ": ";
        if (arr_spec->kind == ArraySpec::IN) {
            ret += "*const ";
        } else {
            ret += "*mut ";
        }

        ret += scalar_type;
        if (arr_spec->count > 1)
            ret += " " + std::to_string(arr_spec->count);
        return ret;
    }
}

string TypeSpec::as_cpp_cast(const string& arg) const {
    if (!arr_spec) {
        return "static_cast<" + type + ">(" + arg + ")";
    }

    string modifier = arr_spec->kind == ArraySpec::IN ? "const " : "";
    string cast_type = type == "any" ? "void*" : type + "*";
    return "reinterpret_cast<" + modifier + cast_type + ">(" + arg + ")";
}

bool Syscall::is_vdso() const {
    return has_attribute("vdsocall", attributes);
}

bool Syscall::is_noreturn() const {
    return has_attribute("noreturn", attributes);
}

bool Syscall::is_blocking() const {
    return has_attribute("blocking", attributes);
}

bool Syscall::is_internal() const {
    return has_attribute("internal", attributes);
}

size_t Syscall::num_kernel_args() const {
    if (is_noreturn()) {
        return arg_spec.size();
    }

    // The first return value is passed as the ordinary C return
    // value, but only if there is at least one return value.
    size_t ret_values = ret_spec.size();
    if (ret_values > 0) {
        --ret_values;
    }
    return arg_spec.size() + ret_values;
}

void Syscall::for_each_return(const std::function<void(const TypeSpec&)>& cb) const {
    if (ret_spec.size() > 1) {
        std::for_each(ret_spec.begin() + 1, ret_spec.end(), cb);
    }
}

void Syscall::for_each_kernel_arg(const std::function<void(const TypeSpec&)>& cb) const {
    std::for_each(arg_spec.begin(), arg_spec.end(), cb);
    for_each_return(cb);
}

bool Syscall::validate() const {
    if (ret_spec.size() > 0 && is_noreturn()) {
        print_error("noreturn should have zero return arguments");
        return false;
    }

    if (num_kernel_args() > kMaxArgs) {
        print_error("invalid number of arguments");
        return false;
    }

    if (ret_spec.size() >= 1 && !ret_spec[0].name.empty()) {
        print_error("the first return argument cannot be named, yet...");
        return false;
    }

    if (is_blocking() &&
        (ret_spec.size() == 0 || ret_spec[0].type != "zx_status_t")) {
        print_error("blocking must have first return be of type zx_status_t");
        return false;
    }

    if (is_vdso() && is_internal()) {
        print_error("vdsocall cannot be internal");
        return false;
    }

    bool valid_args = true;
    for_each_kernel_arg([this, &valid_args](const TypeSpec& arg) {
        if (arg.name.empty()) {
            print_error("all arguments need to be named, except the first return");
            valid_args = false;
        }
        if (arg.arr_spec) {
            if (!validate_array_spec(arg)) {
                valid_args = false;
            }
        }
    });
    return valid_args;
}

void Syscall::assign_index(int* next_index) {
    if (!is_vdso())
        index = (*next_index)++;
}

bool Syscall::validate_array_spec(const TypeSpec& ts) const {
    if (ts.arr_spec->count > 0)
        return true;
    // find arguments that represent the array count.
    for (const string& multiplier : ts.arr_spec->multipliers) {
        auto arg = std::find_if(arg_spec.begin(), arg_spec.end(), [&](const TypeSpec& a) {
            return a.name == multiplier;
        });
        if (arg == arg_spec.end()) {
            std::string err = "invalid array spec for " + ts.name + ": '" + multiplier + "' does not refer to an argument";
            print_error(err.c_str());
            return false;
        }
        // TODO:cpu also enforce INOUT here.
        if (arg->arr_spec && arg->arr_spec->count != 1u) {
            std::string err = "invalid array spec for " + ts.name + ": '" + multiplier + "' refers to an array of size != 1";
            return false;
        }
    }
    return true;
}

void Syscall::print_error(const char* what) const {
    fprintf(stderr, "error: %s  : %s\n", name.c_str(), what);
}

string Syscall::return_type() const {
    if (ret_spec.empty()) {
        return "void";
    }
    return ret_spec[0].to_string();
}

bool Syscall::is_void_return() const {
    return return_type() == "void";
}