def index():
    """Index (and only) page of site."""
    render_obj = []
    message_objects = Message.query.filter_by(display=True).all()
    server_objects = Server.query.all()

    for server in server_objects:
        address = server.address
        port = server.port
        conn = MinecraftServer(address, port)

        try:
            conn.ping()
        # except ConnectionRefusedError:
        # Commented out because for some reason on the production server,
        # attempting to catch this error causes the site to break and display
        # 'Internal Server Error'. Logs from such events say that
        # 'ConnectionRefusedError' is undefined, although there seem to be no
        # issues when testing locally.
        except:
            render_obj.append({
                "address": address,
                "port": port,
                "modpack_version": server.modpack_version,
                "client_config": server.client_config,
                "status": "Offline",
            })
        else:
            add_to_render = {}
            q = conn.query()
            motd = q.motd
            players = {
                "max": q.players.max,
                "online": q.players.online,
                "names": q.players.names,
            }
            jar_version = q.software.version

            add_to_render.update({
                "address": address,
                "port": port,
                "modpack_version": server.modpack_version,
                "client_config": server.client_config,
                "status": "Online",
                "motd": motd,
                "players": players,
                "jar_version": jar_version,
            })

            render_obj.append(add_to_render)

    return render_template(
        "index.html",
        servers=render_obj,
        messages=message_objects,
    )

def query():
    address = request.args.get("address")
    port = int(request.args.get("port"))
    conn = MinecraftServer(address, port)

    try:
        conn.ping()
    # except ConnectionRefusedError:
    # Commented out because for some reason on the production server,
    # attempting to catch this error causes the site to break and display
    # 'Internal Server Error'. Logs from such events say that
    # 'ConnectionRefusedError' is undefined, although there seem to be no
    # issues when testing locally.
    except:
        response = jsonify({
            "status": "Offline",
            "players_online": 0,
            "player_names": None,
        })
    else:
        q = conn.query()
        response = jsonify({
            "status": "Online",
            "players_online": q.players.online,
            "players_max": q.players.max,
            "player_names": q.players.names,
        })

    return response

def get_latency_or_offline(server_ip):
    print("Checking server " + server_ip)
    # noinspection PyBroadException
    try:
        server = MinecraftServer(server_ip)
        # MinecraftServer.lookup(server_ip)
        latency = server.status(retries=1).latency
        print("Server " + server_ip + " is online (latency: " + str(latency) + "ms)")
        return True, latency
    except Exception as e:
        print("Server " + server_ip + " is offline " + str(e))
        return False, str(e)

def mcb():

    # Look up server
    server = MinecraftServer.lookup('98.244.54.58:25565')
    ip = '{}:{}'.format(server.host, server.port)

    # Ping the server
    stat = None
    rawinfo = None
    players = None
    try:
        ping = server.ping()
    except Exception as e:
        return 'Server is down :('
    else:
        stat = 1

    if stat == 1:
        # Get query info
        rawinfo = server.query().raw
        players = server.query().players.names

    return render_template('mcb.html',
                           stat=stat,
                           pnum=int(rawinfo['numplayers']),
                           names=players,
                           ver=rawinfo['version'],
                           ip=ip)

def _init():
    config = configparser.ConfigParser()
    config.read("config.ini")
    hostname = config['DEFAULT']['server']

    server = MinecraftServer.lookup(hostname)
    return server

    def query_command(self, protocol, caller, source, command, raw_args,
                      parsed_args):
        if len(parsed_args) < 1:
            caller.respond("Usage: {CHARS}mcquery <address[:port]>")
        address = parsed_args[0]
        target = source

        if isinstance(source, User):
            target = caller

        try:
            q = MinecraftServer.lookup(address)
            status = q.status()
        except Exception as e:
            target.respond("Error retrieving status: %s" % e)
            self.logger.exception("Error retrieving status")
            return

        servername = status.description

        if isinstance(servername, dict):
            servername = servername.get("text", "<Unknown server name>")

        done = ""
        done += "[%s] %s | " % (status.version.name, servername)
        done += "%s/%s " % (status.players.online, status.players.max)
        if "plugins" in status.raw:
            done += "| %s plugins" % len(status.raw["plugins"])

        target.respond(done)

        if protocol.can_flood and status.players.sample:
            players = ", ".join([x.name for x in status.players.sample])
            target.respond("Players: %s" % players)

def mcping(text):
    """<server[:port]> - gets info about the Minecraft server at <server[:port]>"""
    try:
        server = MinecraftServer.lookup(text)
    except (IOError, ValueError) as e:
        return e

    try:
        s = server.status()
    except socket.gaierror:
        return "Invalid hostname"
    except socket.timeout:
        return "Request timed out"
    except ConnectionRefusedError:
        return "Connection refused"
    except ConnectionError:
        return "Connection error"
    except (IOError, ValueError) as e:
        return "Error pinging server: {}".format(e)

    if isinstance(s.description, dict):
        description = format_colors(" ".join(s.description["text"].split()))
    else:
        description = format_colors(" ".join(s.description.split()))

    if s.latency:
        return "{}\x0f - \x02{}\x0f - \x02{:.1f}ms\x02" " - \x02{}/{}\x02 players".format(
            description, s.version.name, s.latency, s.players.online, s.players.max
        ).replace("\n", "\x0f - ")
    else:
        return "{}\x0f - \x02{}\x0f" " - \x02{}/{}\x02 players".format(
            description, s.version.name, s.players.online, s.players.max
        ).replace("\n", "\x0f - ")

def index(request):		
	# Get the server
	server = MinecraftServer.lookup("www.yourServerHere.com:25565")

	# Get the status and query data, requires two calls to get everything.
	status = server.status()
	query = server.query()

	# Create the object to store all the server data.
	req = {}
		
	req['playerCount'] = status.players.online
	req['maxPlayers'] = status.players.max

	req['playerNames'] = query.players.names
	
	req['version'] = query.software.version;
	req['motd'] = query.motd;
	req['map'] = query.map;

	# Package the requested data into the callback for JSONP
	callback = request.GET.get('callback', '')
	response = json.dumps(req)
	response = callback + '(' + response + ');'

	return HttpResponse(response, content_type="application/json")

def minecraft_test(server_info, extra):
    try:
        server = MinecraftServer.lookup(server_info)
        server.status()
        return True
    except Exception as e:
        print e
        return False

 def getStatus(self):
     prop = self.getProperties()
     port = prop["server-port"]
     host = prop["server-ip"]
     if not host:
         host = "127.0.0.1"
     print(port, host)
     return MinecraftServer.lookup(host + ":" + port).status()

def query_server(server):
    """Query the minecraft server"""
    server = MinecraftServer.lookup(server)
    try:
        response = server.query()
    except socket.timeout:
      return None
    else:
      return response

def minecraft_status (bot, msg):
    server = MinecraftServer.lookup("minecraft.westsixth.net:25565")
    query = server.query()
    if not query.players.names:
         bot.say(msg.channel, "Nobody is on :-(")
         bot.say(msg.channel, "The server is running version {0} at the moment.".format("".join(query.software.version)))
    else:
        bot.say(msg.channel, "The following people are on: {0}".format(", ".join(query.players.names)))
        bot.say(msg.channel, "The server is running version {0} at the moment.".format("".join(query.software.version)))

def get_players(address):
    if not address:
        return []
    print "Connecting to {}".format(address)
    server = MinecraftServer.lookup(address)
    resp = server.status()
    try:
        return [p.name for p in resp.players.sample]
    except TypeError:
        return []

    async def __call__(self, client, message):
        ip = message.content.split(' ')[1]

        server = MinecraftServer.lookup(ip)
        try:
            status = server.status()
            await client.send_message(message.channel, '**{0}**: {1} players online. Running {2}'.format(
                      ip, status.players.online, status.version.name))
        except socket.gaierror:
            await client.send_message(message.channel, 'Cannot reach server.')

    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/html')
        self.end_headers()
	if self.path.translate(None, "/") in Config.keys():
	    server = MinecraftServer.lookup(Config[self.path.translate(None, "/")])
	    status = server.status()
	    result = {'online': status.players.online, 'latency': status.latency}
	    self.wfile.write(json.dumps(result))
	else:
	    self.wfile.write("Failed")

def index(request):
    try:
        server = MinecraftServer.lookup(settings.MC_HOST)
        status = server.status()
        query = server.query()
    except:
        status = None
        query = None
    user = Account.objects.all()
    top_m = Fe.objects.order_by("-money").exclude(name__contains="-")
    return render(request, "portal/index.html", {"status": status, "query": query, "top_m": top_m, "user": user})

def bot_online(bot, update, args):
    """Ónline function to check status of a Minecraft server"""
    try:
        chat_id = update.message.chat_id
        address = args[0]
        server = MinecraftServer(address)
        status = server.status()
        bot.sendMessage(
            chat_id=chat_id,
            text=("{0} ({1}) v{2} {3}ms Players online {4}/{5}".format(
                status.description,
                address,
                status.version.name,
                status.latency,
                status.players.online,
                status.players.max
            )))
    except IndexError:
        bot.sendMessage(chat_id=chat_id, text=onlinetext)
    except OSError:
        bot.sendMessage(chat_id=chat_id, text=onlinetext)

    def check(self, textkey, data, config):
        server = MinecraftServer.lookup("localhost:25565")
        srv = server.status()
        players = srv.players.online
        latency = server.ping()

        if textkey == 'players': 
            return players

	elif textkey == 'latency':
            return latency

        return 0

 def updateOnlineServers(self):
     connection = sqlite3.connect("servers.db")
     cursor = connection.cursor()
     ports = AnalyzeData.getPorts()
     for x in ports:
         name="node" + str(x)
         try:
             server = MinecraftServer.lookup("127.0.0.1:" + str(x))
             status = server.ping()
         except timeout:
             cursor.execute("UPDATE server_running SET running=? WHERE name=?", (False,name))
             connection.commit()
     connection.close()

def index():
    # Server IPs

    lobby_ip = '50.116.56.173:25565'

    # Fetch Server Data

    server = MinecraftServer.lookup(lobby_ip)
    status = server.status()
#   latency = server.ping()
#   query = server.query()

    lobby_players = status.players.online

    return render_template("index.html", count=lobby_players)