#!/usr/bin/env python
# -*- coding: iso8859-1 -*-
import sys, os, re, time, urllib2

LOGFILE = "wm_scorefeed_livescore.log"
LIVESCORE_URL = "http://www.livescore.com/euro/fixtures/"
WM_URL = "http://wm.emphy.de/"
WM_Auth_File = "wm_scorefeed_auth.site"  # contents of that file: single line with "username:passwordInPlainText"
WM_Auth = open(WM_Auth_File).read().strip()

TeamNames = """
    albanien            : albania
    algerien            : algeria
    argentinien         : argentina
    australien          : australia
    belgien             : belgium
    bosnien-herzegowina : bosnia-herzegovina
    brasilien           : brazil
    deutschland         : germany
    elfenbeinküste      : ivory coast
    frankreich          : france
    griechenland        : greece
    irland              : ireland
    island              : iceland
    italien             : italy
    kamerun             : cameroon
    kolumbien           : colombia
    kroatien            : croatia
    mexiko              : mexico
    niederlande         : netherlands
    nordirland          : n.ireland
    österreich          : austria
    Österreich          : austria
    polen               : poland
    rumänien            : romania
    russland            : russia
    schweden            : sweden
    schweiz             : switzerland
    slowakei            : slovakia
    spanien             : spain
    südkorea            : south korea
    tschechien          : czech republic
    türkei              : turkey
    ungarn              : hungary
"""
TeamNames = dict(map(str.strip, line.split(':')) for line in TeamNames.split('\n') if line.strip())

C_RED, C_GREEN, C_BROWN, C_BLUE, C_VIOLET, C_CYAN, C_GRAY = ("\x1b[%dm" % x for x in xrange(31,38))
LOG_SUCCESS = C_GREEN
LOG_ERROR = C_RED
LOG_WARNING = C_BROWN
LOG_INFO = C_BLUE

_color = ("posix" in os.name.lower()) and sys.stdout.isatty()
_logfile = None
def log(msg, color=""):
    global _logfile, LOGFILE, _color
    prefix = time.strftime("[%Y-%m-%d %H:%M:%S] ", time.localtime())
    msg = msg.replace('\n', '\n                      ')
    if not(_logfile) and LOGFILE:
        try:
            _logfile = open(LOGFILE, "a")
        except IOError, e:
            f = LOGFILE
            LOGFILE = None
            log("could not open log file %s:\n%s" % (f, e), LOG_ERROR)
    if _logfile:
        _logfile.write(prefix + msg + "\n")
        _logfile.flush()
    if not _color:
        color = ""
    sys.stdout.write(prefix + color + msg + ("\x1b[0m\n" if color else "\n"))
    sys.stdout.flush()

def notags(x):
    return re.sub(r'<[^>]*>', '', x).strip()

class Match(object):
    def __init__(self):
        self.valid = False
        self.minute = 0
        self.teamA = None
        self.teamB = None
        self.goalsA = None
        self.goalsB = None

    def __repr__(self):
        return "Match(valid=%s, minute=%d, teams=(%r, %r), goals=(%r, %r))" % (self.valid, self.minute, self.teamA, self.teamB, self.goalsA, self.goalsB)

################################################################################

def ParseLiveScore(url):
    while True:
        try:
            if url.startswith("http"):
                req = urllib2.Request(url)
                req.add_header("Cookie", "tz=2")
                data = urllib2.urlopen(req).read()
            else:
                data = open(url).read()
            break
        except IOError, e:
            log("failed to load live score\nURL: %s\nError: %s\ntrying again in 10 seconds" % (url, e), LOG_ERROR)
            time.sleep(10)
            continue

    def is_valid_team(t):
        if not t: return False  # empty team name
        if t[0] in "123": return False  # placeholder for group round winners
        t = t.lower()
        if t.endswith('*'): return False  # fake result without penalty
        if '/' in t: return False  # placeholder for KO round winners like "Hereland/Thereland"
        if t.startswith("winner ") or t.startswith("loser "): return False  # placeholder for K.O. round winners
        return True

    data = data.split('<div class="content')[-1]
    for row in data.split('<div class="row'):
        row = re.sub(r'<[^>]*>', "\n", '<' + row)
        row = row.replace("&nbsp;", "")
        row = row.replace("&#x27;", "'")
        cells = filter(None, (c.strip() for c in row.split('\n')))
        m = Match()
        try:
            t, vs, score = cells[-3:]
            m.teamA, m.teamB = map(str.strip, vs.split(" vs "))
            if not(is_valid_team(m.teamA)) or not(is_valid_team(m.teamB)):
                continue
            m.goalsA, m.goalsB = [(None if (x.strip() == '?') else int(x.strip())) for x in score.split(" - ")]
            t = t.upper()
            if t.endswith("'"):
                m.minute = int(t[:-1].split('+', 1)[0].strip())
            elif t == "HT":
                m.minute = 45
            elif t == "ET":
                m.minute = 90
            elif t == "PEN":
                m.minute = 120
            elif t == "FT":
                m.minute = 90
                m.valid = not(m.goalsA is None) and not(m.goalsB is None)
            elif t == "AET":
                m.minute = 120
                m.valid = not(m.goalsA is None) and not(m.goalsB is None) and (m.goalsA != m.goalsB)
            yield m
        except (IndexError, ValueError):
            pass

################################################################################

def WMRequest(uri):
    url = WM_URL + uri
    try:
        req = urllib2.Request(url)
        req.add_header("Authorization", "Basic " + WM_Auth.encode('base64').strip())
        data = urllib2.urlopen(req).read()
    except IOError, e:
        log("Wettmeister request failed\nURL: %s\nError: %s" % (url, e), LOG_ERROR)
        return ""
    return data

def GetOpenMatches():
    data = WMRequest("adm_score_feed_endpoint.php").split('\n')
    gmap = {}
    for line in data:
        if not line: continue
        mid, ta, tb = line.split(':')
        gmap[TeamNames.get(ta, ta) + ':' + TeamNames.get(tb, tb)] = int(mid)
    return gmap

################################################################################

if __name__ == "__main__":
    if len(sys.argv) == 2:
        for m in ParseLiveScore(LIVESCORE_URL if (sys.argv[1] == "--test") else sys.argv[1]):
            print m
        sys.exit(0)

    log("----- %s starting -----" % sys.argv[0], C_VIOLET)
    wait = 0
    matches = {}
    was_short_wait = False
    active_matches = set()
    invalid_matches = False
    while True:
        if wait <= 60:
            invalid_matches = False  # don't update valid matches too often

        if wait:
            if wait >= 90:
                log("waiting %d minutes (until %s)" % ((wait + 30) / 60, time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time() + wait))), LOG_INFO)
                was_short_wait = False
            else:
                if not was_short_wait:
                    log("match(es) coming to a close, entering short-wait phase", LOG_INFO)
                was_short_wait = True
            try:
                time.sleep(wait)
            except KeyboardInterrupt:
                print
                break
            wait = 0

        if not(matches) or invalid_matches:
            matches = GetOpenMatches()
            if not matches:
                log("Wettmeister reports no outstanding matches.", LOG_INFO)
                wait = 3600
                continue
            else:
                log("Wettmeister reports %d outstanding match(es)" % len(matches), LOG_INFO)
            invalid_matches = False

        wait = 90 * 60
        n_done = 0
        for m in ParseLiveScore(LIVESCORE_URL):
            a = m.teamA.lower()
            b = m.teamB.lower()
            mcode = m.teamA + " - " + m.teamB
            this_wait = None

            if m.minute and not(m.valid) and not(mcode in active_matches):
                log("match %s is now running (minute %d, %s:%s)" % (mcode, m.minute, '?' if (m.goalsA is None) else m.goalsA, '?' if (m.goalsB is None) else m.goalsB), LOG_SUCCESS)
                active_matches.add(mcode)
            elif m.valid and (mcode in active_matches):
                log("match %s has finished" % mcode, LOG_SUCCESS)
                active_matches.remove(mcode)

            reverse = False
            mid = matches.get(a + ':' + b)
            if not mid:
                reverse = True
                mid = matches.get(b + ':' + a)
            if not mid:
                if not m.valid:
                    log("match %s is not outstanding or invalid" % mcode, LOG_WARNING)
                    invalid_matches = True
                continue

            if (mid >= 1000) and m.valid and (m.goalsA == m.goalsB):
                log("match %s seems to have ended with %s:%s, but needs a clear winner" % (mcode, m.goalsA, m.goalsB), LOG_WARNING)
                m.valid = False  # match must have a clear winner, but there is none yet -> don't enter it!
                this_wait = 300

            if m.valid:
                a, b = m.goalsA, m.goalsB
                log("entering result (%s = %d:%d)" % (mcode, a, b), LOG_SUCCESS)
                if reverse:
                    a, b = b, a
                WMRequest("adm_score_feed_endpoint.php?m=%d&a=%d&b=%d" % (mid, a, b))
                n_done += 1
            else:
                if this_wait:
                    pass
                elif m.minute < 90:
                    this_wait = 60 * (90 - m.minute)
                elif (m.minute > 95) and (m.minute < 120):
                    this_wait = 60 * (120 - m.minute)
                else:
                    this_wait = 10
                wait = min(wait, this_wait)

        if n_done:
            log("updating scores", LOG_SUCCESS)
            WMRequest("adm_do_update_scores.php")
            wait = 0
            matches = {}
            active_matches = set()
            invalid_matches = False
    log("----- %s exiting -----" % sys.argv[0], C_VIOLET)