#!/usr/bin/env python

# imports ######################################################################
import sqlite3
import sys
import urllib.request
import re

# functions ####################################################################
# extract cookie to jar
def extract_cookies_to_jar(cookie_db):
    try:

        # Connection
        conn = sqlite3.connect(cookie_db)

        # Execute SELECT query
        cur = conn.cursor()
        r = cur.execute("SELECT name, value FROM moz_cookies WHERE host LIKE '%newbiecontest.org%' AND name LIKE '%SMFCookie%'")

        cookie = r.fetchone()

        conn.close()

        return cookie

    except sqlite3.Error as e:
        print("An error occurred:", e.args[0])

# send request using the cookie
def send_resquest(url, cookie):
    opener = urllib.request.build_opener()
    # add cookie to http header
    opener.addheaders.append(('Cookie', cookie[0] + "=" + cookie[1]))

    f = opener.open(url)

    return f

# extract line containing the configs
def extract_config_line(f):

    for line in f:
        if re.findall(r'a un processeur', line.decode("utf-8")):
            return line.decode("utf-8")

    return None

# extract memory prices
def extract_memory_prices(f):
    # create the hashtable
    memory_hashtable = {}

    # for each line
    for line in f:

        # find ram name
        ram_name = re.findall(r'\d+ Mo [DS]DRAM', line.decode("utf-8"))

        # save ram_name
        if ram_name:
            ram_name_cur = ram_name[0]
            continue

        # save ram_price
        ram_price = re.findall(r'<td>(\d+)', line.decode("utf-8"))
        # if ram_price is not None
        if ram_price:
            # add entry to memory_hashtable
            memory_hashtable[ram_name_cur] = ram_price

        # If all the prices are in the hashtable, just return it
        if re.findall(r'Trop chère ;\)', line.decode("utf-8")):
            return memory_hashtable

    return memory_hash_table;

# extract cpu price
def extract_cpu_prices(f):
    # create the cpu_hashtable
    cpu_hashtable = {}

    # for earch line
    for line in f:

        # find cpu name
        cpu_name = re.findall(r'\d+.\d+ [MG]Hz', line.decode("utf-8"))

        # save cpu name to cpu_name_cur
        if cpu_name:
            cpu_name_cur = cpu_name[0]
            continue

        # find price
        cpu_price = re.findall(r'<td>(\d+)', line.decode("utf-8"))
        # if cpu_price is not None
        if cpu_price:
            # add an entry to the hashtable
            cpu_hashtable[cpu_name_cur] = cpu_price

    # return the hashtable
    return cpu_hashtable

# calculate config prices
def config_price_calc(line, memory_hashtable, cpu_hashtable):
    # crete the hashtable containing the configs
    configs = {}
    i = 0

    # extract the config for each people
    config_array = re.findall(r'(\w+) a un processeur de (\d+.\d+ [MG]Hz) et dispose de (\d+ Mo [DS]DRAM)', line)

    # for all the configs, determine the prices
    for item in config_array:
        try:
            config_price = int(memory_hashtable[item[2]][0]) +\
            int(cpu_hashtable[item[1]][0])

            configs[i] = [item[0], config_price]
            i += 1

        except Exception as e:
            raise e

    # return the hashtable
    return configs

# find the most expensive config
def find_most_expensive_config(configs):

    i = 0

    # for all the configs
    for index in configs:

        # init
        if i == 0:
            name = configs[index][0]
            price = configs[index][1]
            id = i

        i += 1

        # if a new max if found
        if price < configs[index][1]:
            # change the max value, to the current value in the loop
            name = configs[index][0]
            price = configs[index][1]
            id = i

    return name, price

def send_response(url, cookie, name, price):
    opener = urllib.request.build_opener()
    opener.addheaders.append(('Cookie', cookie[0] + "=" + cookie[1]))

    f = opener.open(url + "?prenom=" + name + "&prix=" + str(price))

    print(f.read().decode('utf-8')) 

# main #########################################################################
if __name__ == '__main__':

    # if arguments are missing
    if len(sys.argv) != 4:
        print("[i] Usage : cookie.db url_in url_out")
        print("Get. The. Fuck. Out")

    # extract related cookies from db
    cookie = extract_cookies_to_jar(sys.argv[1])

    # send request, get the challenge page
    f = send_resquest(sys.argv[2], cookie)

    line = extract_config_line(f)

    if line == None:
        os.exit(0)

    memory_hashtable = extract_memory_prices(f)

    cpu_hashtable = extract_cpu_prices(f)

    configs = config_price_calc(line, memory_hashtable, cpu_hashtable)

    name, price = find_most_expensive_config(configs)

    send_response(sys.argv[3], cookie, name, price)

    print("Done.")