#include <BpBootDone.h>
int BpBootDone::set_boot_done() {
    if (!mChan.ok()) {
        return ERR_INVALID_ARGS;
    }
    ::tidl::RequestHeader req_hdr = {
            .cmd = CMD_set_boot_done,
    };
    Request_set_boot_done req = {};
    constexpr uint32_t req_num_handles =
            ::tidl::HandleOps<Request_set_boot_done>::num_handles;
    ::tidl::Handle req_handles[req_num_handles];
    ::tidl::Handle* hptr = req_handles;
    req.send_handles(hptr);
    assert(hptr == &req_handles[req_num_handles]);
    int rc = ::tidl::ipc::send(mChan.get(), &req_hdr, sizeof(req_hdr), &req,
                               sizeof(req), req_handles, req_num_handles);
    if (rc < 0) {
        return rc;
    }
    if (static_cast<size_t>(rc) != sizeof(req_hdr) + sizeof(req)) {
        return ERR_BAD_LEN;
    }
    rc = ::tidl::ipc::wait_for_msg(mChan.get());
    if (rc != NO_ERROR) {
        return rc;
    }
    ::tidl::ResponseHeader resp_hdr;
    rc = ::tidl::ipc::recv(mChan.get(), sizeof(resp_hdr), &resp_hdr,
                           sizeof(resp_hdr), nullptr, 0);
    if (rc < 0) {
        return rc;
    }
    if (static_cast<size_t>(rc) < sizeof(resp_hdr)) {
        return ERR_BAD_LEN;
    }
    if (resp_hdr.cmd != (CMD_set_boot_done | RESP_BIT)) {
        return ERR_CMD_UNKNOWN;
    }
    if (resp_hdr.rc != NO_ERROR) {
        if (static_cast<size_t>(rc) != sizeof(resp_hdr)) {
            return ERR_BAD_LEN;
        }
        return resp_hdr.rc;
    }
    if (static_cast<size_t>(rc) != sizeof(resp_hdr)) {
        return ERR_BAD_LEN;
    }
    return NO_ERROR;
}
int BpBootDone::connect(const char* port, uint32_t flags) {
    if (mChan.ok()) {
        return ERR_INVALID_ARGS;
    }
    return ::tidl::ipc::connect(port, flags, mChan);
}

bool BpBootDone::is_connected() {
    return (mChan.ok());
}
void BpBootDone::reset() {
    mChan.reset();
}
#if !defined(__QL_TIPC__)
#include <BnBootDone.h>
struct TIDL_PACKED_ATTR Request {
    ::tidl::RequestHeader hdr;
    union TIDL_PACKED_ATTR {
        BnBootDone::Request_set_boot_done set_boot_done;
    } req;
};
struct TIDL_PACKED_ATTR Response {
    ::tidl::ResponseHeader hdr;
    union TIDL_PACKED_ATTR {
    } resp;
};
union TIDL_PACKED_ATTR LongestMessage {
    Request req;
    Response resp;
};
BnBootDone::BnBootDone(const char* port,
                       const ::tidl::Service::PortAcl* acl,
                       uint32_t maximum_payload_size)
        : Service("BnBootDone",
                  port,
                  sizeof(LongestMessage) + maximum_payload_size,
                  acl,
                  &kOps) {}
int BnBootDone::get_instance(IBootDone*& instance, const struct uuid*) {
    instance = this;
    return NO_ERROR;
}
::tidl::Service::Ops BnBootDone::kOps = {
        .on_connect = BnBootDone::on_connect,
        .on_message = BnBootDone::on_message,
        .on_channel_cleanup = BnBootDone::on_channel_cleanup,
};
int BnBootDone::on_connect(const ::tidl::Service::Port* port,
                           ::tidl::Handle chan,
                           const struct uuid* peer,
                           void** ctx_p) {
    auto* bn_impl = static_cast<BnBootDone*>(
            reinterpret_cast<Service*>(const_cast<void*>(port->priv)));
    assert(bn_impl);
    IBootDone* instance;
    int rc = bn_impl->get_instance(instance, peer);
    if (rc != NO_ERROR) {
        return rc;
    }
    *ctx_p = instance;
    return NO_ERROR;
}
void BnBootDone::on_channel_cleanup(void* ctx) {
    auto* impl = reinterpret_cast<IBootDone*>(ctx);
    assert(impl);
    impl->destroy();
}
int BnBootDone::on_message(const ::tidl::Service::Port* port,
                           ::tidl::Handle chan,
                           void* ctx) {
    auto* impl = reinterpret_cast<IBootDone*>(ctx);
    auto* bn_impl = static_cast<BnBootDone*>(
            reinterpret_cast<Service*>(const_cast<void*>(port->priv)));
    assert(impl);
    assert(bn_impl);
    ::tidl::Payload req_payload;
    ::tidl::Payload resp_payload;
    ipc_msg_info_t mi;
    int rc = get_msg(chan, &mi);
    if (rc != NO_ERROR) {
        return rc;
    }
    bool call_put_msg = true;
    ::tidl::RequestHeader req_hdr;
    struct iovec req_hdr_iov = {.iov_base = &req_hdr,
                                .iov_len = sizeof(req_hdr)};
    ipc_msg_t req_hdr_msg = {.num_iov = 1,
                             .iov = &req_hdr_iov,
                             .num_handles = 0,
                             .handles = nullptr};
    rc = read_msg(chan, mi.id, 0, &req_hdr_msg);
    if (rc < 0) {
        goto done;
    }
    if (static_cast<size_t>(rc) < sizeof(req_hdr)) {
        rc = ERR_BAD_LEN;
        goto done;
    }
    switch (req_hdr.cmd) {
    case CMD_set_boot_done: {
        Request_set_boot_done req;
        constexpr uint32_t req_num_handles = Request_set_boot_done::num_handles;
        ::tidl::Handle req_handles[req_num_handles];
        struct iovec req_iov[] = {
                {.iov_base = &req, .iov_len = sizeof(req)},
        };
        ipc_msg_t req_msg = {.num_iov = countof(req_iov),
                             .iov = req_iov,
                             .num_handles = req_num_handles,
                             .handles = req_handles};
        rc = read_msg(chan, mi.id, sizeof(req_hdr), &req_msg);
        if (rc < 0) {
            goto done;
        }
        if (static_cast<size_t>(rc) < sizeof(req)) {
            rc = ERR_BAD_LEN;
            goto send_rc;
        }
        put_msg(chan, mi.id);
        call_put_msg = false;
        ::tidl::Handle* hptr = req_handles;
        req.recv_handles(hptr);
        assert(hptr == &req_handles[req_num_handles]);
        rc = impl->set_boot_done();
        if (rc != NO_ERROR) {
            goto send_rc;
        }
        ::tidl::ResponseHeader resp_hdr = {
                .cmd = req_hdr.cmd | RESP_BIT,
                .rc = rc,
        };
        rc = ::tidl::ipc::send(chan, &resp_hdr, sizeof(resp_hdr), nullptr, 0);
        if (rc < 0) {
            goto done;
        }
        if (static_cast<size_t>(rc) != sizeof(resp_hdr)) {
            rc = ERR_BAD_LEN;
            goto done;
        }
        break;
    }
    default:
        put_msg(chan, mi.id);
        call_put_msg = false;
        rc = ERR_CMD_UNKNOWN;
        goto send_rc;
        break;
    }
    rc = NO_ERROR;
done:
    if (call_put_msg) {
        put_msg(chan, mi.id);
    }
    bn_impl->free_payload_buffer(tidl::move(req_payload));
    bn_impl->free_payload_buffer(tidl::move(resp_payload));
    return rc;
send_rc:
    ::tidl::ResponseHeader resp_hdr = {.cmd = req_hdr.cmd | RESP_BIT, .rc = rc};
    rc = ::tidl::ipc::send(chan, &resp_hdr, sizeof(resp_hdr), nullptr, 0);
    if (rc < 0) {
        goto done;
    }
    if (static_cast<size_t>(rc) != sizeof(resp_hdr)) {
        rc = ERR_BAD_LEN;
        goto done;
    }
    goto done;
}
#endif  // #if !defined(__QL_TIPC__)