import struct
import logging

from .. import glob
from ..helpers import dataHelper

logger = logging.getLogger(__name__)
logger.propagate = False # Disable console logging

def handle(client, data):
	ping_ip = ".".join((str(x) for x in struct.unpack(b"<4B", data[4:8])))
	ping_port = struct.unpack(b"<H", data[9:11])[0]

	logger.debug("[%s] -> Pinging to %s:%d" % (client.addr, ping_ip, ping_port))

	if len(data) == 11: # We should add our data ontop
		if data[-1:] in RESPONSE:
			data += RESPONSE[data[-1:]]()

	logger.debug("[%s] <- %s" % (client.addr, data))

	return data

def query_i():
	len_hostname = len(glob.config["server"]["hostname"])
	len_mode = len(glob.config["server"]["mode"])
	len_language = len(glob.config["server"]["language"])

	packet = struct.pack(b"<?HHI%dsI%dsI%ds" % (len_hostname, len_mode, len_language),
		False,
		len(get_online_players()),
		glob.config["server"]["max_players"],
		len_hostname,
		glob.config["server"]["hostname"].encode(),
		len_mode,
		glob.config["server"]["mode"].encode(),
		len_language,
		glob.config["server"]["language"].encode())

	return packet

def query_r():
	packet_data = []

	rules = get_rules()
	packet_data.append(len(rules)) # len_rules

	for name, value in rules.items():
		packet_data.append([
			len(name), name,
			len(value), value
		])

	flat_packet_data = dataHelper.flatten(packet_data)

	packet = struct.pack(b"<H" + b"B%dsB%ds" * flat_packet_data[0] # using len_rules
			% tuple(len(y) for x in rules.items() for y in x), # tuple of only rules entries
		*flat_packet_data)

	return packet

def query_c():
	packet_data = []

	players_scores = get_players_scores()
	packet_data.append(len(players_scores))

	for name, value in players_scores.items():
		packet_data.append([
			len(name), name,
			value
		])

	flat_packet_data = dataHelper.flatten(packet_data)

	packet = struct.pack(b"<H" + b"B%dsI" * flat_packet_data[0]
			% tuple(len(x) for x in players_scores.keys()),
		*flat_packet_data)

	return packet

def query_d():
	packet_data = []

	players = get_online_players()
	packet_data.append(len(players))

	for player in players:
		packet_data.append([
			player["id"],
			len(player["nick"]), player["nick"],
			player["score"],
			player["ping"]
		])

	flat_packet_data = dataHelper.flatten(packet_data)

	packet = struct.pack(b"<H" + b"cc%dsII" * flat_packet_data[0]
			% [len(player["nick"]) for player in players],
		*flat_packet_data)

	return packet

def get_online_players(): #TODO: Get data from server's client objects
	return [
		{"nick": b"Sunpy", "score": 64, "ping": 8, "id": 1} # replace id with function to get player's id
	]

def get_rules(): #TODO
	return {b"Rule name sample": b"Rule value", b"weburl": b"https://git.osufx.com/Sunpy/sampy"}

def get_players_scores(): #TODO
	return {b"Sunpy": 64, b"username": 123}

RESPONSE = { #TODO?: p (https://wiki.sa-mp.com/wiki/Query_Mechanism) (We dont really need to do the last handler as it happens somewhat automatically)
	b"i": query_i,
	b"r": query_r,
	b"c": query_c,
	b"d": query_d
}