# import datetime

import psycopg2.extras
import model
import _bs
from pprint import pprint
import time
import database
import sys
# import view
import arrow

if __name__ == '__main__':
    row = -1
    if len(sys.argv) > 1:
        try:
            row = int(sys.argv[1])
        except ValueError:
            sys.exit(1)
    broadcast = True
    send_only_flagged = True  # Note: there is another one in racenet.py
    if len(sys.argv) > 2:
        broadcast = False
    start = time.time()

    db = database.db

    race_days_global = model.scrape_racingaustralia_main_page(row)
    interim = time.time()
    # print('interim 1 {}'.format(interim - start))
    # pprint(race_days_global)
    race_days = []
    raw_data_dict = {}
    for race_day in race_days_global:
        raw_data = model.get_raw_scratchings(race_day)
        race_day_details = model.process_raw_data(raw_data, race_day)
        race_days.append(race_day_details)
        raw_data_dict[race_day.name] = raw_data

    races = model.get_relevant_races_from_database(db)

    scratchings_for_database = []
    messages = []
    full_scratchings = []
    for race_day in race_days:
        if not raw_data_dict or not race_day:
            # raw_data_dict may be empty when there is no data available (yet)
            continue
        raw_data = raw_data_dict[race_day.name]
        scratchings = model.get_scratching_details(raw_data, race_day)
        if not scratchings:
            # model.get_scratchings_details may return empty
            continue
        # retrieve previous stored scratching for this venue / day
        query = "SELECT * FROM horses WHERE venue = %s AND race_date = %s;"
        db.commit()
        cur1 = db.cursor(cursor_factory=psycopg2.extras.NamedTupleCursor)
        cur1.execute(query, (race_day.name, race_day.date))
        db_data_query1 = cur1.fetchall()
        # print(' 54. len(db_data): {}'.format(len(db_data)))
        # print(' 55. type(db_data): {}'.format(type(db_data)))
        # pprint(db_data)
        cur1.close()

        # compare retrieved scratchings with new data
        for scratching in scratchings:
            additional_data = model.get_race_from_races(races, scratching.date, scratching.venue, scratching.race)
            # print('additional_data')
            # pprint(additional_data)
            if len(additional_data) == 0:
                print('len(additional_data) == {}'.format(len(additional_data)))
                pprint(scratching)
                print('continue')
                continue
            full_scratching = _bs.Scratching(scratching.venue, scratching.state, scratching.date, scratching.race,
                                             additional_data[0], additional_data[1], scratching.horse_no,
                                             scratching.horse_display_name, additional_data[2])
            full_scratchings.append(full_scratching)
            continue

    if (arrow.utcnow().minute + 4) % 20 == 0:
        pprint(full_scratchings)
    scratchings_to_be_broadcast = model.store_scratched_horses(db, full_scratchings)
    # print('len(scratchings_to_be_broadcast): {}'.format(len(scratchings_to_be_broadcast)))
    model.send_messages(scratchings_to_be_broadcast, 'RA', start, send_only_flagged)
    db.close()

    interim = time.time()
    if len(scratchings_to_be_broadcast) > 0:
        print('interim 3 {}'.format(interim - start))