require "duktape"
 require "socket"
 
 def readFramed(socket)
     inputLen = socket.read_bytes(UInt32, IO::ByteFormat::BigEndian);
 
     input = Bytes.new(inputLen);
     socket.read(input);
 
     return(input)
 end
 
 def writeFramed(socket, message)
     socket.write_bytes(UInt32.new(message.size), IO::ByteFormat::BigEndian);
     socket.write(message);
 
     return(message.size);
 end
 
 def pushArray(ctx, data)
     arrIdx  = ctx.push_array();
     dataLen = data.size
 
     idx = UInt32.new(0);
     while idx < dataLen
         ctx.push_uint(data[idx]);
         ctx.put_prop_index(arrIdx, idx);
         idx += 1;
     end
 
     return(nil);
 end
 
 def getArray(ctx, stackIndex)
     dataLen = ctx.get_length(stackIndex);
     data    = Bytes.new(dataLen);
 
     idx = UInt32.new(0);
     while idx < dataLen
         ctx.get_prop_index(stackIndex, idx);
         data[idx] = UInt8.new(ctx.get_uint(-1));
         ctx.pop();
         idx += 1;
     end
 
     return(data);
 end
 
 def initJS()
     ctx = Duktape::Context.new();
     ctx.eval_file_noresult!("chrome-emu.js");
     ctx.eval_file_noresult!("ssh-agent-noasync.js");
 
     ctx.push_global_proc("writeFramed", 2) {|ptr|
         msgCtx = Duktape::Context.new(ptr);
         socket = Box(UNIXSocket).unbox(msgCtx.get_pointer(0));
         data   = getArray(msgCtx, 1);
 
         writeFramed(socket, data);
 
         0;
     }
 
     ctx.push_global_proc("cackeyListCertificates", 0) {|ptr|
         msgCtx = Duktape::Context.new(ptr);
         pushArray(msgCtx, Bytes.new(0));
         1;
     }
 
     ctx.eval! <<-EOF
         var goog = {DEBUG: true};
         cackeySSHAgentFeatures.enabled = true;
 
         function connection(callback) {
             this.sender = {
                 id: "pnhechapfaindjhompbnflcldabbghjo"
             };
             this.onMessage = {
                 listeners: [],
                 addListener: function(callback) {
                     this.listeners.push(callback);
                 }
             };
             this.postMessage = function(message) {
                 return(callback(this, message));
             };
             this.send = function(message) {
                 this.onMessage.listeners.forEach(function(listener) {
                     listener(message);
                 });
             };
         }
 
         function handleDataFromAgent(socket, data) {
             if (!data || !data.type || !data.data) {
                 return;
             }
 
             if (data.type != "auth-agent@openssh.com") {
                 return;
             }
 
             writeFramed(socket.handle, data.data);
         }
 
         function handleDataFromSocket(socket, data) {
             socket.send({
                 type: "auth-agent@openssh.com",
                 data: data
             });
         }
 EOF
 
     return(ctx);
 end
 
 def incomingConnection(socket)
     # Createa a JavaScript instance to deal with this socket
     ctx = initJS();
 
     # Create a socket handle on the JavaScript side that
     # corresponds to the Crystal handle
     ctx.eval!("var socket = new connection(handleDataFromAgent);");
 
     # Link the Crystal handle to the JavaScript handle
     ctx.get_global_string("socket");
     ctx.push_pointer(Box.box(socket));
     ctx.put_prop_string(-2, "handle");
 
     # Notify the agent that we have received a connection
     ctx.eval!("chrome.runtime.externalConnect(socket);");
 
     while true
         begin
             # Read a packet from the peer
             input = readFramed(socket);
 
             # Send that packet to the agent
             ctx.get_global_string("handleDataFromSocket");
             ctx.get_global_string("socket");
             pushArray(ctx, input);
             ctx.call(2);
             if ctx.is_error(-1)
                 puts("Error: #{ctx.json_encode(-1)}");
                 break
             end
 
             ctx.pop();
         rescue
             break
         end
     end
 
     socket.close();
 end
 
 listener = UNIXServer.new("./agent");
 while socket = listener.accept?
     spawn incomingConnection(socket);
 end