ie = minetest.request_insecure_environment()
if not ie then
    minetest.log("warn", "Chatbridge failed to access the insecure enviroment. It will be disabled.")
    error("!!")
    return
end

local oldrequire = require
require = ie.require

local socket = ie.require("socket")
local mime = ie.require("mime")

local bxor = bit.bxor
local band = bit.band
local rshift = bit.rshift
local lshift = bit.lshift


-- Helper function to generate a random WebSocket key (16 bytes, base64-encoded)
local function generate_websocket_key()
    local bytes = {}
    for i = 1, 16 do
        bytes[i] = string.char(math.random(0, 255))
    end
    return mime.b64(table.concat(bytes))
end

-- Helper function to create a masked WebSocket frame for a text message
local function create_websocket_frame(message, opcode)
    local payload = message or ""
    local payload_len = #payload
    local frame = {}

    -- FIN bit (1) and opcode (0x1 for text, 0xA for pong)
    frame[1] = string.char(0x80 + (opcode or 0x1)) -- FIN=1, specified opcode

    -- Mask bit (1) and payload length
    if payload_len <= 125 then
        frame[2] = string.char(0x80 + payload_len) -- Mask=1, length <= 125
    elseif payload_len <= 65535 then
        frame[2] = string.char(0x80 + 126) -- Mask=1, length=126 (extended)
        frame[3] = string.char(math.floor(payload_len / 256)) -- High byte
        frame[4] = string.char(payload_len % 256) -- Low byte
    else
        error("Payload too large for this example")
    end

    -- Generate 4-byte masking key
    local mask_key = {}
    for i = 1, 4 do
        mask_key[i] = math.random(0, 255)
        frame[#frame + 1] = string.char(mask_key[i])
    end

    -- Mask the payload
    for i = 1, payload_len do
        local byte = string.byte(payload, i)
        local masked_byte = bxor(byte, mask_key[(i - 1) % 4 + 1])
        frame[#frame + 1] = string.char(masked_byte)
    end

    return table.concat(frame)
end

-- Helper function to parse a WebSocket frame header
local function parse_websocket_header(data)
    if #data < 2 then return nil, nil, nil, data end -- Not enough data

    local first_byte = string.byte(data, 1)
    local second_byte = string.byte(data, 2)
    local fin = rshift(first_byte, 7) == 1
    local opcode = band(first_byte, 0x0F)
    local masked = rshift(second_byte, 7) == 1
    local payload_len = band(second_byte, 0x7F)
    local offset = 2

    if payload_len == 126 then
        if #data < 4 then return nil, nil, nil, data end
        payload_len = lshift(string.byte(data, 3), 8) + string.byte(data, 4)
        offset = 4
    elseif payload_len == 127 then
        return nil, nil, nil, "64-bit length not supported"
    end

    if masked then
        if #data < offset + 4 then return nil, nil, nil, data end
        offset = offset + 4
    end

    return opcode, payload_len, offset, data
end

-- Helper function to print raw data in hex for debugging
local function print_hex(data)
    if data then
        local hex = data:gsub(".", function(c) return string.format("%02X ", string.byte(c)) end)
        print("Raw data (hex): " .. hex)
    else
        print("No data received")
    end
end

-- Helper function to check for available messages using socket.select
local function check_for_message(client, timeout)
    local readable, _, err = socket.select({client}, nil, timeout or 0)
    if err then
        return false, err
    end
    return #readable > 0, nil
end

-- WebSocket client class
local WebSocketClient = {
    onmessage = function() end
}
WebSocketClient.__index = WebSocketClient

function WebSocketClient:new(host, port)
    local client = socket.connect(host, port)
    if not client then
        return nil, "Connection failed"
    end
    client:settimeout(0.1) -- Short timeout for non-blocking reads

    local self = {
        client = client,
        buffer = "",
        closed = false
    }
    setmetatable(self, WebSocketClient)
    return self
end

function WebSocketClient:connect()
    local client = self.client
    local ws_key = generate_websocket_key()
    local handshake = table.concat({
        "GET / HTTP/1.1",
        "Host: localhost:8001",
        "Upgrade: websocket",
        "Connection: Upgrade",
        "Sec-WebSocket-Key: " .. ws_key,
        "Sec-WebSocket-Version: 13",
        "", ""
    }, "\r\n")

    local _, err = client:send(handshake)
    if err then
        client:close()
        self.closed = true
        return false, "Handshake send failed: " .. err
    end

    local response = ""
    while true do
        local line, err = client:receive("*l")
        if not line or err then
            client:close()
            self.closed = true
            return false, "Handshake failed: " .. (err or "empty line")
        end
        response = response .. line .. "\r\n"
        if line == "" then break end
    end

    if not response:match("HTTP/1.1 101 Switching Protocols") then
        client:close()
        self.closed = true
        return false, "Invalid handshake response"
    end

    print("WebSocket handshake successful")
    return true
end

function WebSocketClient:send_message(message)
    if type(message) == "table" then
        message = minetest.write_json(message)
    end
    if self.closed then
        return false, "Connection closed"
    end

    local frame = create_websocket_frame(message)
    local _, err = self.client:send(frame)
    if err then
        self.client:close()
        self.closed = true
        return false, "Send failed: " .. err
    end
    print("Sent frame: " .. message)
    return true
end

function WebSocketClient:send_pong(payload)
    if self.closed then
        return false, "Connection closed"
    end

    local frame = create_websocket_frame(payload, 0xA) -- Opcode 0xA for pong
    local _, err = self.client:send(frame)
    if err then
        self.client:close()
        self.closed = true
        return false, "Send pong failed: " .. err
    end
    print("Sent pong")
    return true
end

function WebSocketClient:receive_message()
    if self.closed then
        return nil, "Connection closed"
    end

    local client = self.client
    local buffer = self.buffer
    local opcode, payload_len, offset, err

    -- Step 1: Read header
    while true do
        opcode, payload_len, offset, buffer = parse_websocket_header(buffer)
        if opcode then break end
        if err then
            self.client:close()
            self.closed = true
            return nil, err
        end

        local data, err = client:receive(1)
        if data then
            buffer = buffer .. data
            print_hex(data)
        elseif err == "timeout" then
            self.buffer = buffer
            return nil, nil -- Not enough data, try again later
        elseif err == "closed" then
            self.client:close()
            self.closed = true
            return nil, "Connection closed by server"
        else
            self.client:close()
            self.closed = true
            return nil, "Receive error: " .. err
        end
    end

    -- Step 2: Read payload
    while #buffer < offset + payload_len do
        local remaining = offset + payload_len - #buffer
        local data, err = client:receive(remaining)
        if data then
            buffer = buffer .. data
            print_hex(data)
        elseif err == "timeout" then
            self.buffer = buffer
            return nil, nil -- Not enough data, try again later
        elseif err == "closed" then
            self.client:close()
            self.closed = true
            return nil, "Connection closed by server"
        else
            self.client:close()
            self.closed = true
            return nil, "Receive error: " .. err
        end
    end

    -- Extract payload
    local payload = buffer:sub(offset + 1, offset + payload_len)
    self.buffer = buffer:sub(offset + payload_len + 1)
    
    -- Handle frame types
    if opcode == 0x1 then
        print("Received: " .. payload)
        return payload, opcode
    elseif opcode == 0x9 then
        print("Received ping")
        self:send_pong(payload) -- Respond with pong
        return nil, opcode -- Ping frames are not returned as messages
    elseif opcode == 0x8 then
        print("Received close frame")
        self:close()
        return nil, opcode
    else
        print("Unexpected opcode: " .. opcode)
        return nil, opcode
    end
    
    return payload, opcode
end

function WebSocketClient:close()
    if not self.closed then
        local close_frame = string.char(0x88, 0x02, 0x03, 0xE8) -- FIN=1, opcode=0x8, length=2, status=1000
        self.client:send(close_frame)
        self.client:close()
        self.closed = true
    end
end

-- Main client loop for sending and receiving messages
local client, err = WebSocketClient:new("localhost", 8001)
if not client then
    print("Failed to create client: " .. err)
    return
end

if not client:connect() then
    return
end

client.onmessage = function(e, data)
    data = minetest.parse_json(data)
    minetest.chat_send_all(minetest.colorize("#888", "<"..data.name.."> "..data.msg))
end

client:send_message({type = "online"})

minetest.register_on_chat_message(function(name, msg)
    client:send_message({type = "chat", sender = name, msg = msg})
end)

minetest.register_globalstep(function()
    local has_data, err = check_for_message(client.client)
    if has_data then
        local payload, opcode = client:receive_message()
        if payload then
            if opcode == 0x1 then
                print("Received: " .. payload)
                client:onmessage(payload)
            elseif opcode == 0x8 then
                print("Received close frame")
                client:close()
                return
            else
                print("Unexpected opcode: " .. opcode)
            end
        elseif err then
            print("Receive error: " .. err)
            return
        end
    elseif err then
--        print("Select error: " .. err)
--        client:close()
--        return
    end
end)

minetest.register_on_shutdown(function()
    client:close()
end)

require = oldrequire

--local ws, err = socket.connect("localhost", 8001)
--
--if not ws then
--    minetest.log("Failed to open connection: "..err)
--    return
--end



--local ws_key = "dGhlIHNhbXBsZSBub25jZQ=="
--
---- Send HTTP upgrade request
--local handshake = table.concat({
--    "GET / HTTP/1.1",
--    "Host: localhost:8001",
--    "Upgrade: websocket",
--    "Connection: Upgrade",
--    "Sec-WebSocket-Key: " .. ws_key,
--    "Sec-WebSocket-Version: 13",
--    "", ""
--}, "\r\n")
--ws:send(handshake)
--
---- Receive and validate server response
--local response, err = ws:receive("*l")
--if not response or response ~= "HTTP/1.1 101 Switching Protocols" then
--    print("Handshake failed: " .. (err or response))
--    return
--end
--
---- Read headers to confirm Sec-WebSocket-Accept
--while true do
--    local line, err = ws:receive("*l")
--    if not line or err then
--        print("Error reading headers: " .. (err or "empty line"))
--        break
--    end
--    if line == "" then break end -- End of headers
--    print(line)
--end
--
---- Send a simple text frame (incomplete, needs proper framing and masking)
--ws:send("\x81\x04Test") -- Opcode 0x1 (text), length 4, payload "Test"