# Name:        RateMap v1.5b
#
# Author:      JoeyT2008
#
# Description: Allows players to rate their favourite maps.
#
# Commands:    !ratemap - Brings up the rating menu, or the error message if you have already rated.
#              !rate - Brings up the rating menu, or the error message if you have already rated.
#              !rm - Brings up the rating menu, or the error message if you have already rated.
#              !rating - Tells the user what the current map is rated.
#              !rating [map] - Tells the user what the chosen map is rated.
#              !ratings - Shows the users all maps in a list and their ratings.
#              !rmhelp - Brings up the command help menu.
#
# Credits:     Creator         JoeyT2008
#
#              Help            NATO_Hunter
#                              R`SiN
#                              Errant

import es, popuplib, keyvalues, os, playerlib, string, threading, gamethread, urllib2, time, langlib
from es import server_var

ratemap_ver = es.ServerVar("ratemap_ver", "1.5b", "Version of RateMap that you are using.")
ratemap_ver.makepublic()
rm_commands = {"!rm": "ratemap/sendpopup", "!rate": "ratemap/sendpopup", "!ratemap": "ratemap/sendpopup", "!rating": "ratemap/viewrating", "!ratings": "ratemap/listpopup", "!rmhelp": "ratemap/commands"}
rm_languages = ["en"]

info = es.AddonInfo() 
info.name     = "RateMap" 
info.version  = ratemap_ver
info.url      = "http://addons.eventscripts.com/addons/view/ratemap"
info.basename = "ratemap" 
info.author   = "JoeyT2008"

class DoSql(threading.Thread):
    def run(self):
        if rm_usemysql == 1:
            rm_removed = []
            try:
                rm_runsql = urllib2.urlopen("%s/deleted.php?username=%s&password=%s" % (rm_sqlurl, rm_username, rm_password)).read()
                for rm_map in rm_runsql.split("\n"):
                    rm_map = rm_map.replace("<br/>", "")
                    rm_removed.append(rm_map)
            except:
                rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "r")
                rm_logfiletext = rm_logfile.read() + "%s: Error: Could not check for deleted maps.\n" % (time.ctime())
                rm_logfile.close()
                rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "w")
                rm_logfile.write(rm_logfiletext)
                rm_logfile.close()
            rm_filepath = es.getAddonPath("ratemap") + "/data/"
            for rm_map in os.listdir(rm_filepath):
                rm_map = rm_map.replace(".dat", "")
                rm_path = es.getAddonPath("ratemap") + "/data/" + rm_map + ".dat"
                if os.path.exists(rm_path):
                    if rm_map in rm_removed:
                        os.remove(rm_path)
                        rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "r")
                        rm_logfiletext = rm_logfile.read() + "%s: Removed: %s\n" % (time.ctime(), rm_map)
                        rm_logfile.close()
                        rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "w")
                        rm_logfile.write(rm_logfiletext)
                        rm_logfile.close()
                    else:
                        mapkey = keyvalues.KeyValues(name=str(rm_map))
                        mapkey.load(rm_path)
                        if 'fivestars' in mapkey:
                            rm_fivestars = mapkey['fivestars']['count']
                        else:
                            rm_fivestars = 0
                        if 'fourstars' in mapkey:
                            rm_fourstars = mapkey['fourstars']['count']
                        else:
                            rm_fourstars = 0
                        if 'threestars' in mapkey:
                            rm_threestars = mapkey['threestars']['count']
                        else:
                            rm_threestars = 0
                        if 'twostars' in mapkey:
                            rm_twostars = mapkey['twostars']['count']
                        else:
                            rm_twostars = 0
                        if 'onestars' in mapkey:
                            rm_onestars = mapkey['onestars']['count']
                        else:
                            rm_onestars = 0
                        if 'runs' in mapkey:
                            rm_runs = mapkey['runs']['count']
                        else:
                            rm_runs = 0
                        if not rm_map == "":
                            try:
                                rm_runsql = urllib2.urlopen("%s/update.php?username=%s&password=%s&map=%s&fivestars=%s&fourstars=%s&threestars=%s&twostars=%s&onestars=%s&runs=%s" % (rm_sqlurl, rm_username, rm_password, rm_map, rm_fivestars, rm_fourstars, rm_threestars, rm_twostars, rm_onestars, rm_runs)).read()
                            except:
                                rm_runsql = "Could not connect to server."
                            if rm_runsql == "FINISHED":
                                rm_type = "Finished"
                                rm_runsql = "SQL table updated for %s." % rm_map
                            else:
                                rm_type = "Error"
                            rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "r")
                            rm_logfiletext = rm_logfile.read() + "%s: %s: %s\n" % (time.ctime(), rm_type, rm_runsql)
                            rm_logfile.close()
                            rm_logfile = open(es.getAddonPath("ratemap") + "/ratemap.log", "w")
                            rm_logfile.write(rm_logfiletext)
                            rm_logfile.close()

def loadconfig():
    rm_requiredvars = {"rm_maplist": 0, "rm_maplist_type": 0, "rm_maplist_ammount": 0, "rm_popup_automatic": 0, "rm_popup_minutes": 0, "rm_usemysql": 0, "rm_maplist": 0, "rm_sqlurl": 0, "rm_username": 0, "rm_password": 0, "rm_updatetime": 0, "rm_maplist_rating": 0, "rm_maplist_min_votes": 0}
    rm_path = es.ServerVar("eventscripts_gamedir") + "/cfg/ratemap.cfg"
    if os.path.exists(rm_path):
        rm_config = open(rm_path, "r").read()
        rm_vars = {}
        for line in rm_config.split("\n"):
            line = line.strip()
            if not line.startswith("/") and not line.startswith("-") and not line == "":
                line = line.split()
                rm_vars[line[0]] = line[1]
        for rm_varname in rm_vars:
            if rm_varname in rm_requiredvars:
                del rm_requiredvars[rm_varname]
        if len(rm_requiredvars) == 0:
            global rm_maplist
            rm_maplist = es.ServerVar("rm_maplist", int(rm_vars["rm_maplist"]))
            global rm_maplist_type
            rm_maplist_type = es.ServerVar("rm_maplist_type", int(rm_vars["rm_maplist_type"]))
            global rm_maplist_ammount
            rm_maplist_ammount = es.ServerVar("rm_maplist_ammount", int(rm_vars["rm_maplist_ammount"]))
            global rm_popup_automatic
            rm_popup_automatic = es.ServerVar("rm_popup_automatic", int(rm_vars["rm_popup_automatic"]))
            global rm_popup_minutes
            rm_popup_minutes = es.ServerVar("rm_popup_minutes", int(rm_vars["rm_popup_minutes"]))
            global rm_usemysql
            rm_usemysql = es.ServerVar("rm_usemysql", int(rm_vars["rm_usemysql"]))
            global rm_sqlurl
            rm_sqlurl = rm_vars["rm_sqlurl"]
            global rm_username
            rm_username = rm_vars["rm_username"]
            global rm_password
            rm_password = rm_vars["rm_password"]
            global rm_updatetime
            rm_updatetime = es.ServerVar("rm_updatetime", int(rm_vars["rm_updatetime"]))
            global rm_maplist_rating
            rm_maplist_rating = es.ServerVar("rm_maplist_rating", int(rm_vars["rm_maplist_rating"]))
            global rm_maplist_min_votes
            rm_maplist_min_votes = es.ServerVar("rm_maplist_min_votes", int(rm_vars["rm_maplist_min_votes"]))
            es.ServerVar("ratemap_url", rm_sqlurl).makepublic() 
        else: 
            for rm_varname in rm_requiredvars:
                es.dbgmsg(0, lang("cfg_missing_var", {"var": rm_varname}))
                lang("mysql_fail", {"map": rm_map})
            es.unload("ratemap")
    else:
        es.dbgmsg(0, lang("cfg_missing"))
        es.unload("ratemap")

def gg_win(event_var):
    popup_rating()

def load():
    global lang
    lang = langlib.Strings(es.getAddonPath("ratemap") + "/strings.ini")
    loadconfig()
    global rm_rounds_left
    rm_rounds_left = es.ServerVar("mp_maxrounds")
    if rm_rounds_left == 0:
        rm_rounds_left = -1
    for rm_command in rm_commands:
        es.regsaycmd(rm_command, rm_commands[rm_command])
    global rm_map
    rm_map = es.ServerVar("eventscripts_currentmap")
    global rm_path
    rm_path = es.getAddonPath('ratemap') + "/data/" + rm_map + '.dat'
    if not os.path.exists(rm_path):
        mapkey = keyvalues.KeyValues(name=str(rm_map))
        mapkey['fivestars'] = keyvalues.KeyValues(name='fivestars')
        mapkey['fivestars']['count'] = 0
        mapkey['fourstars'] = keyvalues.KeyValues(name='fourstars')
        mapkey['fourstars']['count'] = 0
        mapkey['threestars'] = keyvalues.KeyValues(name='threestars')
        mapkey['threestars']['count'] = 0
        mapkey['twostars'] = keyvalues.KeyValues(name='twostars')
        mapkey['twostars']['count'] = 0
        mapkey['onestars'] = keyvalues.KeyValues(name='onestars')
        mapkey['onestars']['count'] = 0
        mapkey.save(rm_path)
    else:
        mapkey = keyvalues.KeyValues(name=str(rm_map))
        mapkey.load(rm_path)
    gamethread.delayedname(rm_updatetime, "updatesql", updatesql)

def unload():
    gamethread.cancelDelayed("popup_rating")
    gamethread.cancelDelayed("updatesql")
    for rm_command in rm_commands:
        es.unregsaycmd(rm_command)

def es_map_start(event_var):
    global rm_map
    rm_map = es.ServerVar("eventscripts_currentmap")
    global rm_path
    rm_path = es.getAddonPath('ratemap') + "/data/" + rm_map + ".dat"
    if not os.path.exists(rm_path):
        mapkey = keyvalues.KeyValues(name=str(rm_map))
        mapkey['fivestars'] = keyvalues.KeyValues(name='fivestars')
        mapkey['fivestars']['count'] = 0
        mapkey['fourstars'] = keyvalues.KeyValues(name='fourstars')
        mapkey['fourstars']['count'] = 0
        mapkey['threestars'] = keyvalues.KeyValues(name='threestars')
        mapkey['threestars']['count'] = 0
        mapkey['twostars'] = keyvalues.KeyValues(name='twostars')
        mapkey['twostars']['count'] = 0
        mapkey['onestars'] = keyvalues.KeyValues(name='onestars')
        mapkey['onestars']['count'] = 0
        mapkey['runs'] = keyvalues.KeyValues(name='runs')
        mapkey['runs']['count'] = 1
        mapkey.save(rm_path)
    else:
        mapkey = keyvalues.KeyValues(name=str(rm_map))
        mapkey.load(rm_path)
        if 'runs' in mapkey:
            rm_runs = mapkey['runs']['count']
            rm_runs += 1
            mapkey['runs']['count'] = rm_runs
            mapkey.save(rm_path)
        else:
            rm_runs = 1
            mapkey['runs'] = keyvalues.KeyValues(name='runs')
            mapkey['runs']['count'] = rm_runs
            mapkey.save(rm_path)
    if rm_maplist == 1:
        createmaplist()
    gamethread.cancelDelayed("popup_rating")
    if rm_popup_automatic == 1:
        rm_popup_seconds = int(rm_popup_minutes) * 60
        gamethread.delayedname(rm_popup_seconds, 'popup_rating', popup_rating)
    rm_sql = DoSql();
    rm_sql.start()

def updatesql():
    rm_sql = DoSql();
    rm_sql.start()
    gamethread.delayedname(rm_updatetime*60, "updatesql", updatesql)

def popup_rating():
    for rm_userid in playerlib.getPlayerList('#all'):
        rm_userid = int(rm_userid)
        mapkey = keyvalues.KeyValues(name=str(rm_map))
        mapkey.load(rm_path)
        rm_steamid = es.getplayersteamid(rm_userid)
        if not rm_steamid in mapkey:
            popuprating(rm_userid)

def createmaplist():
    rm_maplistdict = {}
    rm_filepath = es.getAddonPath('ratemap') + "/data/"
    for rm_file in os.listdir(rm_filepath):
        rm_filepath_full = rm_filepath + rm_file
        rm_maps = keyvalues.KeyValues(name=rm_file)
        rm_maps.load(rm_filepath_full)
        rm_fivestars = rm_maps["fivestars"]["count"]
        rm_fourstars = rm_maps["fourstars"]["count"]
        rm_threestars = rm_maps["threestars"]["count"]
        rm_twostars = rm_maps["twostars"]["count"]
        rm_onestars = rm_maps["onestars"]["count"]
        rm_total_fivestars = int(rm_fivestars) * 5
        rm_total_fourstars = int(rm_fourstars) * 4
        rm_total_threestars = int(rm_threestars) * 3
        rm_total_twostars = int(rm_twostars) * 2
        rm_total_onestars = int(rm_onestars) * 1
        rm_total_votes = int(rm_fivestars) + int(rm_fourstars) + int(rm_threestars) + int(rm_twostars) + int(rm_onestars)
        rm_total_votes2 = int(rm_total_fivestars) + int(rm_total_fourstars) + int(rm_total_threestars) + int(rm_total_twostars) + int(rm_total_onestars)
        if rm_total_votes2 != 0:
            rm_totalmaplistrating = float(rm_total_votes2) / float(rm_total_votes)
            if rm_maplist_type == 1:
                rm_maplistrating = rm_total_votes2
            if rm_maplist_type == 2:
                rm_maplistrating = float(rm_total_votes2) / float(rm_total_votes)
            if rm_maplist_type == 3:
                rm_maplistrating = rm_total_votes
            rm_mapname = rm_file.replace(".dat", "")
            if rm_total_votes <= int(rm_maplist_min_votes) or rm_totalmaplistrating >= int(rm_maplist_rating):
                rm_maplistdict[rm_mapname] = rm_maplistrating
    rm_maplistdict_items = [(v, k) for k, v in rm_maplistdict.items()]
    rm_maplistdict_items.sort()
    rm_maplistdict_items.reverse()
    rm_maplistdict_items = [(k, v) for v, k in rm_maplistdict_items]
    rm_ammount = rm_maplist_ammount
    rm_txtpath = es.getAddonPath('ratemap') + "../../../../maplist.txt"
    rm_txtpath2 = es.getAddonPath('ratemap') + "../../../../mapcycle.txt"
    rm_txtpath3 = es.getAddonPath('ratemap') + "../../../../cfg/mani_admin_plugin/votemaplist.txt"
    f = open(rm_txtpath, 'w')
    f2 = open(rm_txtpath2, 'w')
    if os.path.exists(rm_txtpath3):
        f3 = open(rm_txtpath3, 'w')
    for rm_key in rm_maplistdict_items:
        rm_ammount -= 1
        if not rm_ammount == 0:
            rm_key = str(rm_key)
            rm_mapname = rm_key.split("', ")[0][2:]
            f.write('%s\n' % rm_mapname)
            f2.write('%s\n' % rm_mapname)
            if os.path.exists(rm_txtpath3):
                f3.write('%s\n' % rm_mapname)
    f.close()
    f2.close()
    if os.path.exists(rm_txtpath3):
        f3.close()

def round_start(event_var):
    global rm_rounds_left
    rm_rounds_left -= 1
    if rm_rounds_left == 0:
        if rm_popup_minutes == 0:
            popup_rating()
    mapkey = keyvalues.KeyValues(name=str(rm_map))
    mapkey.load(rm_path)
    for rm_userid in playerlib.getPlayerList("#all"):
        rm_userid = int(rm_userid)
        rm_player = playerlib.getPlayer(rm_userid)
        rm_lang = rm_player.get("lang")
        if not rm_lang in rm_languages:
            rm_lang = "en"
        es.tell(rm_userid, "#multi", lang("round_start_msg1", {}, rm_lang))
        rm_ratingdict = getrating(rm_userid, rm_map)
        if not rm_ratingdict == None:
            es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
        else:
            es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map}, rm_lang))

def teamplay_round_start(event_var):
    mapkey = keyvalues.KeyValues(name=str(rm_map))
    mapkey.load(rm_path)
    for rm_userid in playerlib.getPlayerList("#all"):
        rm_userid = int(rm_userid)
        rm_player = playerlib.getPlayer(rm_userid)
        rm_lang = rm_player.get("lang")
        if not rm_lang in rm_languages:
            rm_lang = "en"
        es.tell(rm_userid, "#multi", lang("round_start_msg1", {}, rm_lang))
        rm_ratingdict = getrating(rm_userid, rm_map)
        if not rm_ratingdict == None:
            es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
        else:
            es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map}, rm_lang))

def viewrating():
    rm_userid = es.getcmduserid()
    rm_player = playerlib.getPlayer(int(rm_userid))
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    rm_argcount = es.getargc()
    if rm_argcount <= 2:
        if rm_argcount == 1:
            rm_ratingdict = getrating(rm_userid, rm_map)
            if not rm_ratingdict == None:
                es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
            else:
                es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map}, rm_lang))
        if rm_argcount == 2:
            rm_map2 = es.getargv(1)
            rm_ratingdict = getrating(rm_userid, rm_map2)
            if not rm_ratingdict == None:
                es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
            else:
                es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map2}, rm_lang))
    else:
        es.tell(int(rm_userid), "#multi", lang("viewrating", {}, rm_lang))

def sendpopup():
    rm_userid = es.getcmduserid()
    mapkey = keyvalues.KeyValues(name=str(rm_map))
    mapkey.load(rm_path)
    rm_steamid = es.getplayersteamid(rm_userid)
    if rm_steamid in mapkey:
        rm_player = playerlib.getPlayer(int(rm_userid))
        rm_lang = rm_player.get("lang")
        if not rm_lang in rm_languages:
            rm_lang = "en"
        es.tell(rm_userid, "#multi", lang("sendpopup", {"map": rm_map}, rm_lang))
        rm_ratingdict = getrating(rm_userid, rm_map)
        if not rm_ratingdict == None:
            es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
        else:
            es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map}, rm_lang))
    else:
        popuprating(rm_userid)

def popuprating(rm_userid):
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    if popuplib.isqueued('ratemenu', rm_userid):
        popuplib.close('ratemenu', rm_userid)
    ratemenu = popuplib.create("ratemenu")
    ratemenu.addline("RateMap v1.5b")
    ratemenu.addline("-------------------")
    ratemenu.addline("%s: %s" % (lang("map", {}, rm_lang), rm_map))
    ratemenu.addline("-------------------")
    ratemenu.addline("->1. 5 %s" % lang("stars", {}, rm_lang))
    ratemenu.addline("->2. 4 %s" % lang("stars", {}, rm_lang))
    ratemenu.addline("->3. 3 %s" % lang("stars", {}, rm_lang))
    ratemenu.addline("->4. 2 %s" % lang("stars", {}, rm_lang))
    ratemenu.addline("->5. 1 %s" % lang("star", {}, rm_lang))
    ratemenu.addline("-------------------")
    ratemenu.addline("0. %s" % lang("close", {}, rm_lang))
    ratemenu.addline("-------------------")
    ratemenu.select(1, setrating)
    ratemenu.select(2, setrating)
    ratemenu.select(3, setrating)
    ratemenu.select(4, setrating)
    ratemenu.select(5, setrating)
    ratemenu.send(rm_userid)

def setrating(rm_userid, rm_choice, rm_popup):
    mapkey = keyvalues.KeyValues(name=str(rm_map))
    mapkey.load(rm_path)
    if rm_choice == 1:
        rm_stars = "fivestars"
    if rm_choice == 2:
        rm_stars = "fourstars"
    if rm_choice == 3:
        rm_stars = "threestars"
    if rm_choice == 4:
        rm_stars = "twostars"
    if rm_choice == 5:
        rm_stars = "onestars"
    rm_steamid = es.getplayersteamid(rm_userid)
    mapkey[rm_steamid] = keyvalues.KeyValues(name=str(rm_steamid))
    mapkey[rm_steamid]["Rated"] = rm_choice
    rm_count = mapkey[rm_stars]["count"]
    rm_count = int(rm_count)
    rm_count += 1
    mapkey[rm_stars]["count"] = rm_count
    mapkey.save(rm_path)
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    es.tell(rm_userid, "#multi", lang("thx_for_rating", {"map": rm_map}, rm_lang))
    rm_ratingdict = getrating(rm_userid, rm_map)
    if not rm_ratingdict == None:
        es.tell(rm_userid, "#multi", lang("rating", rm_ratingdict, rm_lang))
    else:
        es.tell(rm_userid, "#multi", lang("no_rating", {"map": rm_map}, rm_lang))

def getrating(rm_userid, rm_map2):
    mapkey = keyvalues.KeyValues(name=str(rm_map2))
    rm_path2 = es.getAddonPath('ratemap') + "/data/" + rm_map2 + '.dat'
    if not os.path.exists(rm_path2):
        return None
    else:
        mapkey.load(rm_path2)
        rm_fivestars = mapkey["fivestars"]["count"]
        rm_fourstars = mapkey["fourstars"]["count"]
        rm_threestars = mapkey["threestars"]["count"]
        rm_twostars = mapkey["twostars"]["count"]
        rm_onestars = mapkey["onestars"]["count"]
        rm_total_fivestars = int(rm_fivestars) * 5
        rm_total_fourstars = int(rm_fourstars) * 4
        rm_total_threestars = int(rm_threestars) * 3
        rm_total_twostars = int(rm_twostars) * 2
        rm_total_onestars = int(rm_onestars) * 1
        rm_total_votes = int(rm_fivestars) + int(rm_fourstars) + int(rm_threestars) + int(rm_twostars) + int(rm_onestars)
        rm_total_votes2 = int(rm_total_fivestars) + int(rm_total_fourstars) + int(rm_total_threestars) + int(rm_total_twostars) + int(rm_total_onestars)
        if rm_total_votes != 0:
            rm_map_rating = float(rm_total_votes2) / float(rm_total_votes)
            rm_map_rating = "%.2f"%rm_map_rating
            return {"map": rm_map2, "rating": rm_map_rating, "votes": rm_total_votes}
        else:
            return {"map": rm_map2, "rating": 0.00, "votes": 0}

def listpopup():
    rm_userid = es.getcmduserid()
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    if popuplib.isqueued('ratemenu2', rm_userid):
        popuplib.close('ratemenu2', rm_userid)
    ratemenu2 = popuplib.create('ratemenu2')
    ratemenu2.addline('RateMap v1.5b')
    ratemenu2.addline('-------------------')
    ratemenu2.addline('->1. %s' % lang("nameasc", {}, rm_lang))
    ratemenu2.addline('->2. %s' % lang("nameasc", {}, rm_lang))
    ratemenu2.addline('->3. %s' % lang("votesasc", {}, rm_lang))
    ratemenu2.addline('->4. %s' % lang("votesasc", {}, rm_lang))
    ratemenu2.addline('->5. %s' % lang("ratingasc", {}, rm_lang))
    ratemenu2.addline('->6. %s' % lang("ratingasc", {}, rm_lang))
    ratemenu2.addline('-------------------')
    ratemenu2.addline('0. %s' % lang("close", {}, rm_lang))
    ratemenu2.addline('-------------------')
    ratemenu2.menuselect = sort
    ratemenu2.send(rm_userid)

def sort(rm_userid, rm_choice, rm_popupid):
    if rm_choice == 1:
        sortbyname(rm_userid, 1)
    if rm_choice == 2:
        sortbyname(rm_userid, 2)
    if rm_choice == 3:
        sortbyvotes(rm_userid, 1)
    if rm_choice == 4:
        sortbyvotes(rm_userid, 2)
    if rm_choice == 5:
        sortbyrating(rm_userid, 1)
    if rm_choice == 6:
        sortbyrating(rm_userid, 2)

def sortbyname(rm_userid, rm_type):
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    rm_namedict = {}
    rm_filepath = es.getAddonPath('ratemap') + "/data/"
    ratemenu3 = popuplib.easymenu('ratemenu3', '_popup_choice', showinfo)
    ratemenu3.settitle("RateMap v1.5b\n%s" % lang("mapratings", {}, rm_lang))
    for rm_file in os.listdir(rm_filepath):
        rm_file = rm_file.replace(".dat", "")
        rm_namedict[rm_file] = rm_file
    rm_namedict_items = [(v, k) for k, v in rm_namedict.items()]
    rm_namedict_items.sort()
    if rm_type == 2:
        rm_namedict_items.reverse()
    rm_namedict_items = [(k, v) for v, k in rm_namedict_items]
    for rm_key in rm_namedict_items:
        rm_key = str(rm_key)
        rm_name = rm_key.split("', ")[0][2:]
        ratemenu3.addoption(rm_key, rm_name)
    ratemenu3.send(rm_userid)

def sortbyvotes(rm_userid, rm_type):
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    rm_filepath = es.getAddonPath('ratemap') + "/data/"
    rm_votedict = {}
    rm_ratingdict = {}
    if popuplib.isqueued('ratemenu4', rm_userid):
        popuplib.close('ratemenu4', rm_userid)
    for rm_file in os.listdir(rm_filepath):
        rm_filepath_full = rm_filepath + rm_file
        rm_maps = keyvalues.KeyValues(name=rm_file)
        rm_maps.load(rm_filepath_full)
        rm_map_fivestars = rm_maps["fivestars"]["count"]
        rm_map_fourstars = rm_maps["fourstars"]["count"]
        rm_map_threestars = rm_maps["threestars"]["count"]
        rm_map_twostars = rm_maps["twostars"]["count"]
        rm_map_onestars = rm_maps["onestars"]["count"]
        rm_map_total_fivestars = rm_map_fivestars * 5
        rm_map_total_fourstars = rm_map_fourstars * 4
        rm_map_total_threestars = rm_map_threestars * 3
        rm_map_total_twostars = rm_map_twostars * 2
        rm_map_total_onestars = rm_map_onestars
        rm_map_votes = rm_map_fivestars + rm_map_twostars + rm_map_threestars + rm_map_fourstars + rm_map_onestars
        rm_map_rating = rm_map_total_fivestars + rm_map_total_twostars + rm_map_total_threestars + rm_map_total_fourstars + rm_map_total_onestars
        rm_votedict[rm_file] = rm_map_votes
        rm_ratingdict[rm_file] = rm_map_rating
    rm_votedict_items = [(v, k) for k, v in rm_votedict.items()]
    rm_votedict_items.sort()
    if rm_type == 1:
        rm_votedict_items.reverse()
    rm_votedict_items = [(k, v) for v, k in rm_votedict_items]
    rm_ratingdict_items = [(v, k) for k, v in rm_ratingdict.items()]
    rm_ratingdict_items.sort()
    if rm_type == 1:
        rm_ratingdict_items.reverse()
    ratemenu4 = popuplib.easymenu('ratemenu4', '_popup_choice', showinfo)
    ratemenu4.settitle("RateMap v1.5b\n%s" % lang("mapratings", {}, rm_lang))
    rm_ratingdict_items = [(k, v) for v, k in rm_ratingdict_items]
    for rm_key in rm_votedict_items:
        rm_key = str(rm_key)
        rm_name = rm_key.split("', ")[0][2:]
        rm_name = rm_name.replace(".dat", "")
        rm_value = rm_key.split("', ")[1][:4]
        rm_value = rm_value.replace(")", "")
        rm_name = rm_name + " - " + rm_value
        ratemenu4.addoption(rm_key, rm_name)
    ratemenu4.send(rm_userid)

def sortbyrating(rm_userid, rm_type):
    rm_filepath = es.getAddonPath('ratemap') + "/data/"
    rm_votedict = {}
    rm_ratingdict = {}
    rm_totalratingdict = {}
    if popuplib.isqueued('ratemenu5', rm_userid):
        popuplib.close('ratemenu5', rm_userid)
    ratemenu5 = popuplib.easymenu('ratemenu5', '_popup_choice', showinfo)
    ratemenu5.settitle("RateMap v1.5b")
    for rm_file in os.listdir(rm_filepath):
        rm_filepath_full = rm_filepath + rm_file
        rm_maps = keyvalues.KeyValues(name=rm_file)
        rm_maps.load(rm_filepath_full)
        rm_map_fivestars = rm_maps["fivestars"]["count"]
        rm_map_fourstars = rm_maps["fourstars"]["count"]
        rm_map_threestars = rm_maps["threestars"]["count"]
        rm_map_twostars = rm_maps["twostars"]["count"]
        rm_map_onestars = rm_maps["onestars"]["count"]
        rm_map_total_fivestars = rm_map_fivestars * 5
        rm_map_total_fourstars = rm_map_fourstars * 4
        rm_map_total_threestars = rm_map_threestars * 3
        rm_map_total_twostars = rm_map_twostars * 2
        rm_map_total_onestars = rm_map_onestars
        rm_map_votes = rm_map_fivestars + rm_map_twostars + rm_map_threestars + rm_map_fourstars + rm_map_onestars
        rm_map_rating = rm_map_total_fivestars + rm_map_total_twostars + rm_map_total_threestars + rm_map_total_fourstars + rm_map_total_onestars
        rm_votedict[rm_file] = rm_map_votes
        rm_ratingdict[rm_file] = rm_map_rating
        if rm_map_votes != 0:
            rm_map_rating = rm_map_rating + .00
            rm_map_votes = rm_map_votes + .00
            rm_map_total_rating = rm_map_rating / rm_map_votes
        else:
            rm_map_total_rating = 0
        rm_totalratingdict[rm_file] = rm_map_total_rating
    rm_ratingdict_items = [(v, k) for k, v in rm_totalratingdict.items()]
    rm_ratingdict_items.sort()
    if rm_type == 1:
        rm_ratingdict_items.reverse()
    rm_ratingdict_items = [(k, v) for v, k in rm_ratingdict_items]
    for rm_key in rm_ratingdict_items:
        rm_key = str(rm_key)
        rm_key = rm_key.replace(".dat", "")
        rm_name = rm_key.split("', ")[0][2:]
        rm_name_full = rm_name + ".dat"
        rm_map_rating = rm_totalratingdict[rm_name_full]
        rm_name = rm_name + " - " + str("%.2f"%rm_map_rating) + "/5.00"
        ratemenu5.addoption(rm_key, rm_name)
    ratemenu5.send(rm_userid)

def showinfo(rm_userid, rm_choice, rm_popupid):
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    if ".dat" in rm_choice:
        rm_choice = rm_choice.replace(".dat", "")
    rm_map_name = rm_choice.split("', ")[0][2:]
    rm_map_path = es.getAddonPath('ratemap') + "/data/" + rm_map_name + ".dat"
    if popuplib.isqueued('ratemenu6', rm_userid):
        popuplib.close('ratemenu6', rm_userid)
    mapkey = keyvalues.KeyValues(name=str(rm_map_name))
    mapkey.load(rm_map_path)
    rm_map_fivestars = mapkey["fivestars"]["count"]
    rm_map_fourstars = mapkey["fourstars"]["count"]
    rm_map_threestars = mapkey["threestars"]["count"]
    rm_map_twostars = mapkey["twostars"]["count"]
    rm_map_onestars = mapkey["onestars"]["count"]
    rm_map_total_fivestars = rm_map_fivestars * 5
    rm_map_total_fourstars = rm_map_fourstars * 4
    rm_map_total_threestars = rm_map_threestars * 3
    rm_map_total_twostars = rm_map_twostars * 2
    rm_map_total_onestars = rm_map_onestars
    rm_map_votes = rm_map_fivestars + rm_map_fourstars + rm_map_threestars + rm_map_twostars + rm_map_onestars
    rm_map_rating = rm_map_total_fivestars + rm_map_total_fourstars + rm_map_total_threestars + rm_map_total_twostars + rm_map_total_onestars
    if rm_map_rating != 0:
        rm_map_rating = rm_map_rating + .00
        rm_map_votes2 = rm_map_votes + .00
        rm_map_rating = rm_map_rating / rm_map_votes2
    rm_steamid = es.getplayersteamid(rm_userid)
    if rm_steamid in mapkey:
        rm_player_rating = mapkey[rm_steamid]["Rated"]
        if rm_player_rating == 1:
            rm_player_rating = "5.00"
        if rm_player_rating == 2:
            rm_player_rating = "4.00"
        if rm_player_rating == 3:
            rm_player_rating = "3.00"
        if rm_player_rating == 4:
            rm_player_rating = "2.00"
        if rm_player_rating == 5:
            rm_player_rating = "1.00"
    if 'runs' in mapkey:
        rm_runs = mapkey['runs']['count']
    else:
        rm_runs = 0
    ratemenu6 = popuplib.create('ratemenu6')
    ratemenu6.addline('RateMap v1.5b')
    ratemenu6.addline('-------------------')
    ratemenu6.addline('%s: %s' % (lang("mapname", {}, rm_lang), rm_map_name))
    ratemenu6.addline('%s: %s' % (lang("totalvotes", {}, rm_lang), rm_map_votes))
    ratemenu6.addline('%s: %s times' % (lang("mapruns", {}, rm_lang), rm_runs))
    ratemenu6.addline('%s: %s' % (lang("ratingtxt", {}, rm_lang), "%.2f"%rm_map_rating + "/5.00"))
    if rm_steamid in mapkey:
        ratemenu6.addline('%s: %s' % (lang("yourrating", {}, rm_lang), rm_player_rating))
    ratemenu6.addline('-------------------')
    ratemenu6.addline('0. %s' % lang("close", {}, rm_lang))
    ratemenu6.addline('-------------------')
    ratemenu6.send(rm_userid)

def commands():
    rm_userid = es.getcmduserid()
    if popuplib.isqueued('ratemenu7', rm_userid):
        popuplib.close('ratemenu7', rm_userid)
    ratemenu7 = popuplib.create('ratemenu7')
    ratemenu7.addline('RateMap v1.5b')
    ratemenu7.addline('-------------------')
    ratemenu7.addline('Help')
    ratemenu7.addline('-------------------')
    ratemenu7.addline('->1. !ratemap')
    ratemenu7.addline('->2. !ratings')
    ratemenu7.addline('->3. !rating')
    ratemenu7.addline('->4. !rmhelp')
    ratemenu7.addline('-------------------')
    ratemenu7.addline('0. Close')
    ratemenu7.addline('-------------------')
    ratemenu7.menuselect = commanddesc
    ratemenu7.send(rm_userid)

def commanddesc(rm_userid, rm_choice, rm_popupid):
    rm_player = playerlib.getPlayer(rm_userid)
    rm_lang = rm_player.get("lang")
    if not rm_lang in rm_languages:
        rm_lang = "en"
    if popuplib.isqueued('ratemenu8', rm_userid):
        popuplib.close('ratemenu8', rm_userid)
    ratemenu8 = popuplib.create('ratemenu8')
    ratemenu8.addline('RateMap v1.5b')
    ratemenu8.addline('-------------------')
    if rm_choice == 1:
        ratemenu8.addline('!ratemap')
    if rm_choice == 2:
        ratemenu8.addline('!ratings')
    if rm_choice == 3:
        ratemenu8.addline('!rating')
    if rm_choice == 4:
        ratemenu8.addline('!rmhelp')
    ratemenu8.addline('-------------------')
    if rm_choice == 1:
        ratemenu8.addline('%s' % lang("rmh1", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh2", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh3", {}, rm_lang))
    if rm_choice == 2:
        ratemenu8.addline('%s' % lang("rmh4", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh5", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh6", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh7", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh8", {}, rm_lang))
    if rm_choice == 3:
        ratemenu8.addline('%s' % lang("rmh9", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh10", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh11", {}, rm_lang))
    if rm_choice == 4:
        ratemenu8.addline('%s' % lang("rmh12", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh13", {}, rm_lang))
        ratemenu8.addline('%s' % lang("rmh14", {}, rm_lang))
    ratemenu8.addline('-------------------')
    ratemenu8.addline('0. %s' % lang("close", {}, rm_lang))
    ratemenu8.addline('-------------------')
    ratemenu8.send(rm_userid)