# 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
import struct
import time
import lane_isa_pb2

MAGIC_NUMBER = 0x3F8F9A1B2C3D
SEC_OFFSET = 57000  # Forensic offset derived from digit sum of SEC ID

def compile_to_lane(instructions: list, output_file: str):
    """
    Compiles an instruction sequence into an authenticated .lane binary
    containing the SEC 64-bit binary magic header and sized LanePacket frames.
    """
    with open(output_file, "wb") as f:
        # 1. Write the 64-bit Magic Number Constant
        f.write(struct.pack("<Q", MAGIC_NUMBER))

        # 2. Iterate and write each framed LanePacket
        for i, instr_data in enumerate(instructions):
            opcode = instr_data["code"]
            operands = instr_data.get("operands", [])

            packet = lane_isa_pb2.LanePacket()
            packet.packet_id = SEC_OFFSET + i
            packet.timestamp = int(time.time())

            packet.instr.code = opcode

            for op in operands:
                op_entry = packet.instr.operands.add()
                if op["type"] == "STRING":
                    op_entry.type = lane_isa_pb2.Operand.STRING
                    op_entry.s_val = op["val"]
                elif op["type"] == "FLOAT":
                    op_entry.type = lane_isa_pb2.Operand.FLOAT
                    op_entry.f_val = float(op["val"])
                elif op["type"] == "INT":
                    op_entry.type = lane_isa_pb2.Operand.INT
                    op_entry.i_val = int(op["val"])
                elif op["type"] == "REF":
                    op_entry.type = lane_isa_pb2.Operand.REF
                    op_entry.ref_val = int(op["val"])

            serialized = packet.SerializeToString()
            # Frame each packet with a 32-bit big-endian length prefix
            f.write(struct.pack("<I", len(serialized)))
            f.write(serialized)

if __name__ == "__main__":
    sample_program = [
        {
            "code": lane_isa_pb2.Instruction.MEM_WRITE,
            "operands": [
                {"type": "REF", "val": 1},
                {"type": "STRING", "val": "SOVEREIGN_NODE_ROOT"}
            ]
        },
        {
            "code": lane_isa_pb2.Instruction.COMPUTE,
            "operands": [
                {"type": "STRING", "val": "add"},
                {"type": "FLOAT", "val": 42.0}
            ]
        },
        {
            "code": lane_isa_pb2.Instruction.IO_SINK,
            "operands": [
                {"type": "STRING", "val": "EXECUTION_COMPLETE"}
            ]
        }
    ]
    compile_to_lane(sample_program, "program.lane")
    print("Compilation finished -> program.lane")