#include <ida/idax.hpp>

// Open a database, iterate functions, decode instructions, decompile.
// No flags. No sentinel values. No manual locking. No raw structs.

ida::database::init();
ida::database::open("firmware.i64", /*auto_analysis=*/true);
ida::analysis::wait();

for (auto fn : ida::function::all()) {
    if (ida::instruction::is_call(fn.start()))
        ida::comment::set(fn.start(), "entry is a call instruction");
}

auto main_address = ida::name::resolve("main");
if (main_address) {
    auto df = ida::decompiler::decompile(*main_address);
    if (df) {
        auto lines = df->lines();
        if (lines) {
            for (const auto& line : *lines)
                std::cout << line << "\n";
        }
    }
}

ida::database::save();
ida::database::close();

namespace ida {

template <typename T>
using Result = std::expected<T, Error>;     // value or error

using Status = std::expected<void, Error>;  // success or error

struct Error {
    ErrorCategory category;  // Validation, NotFound, Conflict, Unsupported, SdkFailure, Internal
    int           code;
    std::string   message;
    std::string   context;
};

}

// Before (raw SDK):
ea_t ea = get_name_ea(BADADDR, "main");
if (ea == BADADDR) { /* failure? doesn't exist? wrong arguments? */ }

// After (idax):
auto ea = ida::name::resolve("main");
if (!ea) {
    // ea.error().category tells you exactly what happened
    // ea.error().message tells you why
}

// Iterate every segment
for (auto seg : ida::segment::all()) {
    std::cout << seg.name() << "  "
              << std::hex << seg.start() << "-" << seg.end()
              << "  bits=" << seg.bitness()
              << "  rwx=" << seg.permissions().read
                          << seg.permissions().write
                          << seg.permissions().execute << "\n";
}

// Find a function, inspect its frame
auto fn = ida::function::at(0x401000);
if (fn) {
    auto frame = ida::function::frame(fn->start());
    if (frame)
        std::cout << "locals: " << frame->local_variables_size()
                  << " args: "  << frame->arguments_size() << "\n";
}

auto insn = ida::instruction::decode(address);
if (insn) {
    std::cout << insn->mnemonic() << " (" << insn->size() << " bytes)\n";

    for (size_t i = 0; i < insn->operand_count(); ++i) {
        auto op = insn->operand(i);
        if (op && op->is_register())
            std::cout << "  reg: " << op->register_name()
                      << " read=" << op->is_read()
                      << " written=" << op->is_written() << "\n";
    }

    // Change operand display format
    ida::instruction::set_operand_hex(address, 1);
}

if (auto avail = ida::decompiler::available(); avail && *avail) {
    auto df = ida::decompiler::decompile(function_address);
    if (df) {
        // Get pseudocode
        std::cout << *df->pseudocode() << "\n";

        // Enumerate local variables
        auto variables = df->variables();
        if (variables) {
            for (const auto& var : *variables)
                std::cout << var.index << ": " << var.name
                          << " : " << var.type_name << "\n";
        }

        // Walk the ctree.
        ida::decompiler::for_each_expression(*df,
            [](ida::decompiler::ExpressionView expr) {
                if (expr.type() == ida::decompiler::ItemType::ExprHelper) {
                    auto helper = expr.helper_name();
                    if (helper)
                        std::cout << *helper << "\n";
                }
                return ida::decompiler::VisitAction::Continue;
            });
    }

    auto refs = ida::decompiler::collect_referenced_types(function_address);
    if (refs)
        std::cout << "referenced type ordinals: "
                  << refs->ordinals.size() << "\n";
}

// Subscribe to owned mutation snapshots; callback-side unsubscribe is supported.
auto token = ida::event::on_segment_moved(
    [](const ida::event::SegmentMovedEvent& event) {
        ida::ui::message("segment moved to " + std::to_string(event.to) + "\n");
    });

ida::event::ScopedSubscription guard(*token);  // RAII: unsubscribes in destructor

auto lo = *ida::database::min_address();
auto hi = *ida::database::max_address();

// Find an ELF signature
auto hit = ida::data::find_binary_pattern(lo, hi, "7F 45 4C 46");
if (hit) {
    // Patch it
    ida::data::patch_byte(*hit, 0x00);

    // Read it back to confirm
    auto val = ida::data::read_byte(*hit);
    assert(val && *val == 0x00);
}

// Build types programmatically
auto int_t = ida::type::TypeInfo::int32();
auto ptr_t = ida::type::TypeInfo::pointer_to(int_t);
auto arr_t = ida::type::TypeInfo::array_of(int_t, 16);

// Create a struct
auto st = ida::type::TypeInfo::create_struct();
st.add_member("flags",  ida::type::TypeInfo::uint32());
st.add_member("buffer", ida::type::TypeInfo::array_of(ida::type::TypeInfo::uint8(), 256));
st.save_as("packet_header");

// Preserve exact IDA shifted-pointer metadata without exposing ptr_type_data_t.
auto packet = ida::type::TypeInfo::by_name("packet_header");
if (packet) {
    auto shifted = ida::type::TypeInfo::pointer_to(*packet)
        .with_shifted_parent(*packet, 8);
    if (shifted) {
        auto details = shifted->pointer_details(); // parent + signed byte delta
    }
}

// Replace only an exact local forward declaration, preserving its ordinal.
auto forward = ida::type::TypeInfo::by_name("packet_forward");
if (forward && forward->is_forward_declaration()
    && forward->forward_declaration_kind() == ida::type::TypeKind::Struct) {
    auto complete = ida::type::TypeInfo::create_struct();
    complete.add_member("length", ida::type::TypeInfo::uint32(), 0);
    auto replaced = complete.replace_forward_declaration("packet_forward");
}

// Keep UDT-member identities opaque while adding persistent informational
// references from exact instruction item heads.
if (packet) {
    auto added = packet->ensure_member_reference(0, instruction_address);
    auto sources = packet->member_references(0);
}

// Parse from C declaration
auto parsed = ida::type::TypeInfo::from_declaration("int (*callback)(void*, size_t)");

#include <ida/idax.hpp>

class MyPlugin final : public ida::plugin::Plugin {
public:
    Info info() const override {
        return {"My Plugin", "Ctrl-Alt-M", "Does something useful", "Help text"};
    }

    ida::Status run(size_t) override {
        ida::ui::message("Plugin executed\n");
        return ida::ok();
    }
};

#include <ida/idax.hpp>

class MyLoader final : public ida::loader::Loader {
public:
    ida::Result<std::optional<ida::loader::AcceptResult>>
    accept(ida::loader::InputFile& file) override {
        auto magic = file.read_bytes_at(0, 4);
        if (!magic || magic->size() < 4) return std::nullopt;
        if ((*magic)[0] == 0x7F && (*magic)[1] == 'E' &&
            (*magic)[2] == 'L'  && (*magic)[3] == 'F')
            return ida::loader::AcceptResult{"My ELF Loader", "metapc", 1};
        return std::nullopt;
    }

    ida::Status load(ida::loader::InputFile& file, std::string_view) override {
        auto r = ida::loader::set_processor("metapc");
        if (!r) return r;
        return ida::loader::file_to_database(file.handle(), 0, 0x400000, 0x1000, true);
    }
};

IDAX_LOADER(MyLoader)

#include <ida/idax.hpp>

class MyProcessor final : public ida::processor::Processor {
public:
    ida::processor::ProcessorInfo info() const override {
        ida::processor::ProcessorInfo pi;
        pi.id             = 0x8001;
        pi.short_names    = {"myproc"};
        pi.long_names     = {"My Custom Processor"};
        pi.default_bitness = 32;
        pi.registers      = {{"r0", false}, {"r1", false}, {"sp", false}, {"pc", false},
                             {"cs", false}, {"ds", false}};
        pi.first_segment_register = 4;
        pi.last_segment_register = 5;
        pi.code_segment_register = 4;
        pi.data_segment_register = 5;
        pi.instructions   = {{"nop", 0}, {"mov", 0}, {"add", 0}, {"jmp", 0}};
        return pi;
    }

    ida::Result<int> analyze(ida::Address address) override {
        // Decode instruction at address, return instruction length
        return 4;
    }

    ida::Result<ida::processor::AnalyzeDetails>
    analyze_with_details(ida::Address address) override {
        ida::processor::AnalyzeDetails details;
        details.instruction_code = 0;
        details.size = 4;
        return details;
    }

    ida::processor::EmulateResult emulate(ida::Address) override {
        return ida::processor::EmulateResult::Success;
    }

    void output_instruction(ida::Address) override {}

    ida::processor::OutputInstructionResult
    output_instruction_with_context(ida::Address,
                                    ida::processor::OutputContext& output) override {
        output.mnemonic("nop");
        return ida::processor::OutputInstructionResult::Success;
    }

    ida::processor::OutputOperandResult output_operand(ida::Address, int) override {
        return ida::processor::OutputOperandResult::Hidden;
    }
};

IDAX_PROCESSOR(MyProcessor)