#!/usr/bin/env python3

# OG racing score conversion script
#
# This script is meant to update racing scoreboards from Retro-style scores
# to OG-accurate scores. Be careful to only run this once!
#
# The script will create a backup of your DB, as well as a log file
# containing a record of all the changes that were made. Make sure to
# preserve this log file in case you need to reference it in the future.
#
# If something goes wrong with the first invocation, you'll need to move the
# DB backup and log files out of the way before the script can be re-run.
#
# If all goes well, you should see different, OG-true scores in IZ scoreboards.
#
# Do not hesitate to ask the OF developers for assistance if necessary.

import sys
import os.path
import shutil
import logging
import json
from math import exp

import sqlite3

LOGFILE = 'ogracing.log'
DRY_RUN = False # set to True if testing the script
CAP_SCORES = True # set to False to disable capping scores to the IZ maximum

class EpData:
    max_score = 0
    pod_factor = 0
    max_pods = 0
    max_time = 0
    time_factor = 0
    scale_factor = 0

class RaceResult:
    epid = 0
    playerid = 0
    score = 0
    timestamp = 0
    ring_count = 0
    time = 0

def check_version(cur):
    cur.execute("SELECT Value FROM Meta WHERE Key = 'DatabaseVersion';")
    ver = cur.fetchone()[0]

    if ver < 2:
        sys.exit('fatal: you must first upgrade your DB version to 2 by running the server at least once')

def load_epinfo():
    epinfo = {}
    with open("drops.json", "r") as f:
        dat = json.load(f)["Racing"]
    for key in dat:
        val = dat[key]
        epdata = EpData()
        epid = int(val["EPID"])
        epdata.max_score = int(val["ScoreCap"])
        epdata.pod_factor = float(val["PodFactor"])
        epdata.max_pods = int(val["TotalPods"])
        epdata.max_time = int(val["TimeLimit"])
        epdata.time_factor = float(val["TimeFactor"])
        epdata.scale_factor = float(val["ScaleFactor"])
        epinfo[epid] = epdata
    return epinfo
    

def get_results(cur):
    results = []
    cur.execute('SELECT EPID, PlayerID, Timestamp, RingCount, Time, Score FROM RaceResults;')
    for x in cur.fetchall():
        result = RaceResult()
        result.epid = int(x[0])
        result.playerid = int(x[1])
        result.timestamp = int(x[2])
        result.ring_count = int(x[3])
        result.time = int(x[4])
        result.score = int(x[5])
        results.append(result)
    return results

def process_result(cur, result, epinfo):
    epdata = epinfo[result.epid]
    pod_score = (epdata.pod_factor * result.ring_count) / epdata.max_pods
    time_score = (epdata.time_factor * result.time) / epdata.max_time
    newscore = int(exp(pod_score - time_score + epdata.scale_factor))
    if CAP_SCORES and newscore > epdata.max_score:
        logging.warning('score {} greater than max ({}) for epid {}, capping'.format(newscore, epdata.max_score, result.epid))
        print('warning: score {} greater than max ({}) for epid {}, capping'.format(newscore, epdata.max_score, result.epid))
        newscore = epdata.max_score
    logging.info('* {} -> {} (EPID: {}, pods: {}, time: {})'.format(result.score, newscore, result.epid, result.ring_count, result.time))
    if not DRY_RUN:
        cur.execute('UPDATE RaceResults SET Score = ? WHERE (PlayerID, Timestamp) = (?, ?);', (newscore, result.playerid, result.timestamp))

def main(path):
    if os.path.isfile(LOGFILE):
        sys.exit('fatal: a log file named {} already exists. refusing to modify.'.format(LOGFILE))

    logging.basicConfig(filename=LOGFILE, level=20, format='%(levelname)s: %(message)s')

    if not os.path.isfile(path):
        sys.exit('fatal: {} is not a file'.format(path))

    bakpath = path + '.ogracing.bak'

    if os.path.isfile(bakpath):
        sys.exit('fatal: a DB backup named {} already exists. refusing to overwrite.'.format(bakpath))

    shutil.copy(path, bakpath)
    logging.info('saved database backup to {}'.format(bakpath))
    print('saved database backup to {}'.format(bakpath))

    epinfo = load_epinfo()

    with sqlite3.connect(path) as db:
        cur = db.cursor()

        check_version(cur)

        results = get_results(cur)

        for result in results:
            process_result(cur, result, epinfo)

    logging.info('done.')
    print('done.')

if __name__ == '__main__':
    if len(sys.argv) != 2:
        sys.exit('usage: {} database.db'.format(sys.argv[0]))
    main(sys.argv[1])