local Proxy = module("lib/Proxy")
local Tunnel = module("lib/Tunnel")
local Lang = module("lib/Lang")
Debug = module("lib/Debug")

local config = module("cfg/base")
local version = module("version")
Debug.active = config.debug

-- versioning
print("[vRP] launch version "..version)

vRP = {}
Proxy.addInterface("vRP",vRP)

tvRP = {}
Tunnel.bindInterface("vRP",tvRP) -- listening for client tunnel

-- load language
local dict = module("cfg/lang/"..config.lang) or {}
vRP.lang = Lang.new(dict)

-- init
vRPclient = Tunnel.getInterface("vRP","vRP") -- server -> client tunnel

vRPlogs = Proxy.getInterface("vRP_logs")
vRPteleRing = Proxy.getInterface("vRP_teleportRing")
vRPsb = Proxy.getInterface("vRP_scoreboard")
vRPbiz = Proxy.getInterface("vRP_biz")
vRPjobs = Proxy.getInterface("vRP_jobs")

vRP.users = {} -- will store logged users (id) by first identifier
vRP.rusers = {} -- store the opposite of users
vRP.user_tables = {} -- user data tables (logger storage, saved to database)
vRP.user_tmp_tables = {} -- user tmp data tables (logger storage, not saved)
vRP.user_sources = {} -- user sources

hoursPlayed = {}

-- identification system

Citizen.CreateThread(function()
  local uptimeMinute, uptimeHour = 0, 0

  while true do
    Citizen.Wait(1000 * 60) -- every minute
    uptimeMinute = uptimeMinute + 1

    if uptimeMinute == 60 then
      uptimeMinute = 0
      uptimeHour = uptimeHour + 1
    end

    ExecuteCommand(string.format("sets UpTime \"%02dh %02dm\"", uptimeHour, uptimeMinute))
  end
end)

--- sql.
-- cbreturn user id or nil in case of error (if not found, will create it)
function vRP.getUserIdByIdentifiers(ids, cbr)
  local task = Task(cbr)

  if ids ~= nil and #ids then
    local i = 0

    -- search identifiers
    local function search()
      i = i+1
      if i <= #ids then
        if not config.ignore_ip_identifier or (string.find(ids[i], "ip:") == nil) then  -- ignore ip identifier
          local rows = MySQL.Sync.fetchAll("SELECT user_id FROM vrp_user_ids WHERE identifier = @identifier", {['@identifier'] = ids[i]})
          Citizen.Wait(75)
          if #rows > 0 then  -- found
            task({rows[1].user_id})
          else -- not found
            search()
          end
        else
          search()
        end
      else -- no ids found, create user
        local rows = MySQL.Sync.fetchAll("INSERT INTO vrp_users(whitelisted,banned,faction,isFactionLeader,factionRank,username) VALUES(false,false,'user',0,'none','Username'); SELECT LAST_INSERT_ID() AS id")
        Citizen.Wait(75)
        if #rows > 0 then
          local user_id = rows[1].id
          -- add identifiers
          for l,w in pairs(ids) do
            if not config.ignore_ip_identifier or (string.find(w, "ip:") == nil) then  -- ignore ip identifier
              MySQL.Async.execute("INSERT INTO vrp_user_ids(identifier,user_id) VALUES(@identifier,@user_id)", {['@user_id'] = user_id, ['@identifier'] = w}, function()end)
            end
          end

          task({user_id})
        else
          task()
        end
      end
    end

    search()
  else
    task()
  end
end

-- return identification string for the source (used for non vRP identifications, for rejected players)
function vRP.getSourceIdKey(source)
  local ids = GetPlayerIdentifiers(source)
  local idk = "idk_"
  for k,v in pairs(ids) do
    idk = idk..v
  end

  return idk
end

function vRP.getPlayerEndpoint(player)
  return GetPlayerEP(player) or "0.0.0.0"
end

function vRP.getPlayerName(player)
  return GetPlayerName(player) or "unknown"
end

function vRP.formatMoney(amount)
  local left,num,right = string.match(tostring(amount),'^([^%d]*%d)(%d*)(.-)$')
  return left..(num:reverse():gsub('(%d%d%d)','%1.'):reverse())..right
end

--- sql
function vRP.isBanned(user_id, cbr)
  local task = Task(cbr, {false})
  local rows = MySQL.Sync.fetchAll("SELECT banned FROM vrp_users WHERE id = @user_id", {['@user_id'] = user_id})
  Citizen.Wait(50)
  if #rows > 0 then
    task({rows[1].banned})
  else
    task()
  end
end

--- sql
function vRP.setBanned(user_id,banned,reason,by)
  if(banned == false)then
    reason = ""
  end
  if(tostring(by) ~= "Consola")then
    theAdmin = vRP.getUserId(by)
    adminName = GetPlayerName(by)
    banBy = adminName.." ["..theAdmin.."]"
  else
    banBy = "Consola"
  end
  MySQL.Async.execute("UPDATE vrp_users SET banned = @banned, bannedReason = @reason, bannedBy = @bannedBy WHERE id = @user_id", {['@user_id'] = user_id, ['@banned'] = banned, ['@reason'] = reason, ['@bannedBy'] = banBy}, function()end)
end

--- sql
function vRP.isWhitelisted(user_id, cbr)
  local task = Task(cbr, {false})
  local rows = MySQL.Sync.fetchAll("SELECT whitelisted FROM vrp_users WHERE id = @user_id", {['@user_id'] = user_id})
  Citizen.Wait(50)
  if #rows > 0 then
    task({rows[1].whitelisted})
  else
    task()
  end
end

--- sql
function vRP.setWhitelisted(user_id,whitelisted)
  MySQL.Async.execute("UPDATE vrp_users SET whitelisted = @whitelisted WHERE id = @user_id", {['@user_id'] = user_id, ['@whitelisted'] = whitelisted}, function()end)
end

--- sql
function vRP.getLastLogin(user_id, cbr)
  local task = Task(cbr,{""})
  local rows = MySQL.Sync.fetchAll("SELECT last_login FROM vrp_users WHERE id = @user_id", {['@user_id'] = user_id})
  if #rows > 0 then
    task({rows[1].last_login})
  else
    task()
  end
end

function vRP.setUData(user_id,key,value)
  MySQL.Async.execute("REPLACE INTO vrp_user_data(user_id,dkey,dvalue) VALUES(@user_id,@key,@value)", {['@user_id'] = user_id, ['@key'] = key, ['@value'] = value}, function()end)
end

function vRP.getUData(user_id,key,cbr)
	local task = Task(cbr,{""})

  local rows = MySQL.Sync.fetchAll("SELECT dvalue FROM vrp_user_data WHERE user_id = @user_id AND dkey = @key", {['@user_id'] = user_id, ['@key'] = key})
  Citizen.Wait(100)
	if #rows > 0 then
		task({rows[1].dvalue})
	else
		task()
	end
end

function vRP.setSData(key,value)
  MySQL.Async.execute("REPLACE INTO vrp_srv_data(dkey,dvalue) VALUES(@key,@value)", {['@key'] = key, ['@value'] = value}, function()end)
end

function vRP.getSData(key, cbr)
  local task = Task(cbr,{""})

  local rows = MySQL.Sync.fetchAll("SELECT dvalue FROM vrp_srv_data WHERE dkey = @key", {['@key'] = key})
  Citizen.Wait(100)
  if #rows > 0 then
    task({rows[1].dvalue})
  else
    task()
  end
end
-- return user data table for vRP internal persistant connected user storage
function vRP.getUserDataTable(user_id)
  return vRP.user_tables[user_id]
end

function vRP.getUserTmpTable(user_id)
  return vRP.user_tmp_tables[user_id]
end

function vRP.isConnected(user_id)
  return vRP.rusers[user_id] ~= nil
end

function vRP.isFirstSpawn(user_id)
  local tmp = vRP.getUserTmpTable(user_id)
  return tmp and tmp.spawns == 1
end

function vRP.getUserId(source)
  if source ~= nil then
    local ids = GetPlayerIdentifiers(source)
    if ids ~= nil and #ids > 0 then
      return vRP.users[ids[1]]
    end
  end

  return nil
end

-- return map of user_id -> player source
function vRP.getUsers()
  local users = {}
  for k,v in pairs(vRP.user_sources) do
    users[k] = v
  end

  return users
end

-- return source or nil
function vRP.getUserSource(user_id)
  return vRP.user_sources[user_id]
end

function vRP.ban(source,reason,admin)
  local user_id = vRP.getUserId(source)

  if user_id ~= nil then
    vRP.setBanned(user_id,1,reason,admin)
    motiv = "De: "..admin.."\nMotiv: "..reason.."\nID-ul Tau: ["..user_id.."]\n\nPentru unban intra pe Discord: https://discord.gg/hcuMnfn"
    vRP.kick(source,"[Banned] "..motiv)
  end
end

function vRP.kick(source,reason)
  DropPlayer(source,reason)
end

-- tasks

function task_save_datatables()
  TriggerEvent("vRP:save")

  Debug.pbegin("vRP save datatables")
  for k,v in pairs(vRP.user_tables) do
    vRP.setUData(k,"vRP:datatable",json.encode(v))
  end

  Debug.pend()
  SetTimeout(config.save_interval*1000, task_save_datatables)
end
task_save_datatables()

--[[local max_pings = math.ceil(config.ping_timeout*60/30)+1
function task_timeout() -- kick users not sending ping event in 2 minutes
  local users = vRP.getUsers()
  for k,v in pairs(users) do
    local tmpdata = vRP.getUserTmpTable(tonumber(k))
    if tmpdata.pings == nil then
      tmpdata.pings = 0
    end

    tmpdata.pings = tmpdata.pings+1
    if tmpdata.pings >= max_pings then
      vRP.kick(v,"[vRP] Ping timeout.")
    end
  end

  SetTimeout(30000, task_timeout)
end
task_timeout()]]

function tvRP.ping()
  local user_id = vRP.getUserId(source)
  if user_id ~= nil then
    local tmpdata = vRP.getUserTmpTable(user_id)
    tmpdata.pings = 0 -- reinit ping countdown
  end
end

function vRP.getUserHoursPlayed(user_id)
  if(hoursPlayed[user_id] ~= nil)then
    return math.floor(hoursPlayed[user_id])
  else
    return 0
  end
end

function tvRP.updateHoursPlayed(hours)
  user_id = vRP.getUserId(source)
  MySQL.Async.execute("UPDATE vrp_users SET hoursPlayed = hoursPlayed + @hours WHERE id = @user_id", {['@hours'] = hours, ['@user_id'] = user_id}, function()end)
  hoursPlayed[user_id] = hoursPlayed[user_id] + hours
  vRPsb.updateScoreboardPlayer({user_id, hours})
end

-- handlers

AddEventHandler("playerConnecting",function(name,setMessage, deferrals)
  deferrals.defer()

  local source = source
  Debug.pbegin("playerConnecting")
  local ids = GetPlayerIdentifiers(source)

  if ids ~= nil and #ids > 0 then
    deferrals.update("[KRONOS] Checking identifiers...")
    vRP.getUserIdByIdentifiers(ids, function(user_id)
      -- if user_id ~= nil and vRP.rusers[user_id] == nil then -- check user validity and if not already connected (old way, disabled until playerDropped is sure to be called)
      if user_id ~= nil then -- check user validity
        deferrals.update("[KRONOS] Checking banned...")
        vRP.isBanned(user_id, function(banned)
          local rows = MySQL.Sync.fetchAll("SELECT * FROM vrp_users WHERE id = @user_id", {['@user_id'] = user_id})
          bannedBy = rows[1].bannedBy or ""
          banReason = rows[1].bannedReason or ""

          if not banned then
            deferrals.update("[KRONOS] Checking whitelisted...")
            vRP.isWhitelisted(user_id, function(whitelisted)
              if not config.whitelist or whitelisted then
                Debug.pbegin("playerConnecting_delayed")
                if vRP.rusers[user_id] == nil then -- not present on the server, init
                  -- init entries
                  vRP.users[ids[1]] = user_id
                  vRP.rusers[user_id] = ids[1]
                  vRP.user_tables[user_id] = {}
                  vRP.user_tmp_tables[user_id] = {}
                  vRP.user_sources[user_id] = source

                  -- load user data table
                  deferrals.update("[KRONOS] Loading datatable...")
                  vRP.getUData(user_id, "vRP:datatable", function(sdata)
                    local data = json.decode(sdata)
                    if type(data) == "table" then vRP.user_tables[user_id] = data end

                    -- init user tmp table
                    local tmpdata = vRP.getUserTmpTable(user_id)

                    deferrals.update("[KRONOS] Getting last login...")
                    vRP.getLastLogin(user_id, function(last_login)
                      tmpdata.last_login = last_login or ""
                      tmpdata.spawns = 0

                      -- set last login
                      local ep = vRP.getPlayerEndpoint(source)
                      local last_login_stamp = ep.." "..os.date("%H:%M:%S %d/%m/%Y")
                      MySQL.Async.execute("UPDATE vrp_users SET last_login = @last_login WHERE id = @user_id", {['@user_id'] = user_id, ['@last_login'] = last_login_stamp}, function()end)

                      -- trigger join
                      print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") joined (user_id = "..user_id..")")
                      TriggerEvent("vRP:playerJoin", user_id, source, name, tmpdata.last_login)
                      deferrals.done()
                    end)
                  end)
                else -- already connected
                  print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") re-joined (user_id = "..user_id..")")
                  TriggerEvent("vRP:playerRejoin", user_id, source, name)
                  deferrals.done()

                  -- reset first spawn
                  local tmpdata = vRP.getUserTmpTable(user_id)
                  tmpdata.spawns = 0
                end

                Debug.pend()
              else
                print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") rejected: not whitelisted (user_id = "..user_id..")")
                deferrals.done("Nu te poti conecta pe serverul de teste...")
              end
            end)
          else
            print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") rejected: banned (user_id = "..user_id..")")
            deferrals.done("[KRONOS] Esti banat pe acest server!\nBanat De: "..bannedBy.."\nMotiv: "..banReason.."\nID-ul Tau: ["..user_id.."]\n\nPentru unban intra pe Discord: https://discord.gg/hcuMnfn")
          end
        end)
      else
        print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") rejected: identification error")
        deferrals.done("[KRONOS] Identification error.")
      end
    end)
  else
    print("[KRONOS] "..name.." ("..vRP.getPlayerEndpoint(source)..") rejected: missing identifiers")
    deferrals.done("[KRONOS] Missing identifiers.")
  end
  Debug.pend()
end)

AddEventHandler("playerDropped",function(reason)
  local source = source
  Debug.pbegin("playerDropped")

  -- remove player from connected clients
  vRPclient.removePlayer(-1,{source})


  local user_id = vRP.getUserId(source)

  if user_id ~= nil then
    TriggerEvent("vRP:playerLeave", user_id, source)

    -- save user data table
    vRP.setUData(user_id,"vRP:datatable",json.encode(vRP.getUserDataTable(user_id)))

    print("[vRP] "..vRP.getPlayerEndpoint(source).." disconnected (user_id = "..user_id..")")
    vRP.users[vRP.rusers[user_id]] = nil
    vRP.rusers[user_id] = nil
    vRP.user_tables[user_id] = nil
    vRP.user_tmp_tables[user_id] = nil
    vRP.user_sources[user_id] = nil
  end
  Debug.pend()
end)

RegisterServerEvent("vRPcli:playerSpawned")
AddEventHandler("vRPcli:playerSpawned", function()
  Debug.pbegin("playerSpawned")
  -- register user sources and then set first spawn to false
  local user_id = vRP.getUserId(source)
  local player = source
  if user_id ~= nil then
    vRP.user_sources[user_id] = source
    local tmp = vRP.getUserTmpTable(user_id)
    tmp.spawns = tmp.spawns+1
    local first_spawn = (tmp.spawns == 1)

    if first_spawn then
      -- first spawn, reference player
      -- send players to new player
      for k,v in pairs(vRP.user_sources) do
        vRPclient.addPlayer(source,{v})
      end
      -- send new player to all players
      vRPclient.addPlayer(-1,{source})
      local theHours = MySQL.Sync.fetchAll("SELECT hoursPlayed FROM vrp_users WHERE id = @user_id", {['@user_id'] = user_id})
      hoursPlayed[user_id] = tonumber(theHours[1].hoursPlayed)
    end

    -- set client tunnel delay at first spawn
    Tunnel.setDestDelay(player, config.load_delay)

    -- show loading
    vRPclient.setProgressBar(player,{"vRP:loading", "botright", "Loading...", 0,0,0, 100})
    MySQL.Async.execute("UPDATE vrp_users SET username = @username WHERE id = @user_id", {['@user_id'] = user_id, ['@username'] = GetPlayerName(player)}, function()end)
    SetTimeout(2000, function() -- trigger spawn event
    TriggerEvent("vRP:playerSpawn",user_id,player,first_spawn)
      SetTimeout(config.load_duration*1000, function() -- set client delay to normal delay
        Tunnel.setDestDelay(player, config.global_delay)
        vRPclient.removeProgressBar(player,{"vRP:loading"})
      end)
    end)
  end

  Debug.pend()
end)

RegisterServerEvent("vRP:playerDied")