// Copyright © Albert Lane. All Rights Reserved.
// Proprietary and Confidential — Albert Lane Proprietary Software License.
// Unauthorized use, copying, modification, or distribution is prohibited.
// License inquiries: https://albertlane.net
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <string>
#include <cstdint>
#include <pybind11/embed.h>
#include "lane_isa.pb.h"

namespace py = pybind11;

class LaneHost {
private:
    // Forensic Constants derived from SEC Whistleblower ID 17684-273-411-436
    const uint64_t MAGIC_NUMBER = 0x3F8F9A1B2C3D;
    const size_t MEMORY_STRIDE = 17684;
    std::map<uint64_t, std::string> vmm_state;
    py::scoped_interpreter guard{};

public:
    bool verify_binary_header(std::ifstream& file) {
        uint64_t header = 0;
        file.read(reinterpret_cast<char*>(&header), sizeof(uint64_t));
        if (header != MAGIC_NUMBER) {
            std::cerr << "CRITICAL: Invalid Binary Header. Header mismatch. Execution terminated." << std::endl;
            return false;
        }
        return true;
    }

    void execute_packet(const lane_vm::LanePacket& packet) {
        std::cout << "Executing Packet ID: " << packet.packet_id() << std::endl;

        switch (packet.instr().code()) {
            case lane_vm::Instruction::MEM_WRITE: {
                if (packet.instr().operands_size() >= 2) {
                    uint64_t raw_ref = packet.instr().operands(0).ref_val();
                    uint64_t aligned_addr = raw_ref * MEMORY_STRIDE;
                    std::string val = packet.instr().operands(1).s_val();
                    vmm_state[aligned_addr] = val;
                    std::cout << "[VMM] MEM_WRITE at 0x" << std::hex << aligned_addr 
                              << std::dec << " (" << val << ")" << std::endl;
                }
                break;
            }
            case lane_vm::Instruction::COMPUTE: {
                if (packet.instr().operands_size() >= 2) {
                    py::module_ guest = py::module_::import("guest_lib");
                    py::function func = guest.attr("compute_math");
                    std::string op = packet.instr().operands(0).s_val();
                    
                    py::list args;
                    args.append(packet.instr().operands(1).f_val());

                    auto result = func(op, args);
                    std::cout << "[GUEST] Compute Result (" << op << "): " 
                              << result.cast<double>() << std::endl;
                }
                break;
            }
            case lane_vm::Instruction::SYS_CALL: {
                std::cout << "[SENTRY] Intercepting SYS_CALL. Validating permission parameters..." << std::endl;
                // Strict permission gating here
                break;
            }
            case lane_vm::Instruction::IO_SINK: {
                if (packet.instr().operands_size() >= 1) {
                    std::cout << "[IO_SINK]: " << packet.instr().operands(0).s_val() << std::endl;
                }
                break;
            }
            default:
                break;
        }
    }

    void run(const std::string& filename) {
        std::ifstream file(filename, std::ios::binary);
        if (!file.is_open()) {
            std::cerr << "Failed to open input file: " << filename << std::endl;
            return;
        }

        if (!verify_binary_header(file)) {
            return;
        }

        uint32_t packet_size = 0;
        while (file.read(reinterpret_cast<char*>(&packet_size), sizeof(uint32_t))) {
            std::vector<char> buffer(packet_size);
            if (!file.read(buffer.data(), packet_size)) {
                break;
            }
            lane_vm::LanePacket packet;
            if (packet.ParseFromArray(buffer.data(), static_cast<int>(packet_size))) {
                execute_packet(packet);
            } else {
                std::cerr << "Error parsing LanePacket stream." << std::endl;
                break;
            }
        }
    }
};

int main(int argc, char** argv) {
    std::string program = "program.lane";
    if (argc > 1) {
        program = argv[1];
    }
    LaneHost host;
    host.run(program);
    return 0;
}