--[[
  Casino Central Server
  Copyright 2026 Herr Katze and minecartchris
  License: MIT
]]

-- permission function takes uuid as argument

local loop = require("taskmaster")()
local sha256 = require("sha256")

local nfc = peripheral.find("nfc_reader")
local modem = peripheral.find("modem", function(n,w) return not w.isWireless() end)

rednet.open(peripheral.getName(modem))
local permissions = {}

function permissions.all()
  return true
end

function permissions.admin(player)
  --TODO: check player uuid against configurable admins, currently hardcoded to be Herr Katze
  if player == "1f558cbb-0752-49c0-ace4-7f9ed0506fe3" then return true end
  if player == "1de578d0-4eae-48db-abc9-7bf3354f809b" then return true end
  return false
end

local accounts = {}
--[[
  Account format:
  {
    username = "HerrKatzeGaming",
    uuid = "1f558cbb-0752-49c0-ace4-7f9ed0506fe3",
    balance = 69420,
    validCard = nil, -- either nil for no card, or a random uuid,
    banned = false
  }
]]

local function saveAccounts()
  local data = textutils.serialize(accounts)
  local f = fs.open("accounts.slt","w")
  f.write(data)
  f.close()
end
if not fs.exists("accounts.slt") then
  saveAccounts()
end

do
  local f = fs.open("accounts.slt","r")
  data = f.readAll()
  f.close()
  accounts = textutils.unserialize(data)
end

local function createAccount(username,uuid,balance)
balance = balance or 0
accounts[uuid] = {
  username = username,
  uuid = uuid,
  balance = balance
}
saveAccounts()
end

local function registerCard(uuid)
  local r = http.get("https://www.uuidgenerator.net/api/version4")
  local cardId = r.readAll()
  r.close()
  rednet.broadcast(cardId,"nfc_atm_write")
  local id, message = rednet.receive("casinoATMC2S", 61) -- 61 seconds so that the timeout should be handled properly
  if not id then
    chatbox.tell(uuid, "<red>Did not receive response from ATM, Please ping a casino maintainer</red>", "Chris's Casino", "minimessage")
    return
  end
  if message.type == "card_timeout" then
    chatbox.tell(uuid, "<red>Card creation timed out. Re run the command to register your card.</red>", "Chris's Casino", "minimessage")
    return
  end
  if message.type == "card_created" then
    accounts[uuid].validCard = cardId
    chatbox.tell(uuid, "<green>Card registered.", "Chris's Casino", "minimessage")
    saveAccounts()
    return
  end
  print("[ERROR] Received Invalid message type",message.type)
end

local function revokeCard(uuid)
  if not accounts[uuid] then
    chatbox.tell(uuid,"<red>Cannot revoke card for non-existant account</red>", "Chris's Casino", "minimessage")
    return
  end
  if not accounts[uuid].validCard then
    chatbox.tell(uuid,"<red>Card not created or already revoked.</red>", "Chris's Casino", "minimessage")
    return
  end
  accounts[uuid].validCard = nil
  saveAccounts()
  chatbox.tell(uuid, "<green>Card revoked. use <blue>\\casino register</blue> to obtain a new one. Your balance will transfer to the new card.", "Chris's Casino", "minimessage")
end

local function deleteAccount(uuid)
  accounts[uuid] = nil
end

local kromerNode = "https://kromer.reconnected.cc/api/krist"
local pkey = ""

local commands = {}
local function makeaddressbyte(byte)
    local byte = 48 + math.floor(byte/7)
    return string.char(byte + 39 > 122 and 101 or byte > 57 and byte + 39 or byte)
end
local function make_address(key)
  local protein = {}
  local stick = sha256(sha256(key))
  local n = 0
  local link = 0
  local v2 = "k"
  repeat
      if n<9 then protein[n] = string.sub(stick,0,2)
      stick = sha256(sha256(stick)) end
      n = n+1
  until n==9
  n=0
  repeat
      link = tonumber(string.sub(stick,1+(2*n),2+(2*n)),16) % 9
      if string.len(protein[link]) ~= 0 then
          v2 = v2 .. makeaddressbyte(tonumber(protein[link],16))
          protein[link] = ''
          n=n+1
      else
      stick = sha256(stick)
      end
  until n==9
  return v2
end

local function split(inputstr, sep)
  sep = sep or ","
  local t={}
  for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
    table.insert(t, str)
  end
  return t
end
local address = make_address(pkey)
print(address)
local function handleWebSockets()
    local id = -1
    local r,f = http.post(kromerNode.."/ws/start","{\"privatekey\":\""..pkey.."\"}",{["content-type"]="application/json"})
    local resp = textutils.unserialiseJSON(r.readAll())
    r.close()
    r = nil
    if  resp.ok then
        socket = http.websocket(resp.url)
        print("Connected to Krist Websockets")
        id = id + 1
        socket.send('{\"id\":'..id ..',\"type\":\"subscribe\",\"event\":\"ownTransactions\"}')
        while true do
            event = {os.pullEvent()}
            if event[1] == "websocket_message" then
                if event[2] == resp.url then
                    wsevent = textutils.unserialiseJSON(event[3])
                    if wsevent.event == "transaction" and wsevent.transaction.to == address then
                        local from = wsevent.transaction.from
                        local hasMessage = false
                        local hasError = false
                        local hasUUID = false
                        local otherUUID = nil
                        err = ""
                        if wsevent.transaction.metadata then
                            mta = split(wsevent.transaction.metadata,";")
                            for i,p in pairs(mta) do
                                if p:match("useruuid") and not hasUUID then
                                    otherUUID = split(p,"=")[2]
                                    hasUUID = true
                                end
                            end
                        end
                        print(otherUUID)
                        if not otherUUID then
                          os.queueEvent("make_transaction",wsevent.transaction.from,wsevent.transaction.value)
                        else
                          if not accounts[otherUUID] then
                            chatbox.tell(otherUUID,"<red>Player doesn't have an account.", "Chris's Casino", "minimessage")
                            os.queueEvent("make_transaction",wsevent.transaction.from,wsevent.transaction.value)
                          else
                          accounts[otherUUID].balance = accounts[otherUUID].balance + wsevent.transaction.value
                          chatbox.tell(otherUUID,"<green>Added <blue>"..wsevent.transaction.value.."</blue> to your balance", "Chris's Casino", "minimessage")
                          saveAccounts()
                          end
                        end

                    elseif wsevent.type == "keepalive" or wsevent.type == "response" then
                    else
                    end
                end


            elseif event[1] == "make_transaction" then
                id = id + 1
                local rq = {
                    id = id,
                    type="make_transaction",
                    to = event[2],
                    amount = event[3],
                    metadata = event[4],
                }
                socket.send(textutils.serialiseJSON(rq))
                local c
                repeat
                c = socket.receive()
                c = textutils.unserialiseJSON(c)
                until c.type == "response"
                os.queueEvent("transaction_complete",c.ok)
            end
        end
    end
end
commands.balance = {
  exec= function(name, uuid, args)
    if accounts[uuid] and accounts[uuid].banned then
      chatbox.tell(uuid,"<red>You have been banned from Chris's Casino, Please contact a casino maintainer for a balance refund.", "Chris's Casino", "minimessage")
      return
    end
    if #args == 0 or not permissions.admin(uuid) then
      if not accounts[uuid] then
        chatbox.tell(name,"<red>You don't have an account, use <blue>\\casino register</blue> to get one", "Chris's Casino", "minimessage")
        return
      end
      chatbox.tell(name,"<green>Your balance is <blue>"..accounts[uuid].balance.."</blue>", "Chris's Casino", "minimessage")
    else
      local otherUUID = args[1]
        if not accounts[otherUUID] then
        chatbox.tell(name,"<red>Player doesn't have an account.", "Chris's Casino", "minimessage")
        return
      end
      chatbox.tell(name,"<green>"..accounts[otherUUID].username.."'s balance is <blue>"..accounts[otherUUID].balance.."</blue>", "Chris's Casino", "minimessage")
    end
  end,
  permission = permissions.all
}
commands.withdraw = {
  exec = function(name,uuid,args)
    if accounts[uuid] and accounts[uuid].banned then
      chatbox.tell(uuid,"<red>You have been banned from Chris's Casino, Please contact a casino maintainer for a balance refund.", "Chris's Casino", "minimessage")
      return
    end
    if not accounts[uuid] then
      chatbox.tell(name,"<red>You don't have an account, use <blue>\\casino register</blue> to get one", "Chris's Casino", "minimessage")
      return
    end
    if args[1] then
      local response = http.get(("https://kromer.reconnected.cc/api/v1/wallet/by-name/%s"):format(name))
      response = textutils.unserializeJSON(response.readAll())
      local address = response.data[1].address
      local amount = math.min(tonumber(args[1]),accounts[uuid].balance)
      print(amount)
      if amount == 0 then
        chatbox.tell(name,"<red>You have no money.</red>","Chris's Casino","minimessage")
      else
        accounts[uuid].balance = accounts[uuid].balance - amount
        saveAccounts()
        os.queueEvent("make_transaction",address,amount)
        chatbox.tell(name,"<red>Withdrew <blue>"..amount.."kro </blue> from your balance. You have <blue>"..accounts[uuid].balance.."</blue> remaining.", "Chris's Casino", "minimessage")
      end
    end
  end,
  permission = permissions.all
}
commands.bal = commands.balance -- alias for \casino bal

commands.register = {
  exec = function(name, uuid, args)
    if accounts[uuid] and accounts[uuid].banned then
      chatbox.tell(uuid,"<red>You have been banned from Chris's Casino, Please contact a casino maintainer for a balance refund.", "Chris's Casino", "minimessage")
      return
    end
    if accounts[uuid] and accounts[uuid].validCard then
      chatbox.tell(name,"<green>You already have a registered card, use <blue>\\casino revoke</blue> to revoke it, then create a new one with <blue>\\casino register</blue>","Chris's Casino", "minimessage")
      return
    end
    if not accounts[uuid] then createAccount(name,uuid) end
    chatbox.tell(name,"<green>Creating card, tap on the NFC reader to register it. This card request will expire in 60s if not registered.", "Chris's Casino", "minimessage")
    registerCard(uuid)
  end,
  permission = permissions.all
}

commands.revoke = {
  exec = function(name, uuid, args)
    if accounts[uuid] and accounts[uuid].banned then
      chatbox.tell(uuid,"<red>You have been banned from Chris's Casino, Please contact a casino maintainer for a balance refund.", "Chris's Casino", "minimessage")
      return
    end
    revokeCard(uuid)
  end,
  permission = permissions.all
}

commands.ban = {
  exec = function(name, uuid, args)
    local account = args[1]
    if not accounts[account] then
      createAccount("$unknown",uuid)
    end
    if accounts[account].banned then
      chatbox.tell(name,"<red>User is already banned.", "Chris's Casino", "minimessage")
      return
    end
    accounts[account].banned = true
    chatbox.tell(name,"<green>Banned user with uuid "..account, "Chris's Casino", "minimessage")
  end,
  permission = permissions.admin
}

commands.pardon = {
  exec = function(name, uuid, args)
    local account = args[1]
    if not accounts[account] or not accounts[account].banned then
      chatbox.tell(name,"<red>User is not banned.", "Chris's Casino", "minimessage")
      return
    end
    accounts[account].banned = false
    if accounts[account].name == "$unknown" then deleteAccount(account) end -- Delete anonymous banned users.
    chatbox.tell(name,"<green>Pardoned user with uuid "..account, "Chris's Casino", "minimessage")
  end,
  permission = permissions.admin
}

commands.add = {
  exec = function(name, uuid, args)
    if not args[2] then
      chatbox.tell(name,"<red>Both a player UUID and a number must be provided", "Chris's Casino", "minimessage")
      return
    end
    local otherUUID = args[1]
    if not accounts[otherUUID] then
      chatbox.tell(name,"<red>Player doesn't have an account.", "Chris's Casino", "minimessage")
      return
    end
    accounts[otherUUID].balance = accounts[otherUUID].balance + tonumber(args[2])
    chatbox.tell(name,"<green>Added <blue>"..args[2].."</blue> To "..accounts[otherUUID].username.."'s balance", "Chris's Casino", "minimessage")
    saveAccounts()
  end,
  permission = permissions.admin
}

commands.subtract = {
  exec = function(name, uuid, args)
    local otherUUID = args[1]
    if not args[2] then
      chatbox.tell(name,"<red>Both a player UUID and a number must be provided", "Chris's Casino", "minimessage")
      return
    end
    if not accounts[otherUUID] then
      chatbox.tell(name,"<red>Player doesn't have an account.", "Chris's Casino", "minimessage")
      return
    end
    accounts[otherUUID].balance = accounts[otherUUID].balance - tonumber(args[2])
    chatbox.tell(name,"<green>Subtracted <blue>"..args[2].."</blue> From "..accounts[otherUUID].username.."'s balance", "Chris's Casino", "minimessage")
    saveAccounts()
  end,
  permission = permissions.admin
}

commands.setbal = {
  exec = function(name, uuid, args)
    local otherUUID = args[1]
    if not args[2] then
      chatbox.tell(name,"<red>Both a player UUID and a number must be provided", "Chris's Casino", "minimessage")
      return
    end
    if not accounts[otherUUID] then
      chatbox.tell(name,"<red>Player doesn't have an account.", "Chris's Casino", "minimessage")
      return
    end
    accounts[otherUUID].balance = tonumber(args[2])
    chatbox.tell(name,"<green>Set"..accounts[otherUUID].username.."'s balance to <blue>"..args[2].."</blue>", "Chris's Casino", "minimessage")
    saveAccounts()
  end,
  permission = permissions.admin
}

local function commandHandler()
  while true do
    _, user, command, args, data = os.pullEvent("command")
    if command ~= "casino" then goto notOurCommand end
    local subcommand = table.remove(args,1)
    if not commands[subcommand] then
      chatbox.tell(user,"<red>Invalid subcommand.</red>", "Chris's Casino", "minimessage")
      goto continue
    end
    do
    local uuid = data.user.uuid
    if not commands[subcommand].permission(uuid) then
      chatbox.tell(user,"<red>You do not have permission to run this command", "Chris's Casino", "minimessage")
      goto continue
    end
    loop:addFunction(commands[subcommand].exec,user,uuid,args)
    end
    ::continue::
    if accounts[data.user.uuid] and accounts[data.user.uuid].username ~= user then
      accounts[data.user.uuid].username = user
      chatbox.tell(user,"<green> Your username has been updated in the account database.", "Chris's Casino", "minimessage")
      saveAccounts()
    end
    ::notOurCommand:: -- separate label so we don't respond to other people's commands with a username change.
  end
end


local function rednetMessageHandler()
  while true do
    local id, message, protocol = rednet.receive()
    if protocol == "machineBalanceModifier" then
      if type(message) ~= "table" or not message.uuid or not message.amount then goto continue_rednet end -- Guard against bullshit messages
      if message.type == "add" then
        accounts[message.uuid].balance = accounts[message.uuid].balance + message.amount
      end
      if message.type == "subtract" then
        accounts[message.uuid].balance = accounts[message.uuid].balance + message.amount
      end
      if message.type == "set" then
        accounts[message.uuid].balance = message.amount
      end

    elseif protocol == "getAccountData" then
      if type(message) ~= "table" or not message.card then goto continue_rednet end
      for _, account in pairs(accounts) do
        if "casinoAccount_"..account.validCard == message.card then -- Here's our guy!
          rednet.send(id,{
            type = "account_data",
            uuid = account.uuid,
            username = account.username,
            balance = account.balance,
            cardId = message.card
        },"server_response")
          break
        end
      end
    end
    ::continue_rednet::
  end
end


loop:task(commandHandler)
:task(rednetMessageHandler)
:task(handleWebSockets)
  :run()