import asyncio
import datetime
import logging
from logging.handlers import RotatingFileHandler
import math
import sys

from typing import Literal

import pandas as pd
import pybaseball as pb
from pybaseball import cache
import urllib

from creation_helpers import get_args, CLUB_LIST, FRANCHISE_LIST, sanitize_name
from batters.stat_prep import DataMismatchError
from db_calls import DB_URL, db_get, db_patch, db_post, db_put, db_delete
from exceptions import log_exception, logger
from retrosheet_transformer import load_retrosheet_csv
import batters.calcs_batter as cba
import defenders.calcs_defense as cde
import pitchers.calcs_pitcher as cpi

cache.enable()
# date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
# log_level = logger.INFO
# logger.basicConfig(
#     filename=f'logs/{date}.log',
#     format='%(asctime)s - retrosheet_data - %(levelname)s - %(message)s',
#     level=log_level
# )


RETRO_FILE_PATH = 'data-input/retrosheet/'
EVENTS_FILENAME = 'retrosheets_events_2005.csv'  # Now using transformer for new format compatibility
PERSONNEL_FILENAME = 'retrosheets_personnel.csv'
DATA_INPUT_FILE_PATH = 'data-input/2005 Live Cardset/'
CARD_BASE_URL = f'{DB_URL}/v2/players/'

start_time = datetime.datetime.now()
RELEASE_DIRECTORY = f'{start_time.year}-{start_time.month}-{start_time.day}'
PLAYER_DESCRIPTION = 'Live'         # Live for Live Series
# PLAYER_DESCRIPTION = 'May PotM'   # <Month> PotM for promos
PROMO_INCLUSION_RETRO_IDS = [
    # AL
    # 'rodra001',  # Alex Rodriguez (IF)
    # 'menck001',  # Kevin Mench (OF)
    # 'colob001',  # Bartolo Colon (SP)
    # 'ryanb001',  # BJ Ryan (RP)
    # NL
    # 'delgc001',  # Carlos Delgado (IF)
    # 'abreb001',  # Bobby Abreu (OF)
    # 'haraa001',  # Aaron Harang (SP)
    # 'hofft001',  # Trevor Hoffman (RP)
]
MIN_PA_VL = 20 if 'live' in PLAYER_DESCRIPTION.lower() else 1          # 1 for PotM
MIN_PA_VR = 40 if 'live' in PLAYER_DESCRIPTION.lower() else 1          # 1 for PotM
MIN_TBF_VL = MIN_PA_VL
MIN_TBF_VR = MIN_PA_VR
CARDSET_ID = 27 if 'live' in PLAYER_DESCRIPTION.lower() else 28   # 27: 2005 Live, 28: 2005 Promos

# Per-Update Parameters
SEASON_PCT = 162 / 162  # Full season
START_DATE = 20050301   # YYYYMMDD format
# END_DATE = 20050531     # YYYYMMDD format - May PotM
END_DATE = 20051002     # End of 2005 regular season
POST_DATA = True
LAST_WEEK_RATIO = 0.0 if PLAYER_DESCRIPTION == 'Live' else 0.0
LAST_TWOWEEKS_RATIO = 0.0
LAST_MONTH_RATIO = 0.0

def date_from_int(integer_date: int) -> datetime.datetime:
    return datetime.datetime(int(str(integer_date)[:4]), int(str(integer_date)[4:6]), int(str(integer_date)[-2:]))


def date_math(start_date: int, operator: Literal['+', '-'], day_delta: int = 0, month_delta: int = 0, year_delta: int = 0) -> int:
    if len(str(start_date)) != 8:
        log_exception(ValueError, 'Start date must be 8 digits long')
    if True in [day_delta < 0, month_delta < 0, year_delta < 0]:
        log_exception(ValueError, 'Time deltas must greater than or equal to 0; use `-` operator to go back in time')
    if day_delta > 28:
        log_exception(ValueError, 'Use month_delta for days > 28')
    if month_delta > 12:
        log_exception(ValueError, 'Use year_delta for months > 12')

    s_date = date_from_int(start_date)
    if year_delta > 0:
        s_date = datetime.datetime(
            s_date.year + year_delta if operator == '+' else s_date.year - year_delta,
            s_date.month,
            s_date.day
        )
    if month_delta > 0:
        month_range = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
        new_index = s_date.month + month_delta if operator == '+' else s_date.month - month_delta
        new_month = month_range[(new_index % 12)]

        new_year = s_date.year
        if new_index > 12:
            new_year += 1
        elif new_index < 1:
            new_year -= 1

        s_date = datetime.datetime(
            new_year,
            new_month,
            s_date.day
        )
    fd = s_date + datetime.timedelta(days=day_delta if operator == '+' else day_delta * -1)
    return f'{str(fd.year).zfill(4)}{str(fd.month).zfill(2)}{str(fd.day).zfill(2)}'


def weeks_between(start_date_int: int, end_date_int: int) -> int:
    start_date = date_from_int(start_date_int)
    end_date = date_from_int(end_date_int)
    delta = end_date - start_date
    return abs(round(delta.days / 7))


async def store_defense_to_csv(season: int):
    for position in ['c', '1b', '2b', '3b', 'ss', 'lf', 'cf', 'rf', 'of', 'p']:
        pos_df = cde.get_bbref_fielding_df(position, season)
        pos_df.to_csv(f'{DATA_INPUT_FILE_PATH}defense_{position}.csv')
        await asyncio.sleep(8)


def get_batting_result_series(plays: pd.DataFrame, event_type: str, pitcher_hand: Literal['r', 'l'], col_name: str) -> pd.Series:
    this_series = plays[(plays.event_type == event_type) & (plays.pitcher_hand == pitcher_hand)].groupby('batter_id').count()['event_type'].astype(int).rename(col_name)
    return this_series


def get_pitching_result_series(plays: pd.DataFrame, event_type: str, batter_hand: Literal['r', 'l'], col_name: str) -> pd.Series:
    this_series = plays[(plays.event_type == event_type) & (plays.batter_hand == batter_hand)].groupby('pitcher_id').count()['event_type'].astype(int).rename(col_name)
    return this_series


def get_run_stat_df(input_path: str):
    run_data = pd.read_csv(f'{input_path}running.csv')  #.set_index('Name-additional'))
    # if 'Player' in run_data:
    #     run_data = run_data.rename(columns={'Player': 'Full Name'})
    # if 'Name' in run_data:
    #     run_data = run_data.rename(columns={'Name': 'Full Name'})
    if 'Player-additional' in run_data:
        run_data = run_data.rename(columns={'Player-additional': 'key_bbref'})
    if 'Name-additional' in run_data:
        run_data = run_data.rename(columns={'Name-additional': 'key_bbref'})
    
    run_data = run_data[['key_bbref', 'Tm', 'ROE', 'XI', 'RS%', 'SBO', 'SB', 'CS', 'SB%', 'SB2', 'CS2', 'SB3', 'CS3', 'SBH', 'CSH', 'PO', 'PCS', 'OOB', 'OOB1', 'OOB2', 'OOB3', 'OOBHm', 'BT', 'XBT%', '1stS', '1stS2', '1stS3', '1stD', '1stD3', '1stDH', '2ndS', '2ndS3', '2ndSH']]

    run_data = run_data.fillna(0)
    return run_data.set_index('key_bbref')


def get_periph_stat_df(input_path: str):
    pit_data = pd.read_csv(f'{input_path}pitching.csv')
    if 'Player-additional' in pit_data:
        pit_data = pit_data.rename(columns={'Player-additional': 'key_bbref'})
    if 'Name-additional' in pit_data:
        pit_data = pit_data.rename(columns={'Name-additional': 'key_bbref'})
    if 'Team' in pit_data:
        pit_data = pit_data.rename(columns={'Team': 'Tm'})
    
    pit_data = pit_data[['key_bbref', 'Tm', 'GF', 'SHO', 'SV', 'IP', 'BK', 'WP']]
    
    pit_data = pit_data.fillna(0)
    return pit_data


def get_player_ids(plays: pd.DataFrame, which: Literal['batters', 'pitchers']) -> pd.DataFrame:
    RETRO_PLAYERS = pd.read_csv(f'{RETRO_FILE_PATH}{PERSONNEL_FILENAME}')
    id_key = 'batter_id' if which == 'batters' else 'pitcher_id'

    players = pd.DataFrame()
    unique_players = pd.Series(plays[id_key].unique()).to_frame('id')
    players = pd.merge(
        left=RETRO_PLAYERS,
        right=unique_players,
        how='right',
        left_on='id',
        right_on='id'
    ).rename(columns={'id': id_key})

    if PLAYER_DESCRIPTION not in ['Live', '1998']:
        msg = f'Player description is *{PLAYER_DESCRIPTION}* so dropping players not in PROMO_INCLUSION_RETRO_IDS'
        print(msg)
        logger.info(msg)
        # players = players.drop(players[players.index not in PROMO_INCLUSION_RETRO_IDS].index)
        players = players[players[id_key].isin(PROMO_INCLUSION_RETRO_IDS)]

    def get_pids(row):
        # return get_all_pybaseball_ids([row[id_key]], 'retro', full_name=f'{row["use_name"]} {row["last_name"]}')
        pull = pb.playerid_reverse_lookup([row[id_key]], key_type='retro')
        if len(pull.values) == 0:
            print(f'Could not find id {row[id_key]} in pybaseball lookup')
        return pull.loc[0][['key_mlbam', 'key_retro', 'key_bbref', 'key_fangraphs']]
    
    players = players[[id_key, 'last_name', 'use_name']]
    start_time = datetime.datetime.now()
    other_ids = players.apply(get_pids, axis=1)
    end_time = datetime.datetime.now()
    print(f'ID lookup: {(end_time - start_time).total_seconds():.2f}s')

    def clean_first(row):
        return sanitize_name(row['use_name'])
    def clean_last(row):
        return sanitize_name(row['last_name'])
    
    players['use_name'] = players.apply(clean_first, axis=1)
    players['last_name'] = players.apply(clean_last, axis=1)

    players = pd.merge(
        left=players,
        right=other_ids,
        left_on=id_key,
        right_on='key_retro'
    )
    players = players.set_index(id_key)

    def get_bat_hand(row):
        pa_vl = plays[(plays.batter_id == row['key_retro']) & (plays.pitcher_hand == 'l')].groupby('result_batter_hand').count()['game_id'].astype(int)
        pa_vr = plays[(plays.batter_id == row['key_retro']) & (plays.pitcher_hand == 'r')].groupby('result_batter_hand').count()['game_id'].astype(int)

        l_vs_l = 0 if 'l' not in pa_vl else pa_vl['l']
        l_vs_r = 0 if 'l' not in pa_vr else pa_vr['l']
        r_vs_l = 0 if 'r' not in pa_vl else pa_vl['r']
        r_vs_r = 0 if 'r' not in pa_vr else pa_vr['r']

        # If player ONLY batted from one side (zero PAs from other side), classify as single-handed
        if sum([l_vs_l, l_vs_r]) == 0 and sum([r_vs_l, r_vs_r]) > 0:
            return 'R'
        elif sum([l_vs_l, l_vs_r]) > 0 and sum([r_vs_l, r_vs_r]) == 0:
            return 'L'

        # If player batted from both sides (even if limited sample), they're a switch hitter
        # This correctly identifies switch hitters regardless of total PA count
        if sum([l_vs_l, l_vs_r]) > 0 and sum([r_vs_l, r_vs_r]) > 0:
            return 'S'

        # Fallback for edge cases (shouldn't reach here in normal flow)
        if sum([l_vs_l, l_vs_r]) > sum([r_vs_l, r_vs_r]):
            return 'L'
        else:
            return 'R'
    
    def get_pitch_hand(row):
        first_event = plays.drop_duplicates('pitcher_id').loc[plays.pitcher_id == row['key_retro'], 'pitcher_hand']
        return first_event.item()

    if which == 'batters':
        players['bat_hand'] = players.apply(get_bat_hand, axis=1)
    elif which == 'pitchers':
        players['pitch_hand'] = players.apply(get_pitch_hand, axis=1)

    return players


def get_base_batting_df(file_path: str, start_date: int, end_date: int) -> list[pd.DataFrame, pd.DataFrame]:
    all_plays = load_retrosheet_csv(file_path)
    all_plays['date'] = all_plays['game_id'].str[3:-1].astype(int)
    date_plays = all_plays[(all_plays.date >= start_date) & (all_plays.date <= end_date)]

    all_player_ids = get_player_ids(all_plays, 'batters')

    pal_series = date_plays[(date_plays.batter_event == 't') & (date_plays.pitcher_hand == 'l')].groupby('batter_id').count()['event_type'].astype(int).rename('PA_vL')
    bs = pd.concat([all_player_ids, pal_series], axis=1)

    par_series = date_plays[(date_plays.batter_event == 't') & (date_plays.pitcher_hand == 'r')].groupby('batter_id').count()['event_type'].astype(int).rename('PA_vR')
    bs = pd.concat([bs, par_series], axis=1)

    abl_series = date_plays[(date_plays.ab == 't') & (date_plays.pitcher_hand == 'l')].groupby('batter_id').count()['event_type'].astype(int).rename('AB_vL')
    bs = pd.concat([bs, abl_series], axis=1)

    abr_series = date_plays[(date_plays.ab == 't') & (date_plays.pitcher_hand == 'r')].groupby('batter_id').count()['event_type'].astype(int).rename('AB_vR')
    bs = pd.concat([bs, abr_series], axis=1)

    core_df = bs.dropna().query(f'PA_vL >= {MIN_PA_VL} & PA_vR >= {MIN_PA_VR}')
    if LAST_WEEK_RATIO == 0.0 and LAST_TWOWEEKS_RATIO == 0.0 and LAST_MONTH_RATIO == 0.0:
        return [date_plays, core_df]

    base_num_weeks = weeks_between(start_date, end_date)

    if LAST_WEEK_RATIO > 0:
        new_start = date_math(end_date, '-', day_delta=7)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_WEEK_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)
    
    if LAST_TWOWEEKS_RATIO > 0:
        new_start = date_math(end_date, '-', day_delta=14)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_TWOWEEKS_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)
    
    if LAST_MONTH_RATIO > 0:
        new_start = date_math(end_date, '-', month_delta=1)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_MONTH_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)

    core_df = core_df.drop(columns=['PA_vL', 'PA_vR', 'AB_vL', 'AB_vR'])

    pal_series = date_plays[(date_plays.batter_event == 't') & (date_plays.pitcher_hand == 'l')].groupby('batter_id').count()['event_type'].astype(int).rename('PA_vL')
    core_df['PA_vL'] = pal_series

    par_series = date_plays[(date_plays.batter_event == 't') & (date_plays.pitcher_hand == 'r')].groupby('batter_id').count()['event_type'].astype(int).rename('PA_vR')
    core_df['PA_vR'] = par_series

    abl_series = date_plays[(date_plays.ab == 't') & (date_plays.pitcher_hand == 'l')].groupby('batter_id').count()['event_type'].astype(int).rename('AB_vL')
    core_df['AB_vL'] = abl_series

    abr_series = date_plays[(date_plays.ab == 't') & (date_plays.pitcher_hand == 'r')].groupby('batter_id').count()['event_type'].astype(int).rename('AB_vR')
    core_df['AB_vR'] = abr_series

    return [date_plays, core_df]


def get_base_pitching_df(file_path: str, start_date: int, end_date: int) -> list[pd.DataFrame, pd.DataFrame]:
    all_plays = load_retrosheet_csv(file_path)
    all_plays['date'] = all_plays['game_id'].str[3:-1].astype(int)
    date_plays = all_plays[(all_plays.date >= start_date) & (all_plays.date <= end_date)]

    ps = get_player_ids(all_plays, 'pitchers')

    tbfl_series = date_plays[(date_plays.batter_event == 't') & (date_plays.batter_hand == 'l')].groupby('pitcher_id').count()['event_type'].astype(int).rename('TBF_vL')
    ps = pd.concat([ps, tbfl_series], axis=1)

    tbfr_series = date_plays[(date_plays.batter_event == 't') & (date_plays.batter_hand == 'r')].groupby('pitcher_id').count()['event_type'].astype(int).rename('TBF_vR')
    ps = pd.concat([ps, tbfr_series], axis=1)

    abl_series = date_plays[(date_plays.ab == 't') & (date_plays.batter_hand == 'l')].groupby('pitcher_id').count()['event_type'].astype(int).rename('AB_vL')
    ps = pd.concat([ps, abl_series], axis=1)

    abr_series = date_plays[(date_plays.ab == 't') & (date_plays.batter_hand == 'r')].groupby('pitcher_id').count()['event_type'].astype(int).rename('AB_vR')
    ps = pd.concat([ps, abr_series], axis=1)

    if PLAYER_DESCRIPTION in ['Live', '1998']:
        core_df = ps.dropna().query(f'TBF_vL >= {MIN_TBF_VL} & TBF_vR >= {MIN_TBF_VR}')
    else:
        core_df = ps.dropna()

    if LAST_WEEK_RATIO == 0.0 and LAST_TWOWEEKS_RATIO == 0.0 and LAST_MONTH_RATIO == 0.0:
        return [date_plays, core_df]

    base_num_weeks = weeks_between(start_date, end_date)

    if LAST_WEEK_RATIO > 0:
        new_start = date_math(end_date, '-', day_delta=7)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_WEEK_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)
    
    if LAST_TWOWEEKS_RATIO > 0:
        new_start = date_math(end_date, '-', day_delta=14)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_TWOWEEKS_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)
    
    if LAST_MONTH_RATIO > 0:
        new_start = date_math(end_date, '-', month_delta=1)
        week_plays = date_plays[(date_plays.date >= int(new_start)) & (date_plays.date <= end_date)]
        copies = round(base_num_weeks * LAST_MONTH_RATIO)
        for x in range(copies):
            date_plays = pd.concat([date_plays, week_plays], ignore_index=True)

    core_df = core_df.drop(columns=['TBF_vL', 'TBF_vR', 'AB_vL', 'AB_vR'])

    tbfl_series = date_plays[(date_plays.batter_event == 't') & (date_plays.batter_hand == 'l')].groupby('pitcher_id').count()['event_type'].astype(int).rename('TBF_vL')
    core_df['TBF_vL'] = tbfl_series

    tbfr_series = date_plays[(date_plays.batter_event == 't') & (date_plays.batter_hand == 'r')].groupby('pitcher_id').count()['event_type'].astype(int).rename('TBF_vR')
    core_df['TBF_vR'] = tbfr_series

    abl_series = date_plays[(date_plays.ab == 't') & (date_plays.batter_hand == 'l')].groupby('pitcher_id').count()['event_type'].astype(int).rename('AB_vL')
    core_df['AB_vL'] = abl_series

    abr_series = date_plays[(date_plays.ab == 't') & (date_plays.batter_hand == 'r')].groupby('pitcher_id').count()['event_type'].astype(int).rename('AB_vR')
    core_df['AB_vR'] = abr_series

    return [date_plays, core_df]


def get_med_vL(row):
    high = 0.9 - row['Hard%_vL']
    low = (row['SLG_vL'] - row['AVG_vL']) * 1.5
    return round(max(min(high, low),0.1), 5)
def get_med_vR(row):
    high = 0.9 - row['Hard%_vR']
    low = (row['SLG_vR'] - row['AVG_vR']) * 1.5
    return round(max(min(high, low),0.1), 5)


def get_batting_stats_by_date(retro_file_path, start_date: int, end_date: int) -> pd.DataFrame:
    start = datetime.datetime.now()
    all_plays, batting_stats = get_base_batting_df(retro_file_path, start_date, end_date)    
    print(f'Get base dataframe: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    start = datetime.datetime.now()
    all_player_ids = batting_stats['key_retro']
    logging.info(f'all_player_ids: {all_player_ids}')
    all_plays = all_plays[all_plays['batter_id'].isin(all_player_ids)]
    print(f'Shrink all_plays: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    # Basic counting stats
    start = datetime.datetime.now()
    for event_type, vs_hand, col_name in [
        ('home run', 'r', 'HR_vR'),
        ('home run', 'l', 'HR_vL'),
        ('single', 'r', '1B_vR'),
        ('single', 'l', '1B_vL'),
        ('double', 'r', '2B_vR'),
        ('double', 'l', '2B_vL'),
        ('triple', 'r', '3B_vR'),
        ('triple', 'l', '3B_vL'),
        ('walk', 'r', 'BB_vR'),
        ('walk', 'l', 'BB_vL'),
        ('strikeout', 'r', 'SO_vR'),
        ('strikeout', 'l', 'SO_vL'),
        ('hit by pitch', 'r', 'HBP_vR'),
        ('hit by pitch', 'l', 'HBP_vL')
    ]:
        this_series = get_batting_result_series(all_plays, event_type, vs_hand, col_name)
        batting_stats[col_name] = this_series
    print(f'Count basic stats: {(datetime.datetime.now() - start).total_seconds():.2f}s')
    
    # Bespoke counting stats
    start = datetime.datetime.now()
    def get_fb_vl(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'f') & (all_plays.pitcher_hand == 'l')].count()['event_type'].astype(int)
    def get_fb_vr(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'f') & (all_plays.pitcher_hand == 'r')].count()['event_type'].astype(int)
    
    def get_gb_vl(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'G') & (all_plays.pitcher_hand == 'l')].count()['event_type'].astype(int)
    def get_gb_vr(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'G') & (all_plays.pitcher_hand == 'r')].count()['event_type'].astype(int)
    
    def get_ld_vl(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'l') & (all_plays.pitcher_hand == 'l')].count()['event_type'].astype(int)
    def get_ld_vr(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batted_ball_type == 'l') & (all_plays.pitcher_hand == 'r')].count()['event_type'].astype(int)
    
    def get_gdp_vl(row):
        dp = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batter_event == 't') & (all_plays.pitcher_hand == 'l') & (all_plays.dp == 't')].count()['event_type'].astype(int)
        tp = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batter_event == 't') & (all_plays.pitcher_hand == 'l') & (all_plays.tp == 't')].count()['event_type'].astype(int)
        return dp + tp
    def get_gdp_vr(row):
        dp = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batter_event == 't') & (all_plays.pitcher_hand == 'r') & (all_plays.dp == 't')].count()['event_type'].astype(int)
        tp = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.batter_event == 't') & (all_plays.pitcher_hand == 'r') & (all_plays.tp == 't')].count()['event_type'].astype(int)
        return dp + tp
    
    def get_bunt(row):
        return all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.bunt == 't')].count()['event_type'].astype(int)
    
    batting_stats['FB_vL'] = batting_stats.apply(get_fb_vl, axis=1)
    batting_stats['FB_vR'] = batting_stats.apply(get_fb_vr, axis=1)

    batting_stats['GB_vL'] = batting_stats.apply(get_gb_vl, axis=1)
    batting_stats['GB_vR'] = batting_stats.apply(get_gb_vr, axis=1)

    batting_stats['LD_vL'] = batting_stats.apply(get_ld_vl, axis=1)
    batting_stats['LD_vR'] = batting_stats.apply(get_ld_vr, axis=1)

    batting_stats['GDP_vL'] = batting_stats.apply(get_gdp_vl, axis=1)
    batting_stats['GDP_vR'] = batting_stats.apply(get_gdp_vr, axis=1)

    batting_stats['Bunts'] = batting_stats.apply(get_bunt, axis=1)
    print(f'Custom counting stats: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    # Infield Hit %
    ifh_vl = all_plays[(all_plays.hit_val.str.contains('1|2|3')) & (all_plays.pitcher_hand == 'l') & (all_plays.hit_location.str.contains('1|2|3|4|5|6')) & (~all_plays.hit_location.str.contains('D', na=False))].groupby('batter_id').count()['event_type'].astype(int).rename('ifh_vL')
    ifh_vr = all_plays[(all_plays.hit_val.str.contains('1|2|3')) & (all_plays.pitcher_hand == 'r') & (all_plays.hit_location.str.contains('1|2|3|4|5|6')) & (~all_plays.hit_location.str.contains('D', na=False))].groupby('batter_id').count()['event_type'].astype(int).rename('ifh_vR')
    
    batting_stats['ifh_vL'] = ifh_vl
    batting_stats['ifh_vR'] = ifh_vr

    def get_pull_vl(row):
        pull_loc = '5|7' if row['bat_hand'] != 'L' else '3|9'
        x = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.pitcher_hand == 'l') & (all_plays.hit_location.str.contains(pull_loc))].count()['event_type'].astype(int)
        return x
    def get_pull_vr(row):
        pull_loc = '5|7' if row['bat_hand'] == 'R' else '3|9'
        x = all_plays[(all_plays.batter_id == row['key_retro']) & (all_plays.pitcher_hand == 'r') & (all_plays.hit_location.str.contains(pull_loc))].count()['event_type'].astype(int)
        return x

    # Bespoke Queries
    batting_stats['pull_vL'] = batting_stats.apply(get_pull_vl, axis=1)
    batting_stats['pull_vR'] = batting_stats.apply(get_pull_vr, axis=1)

    center_vl = all_plays[(all_plays.pitcher_hand == 'l') & (all_plays.hit_location.str.contains('1|4|6|8'))].groupby('batter_id').count()['event_type'].astype(int).rename('center_vl')
    center_vr = all_plays[(all_plays.pitcher_hand == 'r') & (all_plays.hit_location.str.contains('1|4|6|8'))].groupby('batter_id').count()['event_type'].astype(int).rename('center_vr')

    batting_stats['center_vL'] = center_vl
    batting_stats['center_vR'] = center_vr

    oppo_vl = all_plays[(all_plays.pitcher_hand == 'l') & (all_plays.hit_location.str.contains('5|7'))].groupby('batter_id').count()['event_type'].astype(int).rename('oppo_vL')
    oppo_vr = all_plays[(all_plays.pitcher_hand == 'r') & (all_plays.hit_location.str.contains('5|7'))].groupby('batter_id').count()['event_type'].astype(int).rename('oppo_vR')

    batting_stats['oppo_vL'] = oppo_vl
    batting_stats['oppo_vR'] = oppo_vr
    
    # fill na to 0 following counting stats
    batting_stats = batting_stats.fillna(0)

    # Calculated Fields
    start = datetime.datetime.now()
    batting_stats['H_vL'] = batting_stats['1B_vL'] + batting_stats['2B_vL'] + batting_stats['3B_vL'] + batting_stats['HR_vL']
    batting_stats['H_vR'] = batting_stats['1B_vR'] + batting_stats['2B_vR'] + batting_stats['3B_vR'] + batting_stats['HR_vR']

    batting_stats['AVG_vL'] = round(batting_stats['H_vL'] / batting_stats['AB_vL'], 5)
    batting_stats['AVG_vR'] = round(batting_stats['H_vR'] / batting_stats['AB_vR'], 5)

    batting_stats['OBP_vL'] = round((batting_stats['H_vL'] + batting_stats['BB_vL'] + batting_stats['HBP_vL']) / batting_stats['PA_vL'], 5)
    batting_stats['OBP_vR'] = round((batting_stats['H_vR'] + batting_stats['BB_vR'] + batting_stats['HBP_vR']) / batting_stats['PA_vR'], 5)

    batting_stats['SLG_vL'] = round((batting_stats['1B_vL'] + batting_stats['2B_vL'] * 2 + batting_stats['3B_vL'] * 3 + batting_stats['HR_vL'] * 4) / batting_stats['AB_vL'], 5)
    batting_stats['SLG_vR'] = round((batting_stats['1B_vR'] + batting_stats['2B_vR'] * 2 + batting_stats['3B_vR'] * 3 + batting_stats['HR_vR'] * 4) / batting_stats['AB_vR'], 5)

    batting_stats['HR/FB_vL'] = round(batting_stats['HR_vL'] / batting_stats['FB_vL'], 5)
    batting_stats['HR/FB_vR'] = round(batting_stats['HR_vR'] / batting_stats['FB_vR'], 5)

    batting_stats['FB%_vL'] = round(batting_stats['FB_vL'] / (batting_stats['FB_vL'] + batting_stats['GB_vL'] + batting_stats['LD_vL']), 5)
    batting_stats['FB%_vR'] = round(batting_stats['FB_vR'] / (batting_stats['FB_vR'] + batting_stats['GB_vR'] + batting_stats['LD_vR']), 5)

    batting_stats['GB%_vL'] = round(batting_stats['GB_vL'] / (batting_stats['FB_vL'] + batting_stats['GB_vL'] + batting_stats['LD_vL']), 5)
    batting_stats['GB%_vR'] = round(batting_stats['GB_vR'] / (batting_stats['FB_vR'] + batting_stats['GB_vR'] + batting_stats['LD_vR']), 5)

    batting_stats['LD%_vL'] = round(batting_stats['LD_vL'] / (batting_stats['FB_vL'] + batting_stats['GB_vL'] + batting_stats['LD_vL']), 5)
    batting_stats['LD%_vR'] = round(batting_stats['LD_vR'] / (batting_stats['FB_vR'] + batting_stats['GB_vR'] + batting_stats['LD_vR']), 5)

    batting_stats['Hard%_vL'] = round(0.2 + batting_stats['SLG_vL'] - batting_stats['AVG_vL'], 5)
    batting_stats['Hard%_vR'] = round(0.2 + batting_stats['SLG_vR'] - batting_stats['AVG_vR'], 5)

    # def get_med_vL(row):
    #     high = 0.9 - row['Hard%_vL']
    #     low = (row['SLG_vL'] - row['AVG_vL']) * 1.5
    #     return round(max(min(high, low),0.1), 5)
    # def get_med_vR(row):
    #     high = 0.9 - row['Hard%_vR']
    #     low = (row['SLG_vR'] - row['AVG_vR']) * 1.5
    #     return round(max(min(high, low),0.1), 5)

    batting_stats['Med%_vL'] = batting_stats.apply(get_med_vL, axis=1)
    batting_stats['Med%_vR'] = batting_stats.apply(get_med_vR, axis=1)

    batting_stats['Soft%_vL'] = round(1 - batting_stats['Hard%_vL'] - batting_stats['Med%_vL'], 5)
    batting_stats['Soft%_vR'] = round(1 - batting_stats['Hard%_vR'] - batting_stats['Med%_vR'], 5)

    batting_stats['IFH%_vL'] = round(batting_stats['ifh_vL'] / batting_stats['H_vL'], 5)
    batting_stats['IFH%_vR'] = round(batting_stats['ifh_vR'] / batting_stats['H_vR'], 5)

    pull_val = round(batting_stats['pull_vL'] / (batting_stats['pull_vL'] + batting_stats['center_vL'] + batting_stats['oppo_vL']), 5)
    batting_stats['Pull%_vL'] = pull_val.clip(0.1, 0.6)
    pull_val = round(batting_stats['pull_vR'] / (batting_stats['pull_vR'] + batting_stats['center_vR'] + batting_stats['oppo_vR']), 5)
    batting_stats['Pull%_vR'] = pull_val.clip(0.1, 0.6)

    cent_val = round(batting_stats['center_vL'] / (batting_stats['pull_vL'] + batting_stats['center_vL'] + batting_stats['oppo_vL']), 5)
    batting_stats['Cent%_vL'] = cent_val.clip(0.1, 0.6)
    cent_val = round(batting_stats['center_vL'] / (batting_stats['pull_vR'] + batting_stats['center_vR'] + batting_stats['oppo_vR']), 5)
    batting_stats['Cent%_vR'] = cent_val.clip(0.1, 0.6)

    batting_stats['Oppo%_vL'] = round(1 - batting_stats['Pull%_vL'] - batting_stats['Cent%_vL'], 5)
    batting_stats['Oppo%_vR'] = round(1 - batting_stats['Pull%_vR'] - batting_stats['Cent%_vR'], 5)

    batting_stats = batting_stats.fillna(0)

    print(f'Calculated fields: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    return batting_stats


def get_pitching_stats_by_date(retro_file_path, start_date: int, end_date: int) -> pd.DataFrame:
    start = datetime.datetime.now()
    all_plays, pitching_stats = get_base_pitching_df(retro_file_path, start_date, end_date)    
    print(f'Get base dataframe: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    start = datetime.datetime.now()
    all_player_ids = pitching_stats['key_retro']
    all_plays = all_plays[all_plays['pitcher_id'].isin(all_player_ids)]
    print(f'Shrink all_plays: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    # Basic counting stats
    start = datetime.datetime.now()
    for event_type, vs_hand, col_name in [
        ('home run', 'r', 'HR_vR'),
        ('home run', 'l', 'HR_vL'),
        ('single', 'r', '1B_vR'),
        ('single', 'l', '1B_vL'),
        ('double', 'r', '2B_vR'),
        ('double', 'l', '2B_vL'),
        ('triple', 'r', '3B_vR'),
        ('triple', 'l', '3B_vL'),
        ('walk', 'r', 'BB_vR'),
        ('walk', 'l', 'BB_vL'),
        ('strikeout', 'r', 'SO_vR'),
        ('strikeout', 'l', 'SO_vL'),
        ('hit by pitch', 'r', 'HBP_vR'),
        ('hit by pitch', 'l', 'HBP_vL'),
        ('intentional walk', 'l', 'IBB_vL'),
        ('intentional walk', 'r', 'IBB_vR')
    ]:
        this_series = get_pitching_result_series(all_plays, event_type, vs_hand, col_name)
        pitching_stats[col_name] = this_series
    print(f'Count basic stats: {(datetime.datetime.now() - start).total_seconds():.2f}s')
    pitching_stats = pitching_stats.fillna(0)
    
    # Bespoke counting stats
    start = datetime.datetime.now()
    def get_fb_vl(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'f') & (all_plays.batter_hand == 'l')].count()['event_type'].astype(int)
    def get_fb_vr(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'f') & (all_plays.batter_hand == 'r')].count()['event_type'].astype(int)
    
    def get_gb_vl(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'G') & (all_plays.batter_hand == 'l')].count()['event_type'].astype(int)
    def get_gb_vr(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'G') & (all_plays.batter_hand == 'r')].count()['event_type'].astype(int)
    
    def get_ld_vl(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'l') & (all_plays.pitcher_hand == 'l')].count()['event_type'].astype(int)
    def get_ld_vr(row):
        return all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batted_ball_type == 'l') & (all_plays.pitcher_hand == 'r')].count()['event_type'].astype(int)
    
    pitching_stats['FB_vL'] = pitching_stats.apply(get_fb_vl, axis=1)
    pitching_stats['FB_vR'] = pitching_stats.apply(get_fb_vr, axis=1)

    pitching_stats['GB_vL'] = pitching_stats.apply(get_gb_vl, axis=1)
    pitching_stats['GB_vR'] = pitching_stats.apply(get_gb_vr, axis=1)

    pitching_stats['LD_vL'] = pitching_stats.apply(get_ld_vl, axis=1)
    pitching_stats['LD_vR'] = pitching_stats.apply(get_ld_vr, axis=1)

    pitching_stats['H_vL'] = pitching_stats['1B_vL'] + pitching_stats['2B_vL'] + pitching_stats['3B_vL'] + pitching_stats['HR_vL']
    pitching_stats['H_vR'] = pitching_stats['1B_vR'] + pitching_stats['2B_vR'] + pitching_stats['3B_vR'] + pitching_stats['HR_vR']

    print(f'Custom counting stats: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    # Calculated Fields
    """
    Oppo%_vL & R
    """
    start = datetime.datetime.now()
    pitching_stats['AVG_vL'] = round(pitching_stats['H_vL'] / pitching_stats['AB_vL'], 5)
    pitching_stats['AVG_vR'] = round(pitching_stats['H_vR'] / pitching_stats['AB_vR'], 5)

    pitching_stats['OBP_vL'] = round((pitching_stats['H_vL'] + pitching_stats['BB_vL'] + pitching_stats['HBP_vL'] + pitching_stats['IBB_vL']) / pitching_stats['TBF_vL'], 5)
    pitching_stats['OBP_vR'] = round((pitching_stats['H_vR'] + pitching_stats['BB_vR'] + pitching_stats['HBP_vR'] + pitching_stats['IBB_vR']) / pitching_stats['TBF_vR'], 5)

    pitching_stats['SLG_vL'] = round((pitching_stats['1B_vL'] + pitching_stats['2B_vL'] * 2 + pitching_stats['3B_vL'] * 3 + pitching_stats['HR_vL'] * 4) / pitching_stats['AB_vL'], 5)
    pitching_stats['SLG_vR'] = round((pitching_stats['1B_vR'] + pitching_stats['2B_vR'] * 2 + pitching_stats['3B_vR'] * 3 + pitching_stats['HR_vR'] * 4) / pitching_stats['AB_vR'], 5)

    pitching_stats['HR/FB_vL'] = round(pitching_stats['HR_vL'] / pitching_stats['FB_vL'], 5)
    pitching_stats['HR/FB_vR'] = round(pitching_stats['HR_vR'] / pitching_stats['FB_vR'], 5)

    pitching_stats['Hard%_vL'] = round(0.2 + pitching_stats['SLG_vL'] - pitching_stats['AVG_vL'], 5)
    pitching_stats['Hard%_vR'] = round(0.2 + pitching_stats['SLG_vR'] - pitching_stats['AVG_vR'], 5)

    pitching_stats['Med%_vL'] = pitching_stats.apply(get_med_vL, axis=1)
    pitching_stats['Med%_vR'] = pitching_stats.apply(get_med_vR, axis=1)

    pitching_stats['Soft%_vL'] = round(1 - pitching_stats['Hard%_vL'] - pitching_stats['Med%_vL'], 5)
    pitching_stats['Soft%_vR'] = round(1 - pitching_stats['Hard%_vR'] - pitching_stats['Med%_vR'], 5)

    pitching_stats['FB%_vL'] = round(pitching_stats['FB_vL'] / (pitching_stats['FB_vL'] + pitching_stats['GB_vL'] + pitching_stats['LD_vL']), 5)
    pitching_stats['FB%_vR'] = round(pitching_stats['FB_vR'] / (pitching_stats['FB_vR'] + pitching_stats['GB_vR'] + pitching_stats['LD_vR']), 5)

    pitching_stats['GB%_vL'] = round(pitching_stats['GB_vL'] / (pitching_stats['FB_vL'] + pitching_stats['GB_vL'] + pitching_stats['LD_vL']), 5)
    pitching_stats['GB%_vR'] = round(pitching_stats['GB_vR'] / (pitching_stats['FB_vR'] + pitching_stats['GB_vR'] + pitching_stats['LD_vR']), 5)

    def get_oppo_vl(row):
        count = all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batter_hand == 'l') & (all_plays.hit_location.str.contains('5|7'))].count()['event_type'].astype(int)
        denom = all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batter_hand == 'l') & (all_plays.batter_event == 't')].count()['event_type'].astype(int)
        return round(count / denom, 5)
    def get_oppo_vr(row):
        count = all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batter_hand == 'r') & (all_plays.hit_location.str.contains('3|9'))].count()['event_type'].astype(int)
        denom = all_plays[(all_plays.pitcher_id == row['key_retro']) & (all_plays.batter_hand == 'r') & (all_plays.batter_event == 't')].count()['event_type'].astype(int)
        return round(count / denom, 5)

    pitching_stats['Oppo%_vL'] = pitching_stats.apply(get_oppo_vl, axis=1)
    pitching_stats['Oppo%_vR'] = pitching_stats.apply(get_oppo_vr, axis=1)

    pitching_stats = pitching_stats.fillna(0)

    print(f'Calculated fields: {(datetime.datetime.now() - start).total_seconds():.2f}s')

    return pitching_stats


def calc_batting_cards(bs: pd.DataFrame, season_pct: float) -> pd.DataFrame:
    def create_batting_card(row):
        steal_data = cba.stealing(
            chances=int(row['SBO']),
            sb2s=int(row['SB2']),
            cs2s=int(row['CS2']),
            sb3s=int(row['SB3']),
            cs3s=int(row['CS3']),
            season_pct=1.0
        )
        y = pd.DataFrame({
            'key_bbref': [row['key_bbref']],
            'steal_low': [steal_data[0]],
            'steal_high': [steal_data[1]],
            'steal_auto': [steal_data[2]],
            'steal_jump': [steal_data[3]],
            'hit_and_run': [cba.hit_and_run(
                row['AB_vL'], row['AB_vR'], row['H_vL'], row['H_vR'],
                row['HR_vL'], row['HR_vR'], row['SO_vL'], row['SO_vR']
            )],
            'bunt': [cba.bunting(row['Bunts'], season_pct)],
            'running': [cba.running(row['XBT%'])],
            'hand': [row['bat_hand']],
        })
        return y.loc[0]

    all_cards = bs.apply(create_batting_card, axis=1)
    all_cards = all_cards.set_index('key_bbref')

    return all_cards


def calc_pitching_cards(ps: pd.DataFrame, season_pct: float) -> pd.DataFrame:
    def create_pitching_card(row):
        pow_data = cde.pow_ratings(row['IP'], row['GS'], row['G'])
        y = pd.DataFrame({
            "key_bbref": [row['key_bbref']],
            "balk": [cpi.balks(row['BK'], row['IP'], season_pct)],
            "wild_pitch": [cpi.wild_pitches(row['WP'], row['IP'], season_pct)],
            "hold": [cde.hold_pitcher(str(row['caught_stealing_perc']), int(row['pickoffs']), season_pct)],
            "starter_rating": [pow_data[0]],
            "relief_rating": [pow_data[1]],
            "closer_rating": [cpi.closer_rating(int(row['GF']), int(row['SV']), int(row['G']))],
            "batting": [f'#1W{row["pitch_hand"].upper()}-C']
        })
        return y.loc[0]
    
    all_cards = ps.apply(create_pitching_card, axis=1)
    all_cards = all_cards.set_index('key_bbref')

    return all_cards


def calc_batter_ratings(bs: pd.DataFrame) -> pd.DataFrame:
    def create_batting_rating(row):
        if row['key_bbref'] == 'galaran01':
            pass
        ratings = cba.get_batter_ratings(row)
        ops_vl = ratings[0]['obp'] + ratings[0]['slg']
        ops_vr = ratings[1]['obp'] + ratings[1]['slg']
        total_ops = (ops_vl + ops_vr + min(ops_vr, ops_vl)) / 3
        
        def calc_cost(total_ops, base_cost, base_ops, max_delta) -> int:
            delta = ((total_ops - base_ops) / 0.1) * 2
            if delta < 1:
                delta = (max_delta * (1 - (total_ops / base_ops))) * -0.1
            
            final_cost = base_cost + (max_delta * delta)

            return round(final_cost)
        
        if total_ops >= 1.2:
            rarity_id = 99
            cost = calc_cost(total_ops, base_cost=2400, base_ops=1.215, max_delta=810)
        elif total_ops >= 1:
            rarity_id = 1
            cost = calc_cost(total_ops, base_cost=810, base_ops=1.05, max_delta=270)
        elif total_ops >= 0.9:
            rarity_id = 2
            cost = calc_cost(total_ops, base_cost=270, base_ops=0.95, max_delta=90)
        elif total_ops >= 0.8:
            rarity_id = 3
            cost = calc_cost(total_ops, base_cost=90, base_ops=0.85, max_delta=30)
        elif total_ops >= 0.7:
            rarity_id = 4
            cost = calc_cost(total_ops, base_cost=30, base_ops=0.75, max_delta=10)
        else:
            rarity_id = 5
            cost = calc_cost(total_ops, base_cost=10, base_ops=0.61, max_delta=8)

        x = pd.DataFrame({
            'key_bbref': [row['key_bbref']],
            'ratings_vL': [ratings[0]],
            'ratings_vR': [ratings[1]],
            'ops_vL': ops_vl,
            'ops_vR': ops_vr,
            'total_ops': total_ops,
            'rarity_id': rarity_id,
            'cost': cost
        })
        return x.loc[0]

    all_ratings = bs.apply(create_batting_rating, axis=1)
    all_ratings = all_ratings.set_index('key_bbref')

    return all_ratings


def calc_pitcher_ratings(ps: pd.DataFrame) -> pd.DataFrame:
    def create_pitching_rating(row):
        row['pitchingcard_id'] = row['key_fangraphs']
        row['pitch_hand'] = row['pitch_hand'].upper()
        ratings = cpi.get_pitcher_ratings(row)
        ops_vl = ratings[0]['obp'] + ratings[0]['slg']
        ops_vr = ratings[1]['obp'] + ratings[1]['slg']
        total_ops = (ops_vl + ops_vr + min(ops_vr, ops_vl)) / 3

        def calc_cost(total_ops, base_cost, base_ops, max_delta) -> int:
            delta = ((base_ops - total_ops) / 0.1) * 2
            if delta < -0.9:
                delta = -0.95

            final_cost = base_cost + (max_delta * delta)

            return round(final_cost)
        
        if row['starter_rating'] > 3:
            if total_ops <= 0.4:
                rarity_id = 99
                cost = calc_cost(total_ops, 2400, 0.38, 810)
            elif total_ops <= 0.475:
                rarity_id = 1
                cost = calc_cost(total_ops, 810, 0.44, 270)
            elif total_ops <= 0.53:
                rarity_id = 2
                cost = calc_cost(total_ops, 270, 0.51, 90)
            elif total_ops <= 0.6:
                rarity_id = 3
                cost = calc_cost(total_ops, 90, 0.575, 30)
            elif total_ops <= 0.675:
                rarity_id = 4
                cost = calc_cost(total_ops, 30, 0.64, 10)
            else:
                rarity_id = 5
                cost = calc_cost(total_ops, 10, 0.7, 8)
        else:
            if total_ops <= 0.325:
                rarity_id = 99
                cost = calc_cost(total_ops, 2400, 0.38, 810)
            elif total_ops <= 0.4:
                rarity_id = 1
                cost = calc_cost(total_ops, 810, 0.44, 270)
            elif total_ops <= 0.475:
                rarity_id = 2
                cost = calc_cost(total_ops, 270, 0.51, 90)
            elif total_ops <= 0.55:
                rarity_id = 3
                cost = calc_cost(total_ops, 90, 0.575, 30)
            elif total_ops <= 0.625:
                rarity_id = 4
                cost = calc_cost(total_ops, 30, 0.64, 10)
            else:
                rarity_id = 5
                cost = calc_cost(total_ops, 10, 0.7, 8)
    
        x = pd.DataFrame({
            'key_bbref': [row['key_bbref']],
            'ratings_vL': [ratings[0]],
            'ratings_vR': [ratings[1]],
            'ops_vL': ops_vl,
            'ops_vR': ops_vr,
            'total_ops': total_ops,
            'rarity_id': rarity_id,
            'cost': cost
        })
        return x.loc[0]

    all_ratings = ps.apply(create_pitching_rating, axis=1)
    all_ratings = all_ratings.set_index('key_bbref')

    return all_ratings


def calc_positions(bs: pd.DataFrame) -> pd.DataFrame:
    df_c = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_c.csv').set_index('key_bbref')
    df_1b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_1b.csv').set_index('key_bbref')
    df_2b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_2b.csv').set_index('key_bbref')
    df_3b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_3b.csv').set_index('key_bbref')
    df_ss = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_ss.csv').set_index('key_bbref')
    df_lf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_lf.csv').set_index('key_bbref')
    df_cf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_cf.csv').set_index('key_bbref')
    df_rf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_rf.csv').set_index('key_bbref')
    df_of = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_of.csv').set_index('key_bbref')
    season_pct = 1.0

    all_pos = []

    def process_pos(row):
        no_data = True
        for pos_df, position in [(df_1b, '1b'), (df_2b, '2b'), (df_3b, '3b'), (df_ss, 'ss')]:
            if row['key_bbref'] in pos_df.index:
                logger.info(f'Running {position} stats for {row["use_name"]} {row["last_name"]}')
                try:
                    if 'bis_runs_total' in pos_df.columns:
                        average_range = (int(pos_df.at[row["key_bbref"], 'tz_runs_total']) +
                                        int(pos_df.at[row["key_bbref"], 'bis_runs_total']) +
                                        min(
                                            int(pos_df.at[row["key_bbref"], 'tz_runs_total']),
                                            int(pos_df.at[row["key_bbref"], 'bis_runs_total'])
                                        )) / 3
                    else:
                        average_range = pos_df.at[row["key_bbref"], 'tz_runs_total']

                    if float(pos_df.at[row["key_bbref"], 'Inn_def']) >= 10.0:
                        all_pos.append({
                            "key_bbref": row['key_bbref'],
                            "position": position.upper(),
                            "innings": float(pos_df.at[row["key_bbref"], 'Inn_def']),
                            "range": cde.get_if_range(
                                pos_code=position,
                                tz_runs=round(average_range),
                                r_dp=0,
                                season_pct=season_pct
                            ),
                            "error": cde.get_any_error(
                                pos_code=position,
                                errors=int(pos_df.at[row["key_bbref"], 'E_def']),
                                chances=int(pos_df.at[row["key_bbref"], 'chances']),
                                season_pct=season_pct
                            )
                        })
                        no_data = False
                except Exception as e:
                    logger.info(f'Infield position failed: {e}')

        of_arms = []
        of_payloads = []
        for pos_df, position in [(df_lf, 'lf'), (df_cf, 'cf'), (df_rf, 'rf')]:
            if row["key_bbref"] in pos_df.index:
                try:
                    if 'bis_runs_total' in pos_df.columns:
                        average_range = (int(pos_df.at[row["key_bbref"], 'tz_runs_total']) +
                                        int(pos_df.at[row["key_bbref"], 'bis_runs_total']) +
                                        min(
                                            int(pos_df.at[row["key_bbref"], 'tz_runs_total']),
                                            int(pos_df.at[row["key_bbref"], 'bis_runs_total'])
                                        )) / 3
                    else:
                        average_range = pos_df.at[row["key_bbref"], 'tz_runs_total']
                    
                    if float(pos_df.at[row["key_bbref"], 'Inn_def']) >= 10.0:
                        of_payloads.append({
                            "key_bbref": row['key_bbref'],
                            "position": position.upper(),
                            "innings": float(pos_df.at[row["key_bbref"], 'Inn_def']),
                            "range": cde.get_of_range(
                                pos_code=position,
                                tz_runs=round(average_range),
                                season_pct=season_pct
                            )
                        })
                        of_run_rating = 'bis_runs_outfield' if 'bis_runs_outfield' in pos_df.columns else 'tz_runs_total'
                        of_arms.append(int(pos_df.at[row["key_bbref"], of_run_rating]))
                        no_data = False
                except Exception as e:
                    logger.info(f'Outfield position failed: {e}')

        if row["key_bbref"] in df_of.index and len(of_arms) > 0 and len(of_payloads) > 0:
            try:
                error_rating = cde.get_any_error(
                    pos_code=position,
                    errors=int(df_of.at[row["key_bbref"], 'E_def']),
                    chances=int(df_of.at[row["key_bbref"], 'chances']),
                    season_pct=season_pct
                )
                arm_rating = cde.arm_outfield(of_arms)
                for f in of_payloads:
                    f['error'] = error_rating
                    f['arm'] = arm_rating
                    all_pos.append(f)
                no_data = False
            except Exception as e:
                logger.info(f'Outfield position failed: {e}')

        if row["key_bbref"] in df_c.index:
            try:
                run_rating = 'bis_runs_catcher_sb' if 'bis_runs_catcher_sb' in df_c else 'tz_runs_catcher'
                
                if df_c.at[row["key_bbref"], 'SB'] + df_c.at[row["key_bbref"], 'CS'] == 0:
                    arm_rating = 3
                else:
                    arm_rating = cde.arm_catcher(
                        cs_pct=df_c.at[row["key_bbref"], 'caught_stealing_perc'],
                        raa=int(df_c.at[row["key_bbref"], run_rating]),
                        season_pct=season_pct
                    )

                if float(df_c.at[row["key_bbref"], 'Inn_def']) >= 10.0:
                    all_pos.append({
                        "key_bbref": row['key_bbref'],
                        "position": 'C',
                        "innings": float(df_c.at[row["key_bbref"], 'Inn_def']),
                        "range": cde.range_catcher(
                            rs_value=int(df_c.at[row["key_bbref"], 'tz_runs_catcher']),
                            season_pct=season_pct
                        ),
                        "error": cde.get_any_error(
                            pos_code='c',
                            errors=int(df_c.at[row["key_bbref"], 'E_def']),
                            chances=int(df_c.at[row["key_bbref"], 'chances']),
                            season_pct=season_pct
                        ),
                        "arm": arm_rating,
                        "pb": cde.pb_catcher(
                            pb=int(df_c.at[row["key_bbref"], 'PB']),
                            innings=int(float(df_c.at[row["key_bbref"], 'Inn_def'])),
                            season_pct=season_pct
                        ),
                        "overthrow": cde.ot_catcher(
                            errors=int(df_c.at[row["key_bbref"], 'E_def']),
                            chances=int(df_c.at[row["key_bbref"], 'chances']),
                            season_pct=season_pct
                        )
                    })
                    no_data = False
            except Exception as e:
                logger.info(f'Catcher position failed: {e}')

        if no_data:
            all_pos.append({
                "key_bbref": row['key_bbref'],
                "position": 'DH',
                "innings": row['PA_vL'] + row['PA_vR']
            })

    bs.apply(process_pos, axis=1)
    pos_df = pd.DataFrame(all_pos)
    pos_df = pos_df.set_index('key_bbref')

    return pos_df


def calc_pitcher_defense(ps: pd.DataFrame) -> pd.DataFrame:
    df_p = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_p.csv').set_index('key_bbref')

    all_pos = []

    def process_def(row):
        if 'bis_runs_total' in df_p:
            range_val = cde.range_pitcher(rs_value=int(df_p.at[row['key_bbref'], 'bis_runs_total']))
        else: 
            range_val = cde.range_pitcher(rf_per9_value=df_p.at[row['key_bbref'], 'range_factor_per_nine'])

        if row['key_bbref'] in df_p.index:
            all_pos.append({
                'key_bbref': row['key_bbref'],
                'position': 'P',
                'innings': float(df_p.at[row['key_bbref'], 'Inn_def']),
                'range': range_val,
                'error': cde.get_any_error(
                    pos_code='p',
                    errors=int(df_p.at[row["key_bbref"], 'E_def']),
                    chances=int(df_p.at[row["key_bbref"], 'chances']),
                    season_pct=1.0
                )
            })
        else:
            all_pos.append({
                "key_bbref": int(row['key_bbref']),
                "position": 'P',
                "innings": 1,
                "range": 5,
                "error": 51
            })

    ps.apply(process_def, axis=1)
    pos_df = pd.DataFrame(all_pos)
    pos_df = pos_df.set_index('key_bbref')

    return pos_df


async def get_or_post_players(bstat_df: pd.DataFrame = None, bat_rat_df: pd.DataFrame = None, def_rat_df: pd.DataFrame = None, pstat_df: pd.DataFrame = None, pit_rat_df: pd.DataFrame = None) -> pd.DataFrame:
    all_players = []
    player_deltas = [['player_id', 'player_name', 'old-cost', 'new-cost', 'old-rarity', 'new-rarity']]
    new_players = [['player_id', 'player_name', 'cost', 'rarity', 'pos1']]

    async def player_search(bbref_id: str):
        p_query = await db_get('players', params=[('bbref_id', bbref_id), ('cardset_id', CARDSET_ID)])
        if p_query['count'] > 0:
            return p_query['players'][0]
        else:
            return None
    
    async def mlb_search_or_post(retro_id: int):
        mlb_query = await db_get('mlbplayers', params=[('key_retro', retro_id)])
        if mlb_query['count'] > 0:
            return mlb_query['players'][0]
        else:
            mlb_player = await db_post(
                'mlbplayers/one',
                payload={
                    'first_name': row['use_name'],
                    'last_name': row['last_name'],
                    'key_mlbam': row['key_mlbam'],
                    'key_fangraphs': row['key_fangraphs'],
                    'key_bbref': row['key_bbref'],
                    'key_retro': row['key_retro']
                }
            )
            return mlb_player

    def new_player_payload(row, ratings_df: pd.DataFrame):
        return {
            'p_name': f'{row["use_name"]} {row["last_name"]}',
            'cost': f'{ratings_df.loc[row['key_bbref']]["cost"]}',
            'image': f'change-me',
            'mlbclub': CLUB_LIST[row['Tm']],
            'franchise': FRANCHISE_LIST[row['Tm']],
            'cardset_id': CARDSET_ID,
            'set_num': int(float(row['key_fangraphs'])),
            'rarity_id': int(ratings_df.loc[row['key_bbref']]['rarity_id']),
            'description': PLAYER_DESCRIPTION,
            'bbref_id': row['key_bbref'],
            'fangr_id': int(float(row['key_fangraphs'])),
            'mlbplayer_id': mlb_player['id']
        }

    def get_player_record_pos(def_rat_df: pd.DataFrame, row) -> list[str]:
        all_pos = [None, None, None, None, None, None, None, None]
        try:
            count = 0
            all_pos_df = def_rat_df.loc[row['key_bbref']].sort_values(by='innings', ascending=False)
            for index, pos_row in all_pos_df.iterrows():
                all_pos[count] = pos_row.position
                count += 1
        except KeyError:
            logger.info(f'No positions found for {row['use_name']} {row['last_name']}')
            all_pos[0] = 'DH'
        except TypeError:
            logger.info(f'Only one position found for {row['use_name']} {row['last_name']}')
            all_pos[0] = def_rat_df.loc[row['key_bbref']].position  
            
        return all_pos

    dev_count = 0
    if bstat_df is not None and bat_rat_df is not None and def_rat_df is not None:
        for index, row in bstat_df.iterrows():
            if dev_count < 0:
                break

            p_search = await player_search(row['key_bbref'])
            if p_search is not None:
                if 'id' in p_search:
                    player_id = p_search['id']
                else:
                    player_id = p_search['player_id']

                # Update positions for existing players too
                all_pos = get_player_record_pos(def_rat_df, row)
                patch_params = [
                    ('cost', f'{bat_rat_df.loc[row['key_bbref']]["cost"]}'),
                    ('rarity_id', int(bat_rat_df.loc[row['key_bbref']]['rarity_id'])),
                    ('image', f'{CARD_BASE_URL}{player_id}/battingcard{urllib.parse.quote("?d=")}{RELEASE_DIRECTORY}')
                ]
                # Add position updates - set all 8 slots to clear any old positions
                for x in enumerate(all_pos):
                    patch_params.append((f'pos_{x[0] + 1}', x[1]))

                new_player = await db_patch('players', object_id=player_id, params=patch_params)
                new_player['bbref_id'] = row['key_bbref']
                all_players.append(new_player)
                player_deltas.append([
                    new_player['player_id'], new_player['p_name'], p_search['cost'], new_player['cost'], p_search['rarity']['name'], new_player['rarity']['name']
                ])
            else:
                mlb_player = await mlb_search_or_post(row['key_retro'])
                
                player_payload = new_player_payload(row, bat_rat_df)
                
                all_pos = get_player_record_pos(def_rat_df, row)    
                for x in enumerate(all_pos):
                    player_payload[f'pos_{x[0] + 1}'] = x[1]

                new_player = await db_post('players', payload=player_payload)

                if 'id' in new_player:
                    player_id = new_player['id']
                else:
                    player_id = new_player['player_id']

                new_player = await db_patch('players', object_id=player_id, params=[('image', f'{CARD_BASE_URL}{player_id}/battingcard{urllib.parse.quote("?d=")}{RELEASE_DIRECTORY}')])
                if 'paperdex' in new_player:
                    del new_player['paperdex']

                # all_bbref_ids.append(row['key_bbref'])
                # all_player_ids.append(player_id)
                new_player['bbref_id'] = row['key_bbref']
                all_players.append(new_player)
                new_players.append([new_player['player_id'], new_player['p_name'], new_player['cost'], new_player['rarity']['name'], new_player['pos_1']])

            dev_count += 1
    elif pstat_df is not None and pit_rat_df is not None and def_rat_df is not None:
        starter_index = pstat_df.columns.get_loc('starter_rating')
        closer_index = pstat_df.columns.get_loc('closer_rating')

        for index, row in pstat_df.iterrows():
            if dev_count < 0:
                break

            p_search = await player_search(row['key_bbref'])
            if p_search is not None:
                if 'id' in p_search:
                    player_id = p_search['id']
                else:
                    player_id = p_search['player_id']

                # Determine pitcher positions based on ratings
                patch_params = [
                    ('cost', f'{pit_rat_df.loc[row['key_bbref']]["cost"]}'),
                    ('rarity_id', int(pit_rat_df.loc[row['key_bbref']]['rarity_id'])),
                    ('image', f'{CARD_BASE_URL}{player_id}/pitchingcard{urllib.parse.quote("?d=")}{RELEASE_DIRECTORY}')
                ]

                player_index = pstat_df.index[pstat_df['key_bbref'] == row['key_bbref']].tolist()
                stat_row = pstat_df.iloc[player_index]
                starter_rating = stat_row.iat[0, starter_index]

                if starter_rating >= 4:
                    patch_params.append(('pos_1', 'SP'))
                    # Clear other position slots
                    for i in range(2, 9):
                        patch_params.append((f'pos_{i}', None))
                else:
                    patch_params.append(('pos_1', 'RP'))
                    closer_rating = stat_row.iat[0, closer_index]
                    if not pd.isna(closer_rating):
                        patch_params.append(('pos_2', 'CP'))
                        # Clear remaining position slots
                        for i in range(3, 9):
                            patch_params.append((f'pos_{i}', None))
                    else:
                        # Clear remaining position slots
                        for i in range(2, 9):
                            patch_params.append((f'pos_{i}', None))

                new_player = await db_patch('players', object_id=player_id, params=patch_params)
                new_player['bbref_id'] = row['key_bbref']
                all_players.append(new_player)
                player_deltas.append([
                    new_player['player_id'], new_player['p_name'], p_search['cost'], new_player['cost'], p_search['rarity']['name'], new_player['rarity']['name']
                ])
            else:
                mlb_player = await mlb_search_or_post(row['key_retro'])
                
                player_payload = new_player_payload(row, pit_rat_df)
                player_index = pstat_df.index[pstat_df['key_bbref'] == row['key_bbref']].tolist()
                stat_row = pstat_df.iloc[player_index]
                
                starter_rating = stat_row.iat[0, starter_index]
                if starter_rating >= 4:
                    player_payload['pos_1'] = 'SP'
                else:
                    player_payload['pos_1'] = 'RP'
                    closer_rating = stat_row.iat[0, closer_index]
                    if not pd.isna(closer_rating):
                        player_payload['pos_2'] = 'CP'

                new_player = await db_post('players', payload=player_payload)

                if 'id' in new_player:
                    player_id = new_player['id']
                else:
                    player_id = new_player['player_id']

                new_player = await db_patch('players', object_id=player_id, params=[('image', f'{CARD_BASE_URL}{player_id}/pitchingcard{urllib.parse.quote("?d=")}{RELEASE_DIRECTORY}')])
                if 'paperdex' in new_player:
                    del new_player['paperdex']

                new_player['bbref_id'] = row['key_bbref']
                all_players.append(new_player)
                new_players.append([new_player['player_id'], new_player['p_name'], new_player['cost'], new_player['rarity']['name'], new_player['pos_1']])
            
            dev_count += 1
    else:
        raise KeyError(f'Could not get players - not enough stat DFs were supplied')

    pd.DataFrame(player_deltas[1:], columns=player_deltas[0]).to_csv(f'{"batter" if bstat_df is not None else "pitcher"}-deltas.csv')
    pd.DataFrame(new_players[1:], columns=new_players[0]).to_csv(f'new-{"batter" if bstat_df is not None else "pitcher"}s.csv')

    players_df = pd.DataFrame(all_players).set_index('bbref_id')
    return players_df


async def post_batting_cards(cards_df: pd.DataFrame):
    all_cards = []

    cards_df.apply(lambda x: all_cards.append({
        'player_id': int(x["player_id"]),
        'steal_low': x['steal_low'],
        'steal_high': x['steal_high'],
        'steal_auto': x['steal_auto'],
        'steal_jump': x['steal_jump'],
        'bunting': x['bunt'],
        'hit_and_run': x['hit_and_run'],
        'running': x['running'],
        'hand': x['hand']
    }), axis=1)
    resp = await db_put('battingcards', payload={'cards': all_cards}, timeout=6)
    if resp is not None:
        pass
    else:
        log_exception(ValueError, 'Unable to post batting cards')
    
    bc_query = await db_get('battingcards', params=[('cardset_id', CARDSET_ID)])
    if bc_query['count'] > 0:
        bc_data = bc_query['cards']
        
        for line in bc_data:
            line['player_id'] = line['player']['player_id']
            line['key_bbref'] = line['player']['bbref_id']
            line['battingcard_id'] = line['id']

        return pd.DataFrame(bc_data)
    else:
        log_exception(ValueError, 'Unable to pull newly posted batting cards')


async def post_pitching_cards(cards_df: pd.DataFrame):
    all_cards = []
    def get_closer_rating(raw_rating):
        try:
            if pd.isnull(raw_rating):
                return None
            else:
                return raw_rating
        except AttributeError:
            return None

    cards_df.apply(lambda x: all_cards.append({
        'player_id': int(x['player_id']),
        'balk': x['balk'],
        'wild_pitch': x['wild_pitch'],
        'hold': x['hold'],
        'starter_rating': x['starter_rating'],
        'relief_rating': x['relief_rating'],
        'closer_rating': get_closer_rating(x['closer_rating']),
        'batting': x['batting'],
        'hand': x['pitch_hand'].upper()
    }), axis=1)
    resp = await db_put('pitchingcards', payload={'cards': all_cards}, timeout=6)
    if resp is not None:
        pass
    else:
        log_exception(ValueError, 'Unable to post pitcher cards')
    
    pc_query = await db_get('pitchingcards', params=[('cardset_id', CARDSET_ID)])
    if pc_query['count'] > 0:
        pc_data = pc_query['cards']
        if PLAYER_DESCRIPTION.lower() not in ['live', '1998']:
            pc_data = [x for x in pc_query['cards'] if x['player']['mlbplayer']['key_retro'] in PROMO_INCLUSION_RETRO_IDS]

        for line in pc_data:
            line['player_id'] = line['player']['player_id']
            line['key_bbref'] = line['player']['bbref_id']
            line['pitchingcard_id'] = line['id']

        return pd.DataFrame(pc_data)
    else:
        log_exception(ValueError, 'Unable to pull newly posted pitcher cards')


async def post_batting_ratings(ratings_df: pd.DataFrame):
    all_ratings = []

    def append_ratings(row):
        vl = row['ratings_vL']
        vl['player_id'] = row['player_id']
        vl['battingcard_id'] = row['battingcard_id']

        vr = row['ratings_vR']
        vr['player_id'] = row['player_id']
        vr['battingcard_id'] = row['battingcard_id']

        all_ratings.append(vl)
        all_ratings.append(vr)

    ratings_df.apply(append_ratings, axis=1)
    resp = await db_put('battingcardratings', payload={'ratings': all_ratings}, timeout=6)
    if resp is not None:
        return True
    else:
        log_exception(ValueError, 'Unable to post batting ratings')
    

async def post_pitching_ratings(ratings_df: pd.DataFrame):
    all_ratings = []

    def append_ratings(row):
        vl = row['ratings_vL']
        vl['player_id'] = row['player_id']
        vl['pitchingcard_id'] = row['pitchingcard_id']

        vr = row['ratings_vR']
        vr['player_id'] = row['player_id']
        vr['pitchingcard_id'] = row['pitchingcard_id']

        all_ratings.append(vl)
        all_ratings.append(vr)

    ratings_df.apply(append_ratings, axis=1)
    resp = await db_put('pitchingcardratings', payload={'ratings': all_ratings}, timeout=6)
    if resp is not None:
        return True
    else:
        log_exception(ValueError, 'Unable to post pitching ratings')


async def post_positions(pos_df: pd.DataFrame, delete_existing: bool = False):
    # Delete existing cardpositions ONLY for players in this run to avoid stale data
    # (e.g., DH positions from buggy runs where outfielders had no defensive positions)
    # Only delete on the first call (batters), not the second call (pitchers)
    if delete_existing:
        player_ids = pos_df['player_id'].unique().tolist()
        logger.info(f'Deleting existing cardpositions for {len(player_ids)} players in current run')
        existing_positions = await db_get('cardpositions', params=[('cardset_id', CARDSET_ID)])
        if existing_positions and existing_positions.get('count', 0) > 0:
            deleted_count = 0
            for pos in existing_positions['positions']:
                # Only delete positions for players being processed in this run
                if pos['player']['player_id'] in player_ids:
                    try:
                        await db_delete('cardpositions', object_id=pos['id'], timeout=1)
                        deleted_count += 1
                    except Exception as e:
                        logger.warning(f'Failed to delete cardposition {pos["id"]}: {e}')
            logger.info(f'Deleted {deleted_count} positions for players in current run')

    all_pos = []

    def append_positions(row):
        clean_row = row.dropna()
        new_val = clean_row.to_dict()
        new_val['player_id'] = int(row['player_id'])
        all_pos.append(new_val)
    pos_df.apply(append_positions, axis=1)

    resp = await db_put('cardpositions', payload={'positions': all_pos}, timeout=6)
    if resp is not None:
        return True
    else:
        log_exception(ValueError, 'Unable to post positions')


async def post_batter_data(bs: pd.DataFrame, bc: pd.DataFrame, br: pd.DataFrame, dr: pd.DataFrame) -> int:
    all_players = await get_or_post_players(bstat_df=bs, bat_rat_df=br, def_rat_df=dr)
    
    # Post Batting Cards
    bc = pd.merge(
        left=bc,
        right=all_players,
        how='left',
        left_on='key_bbref',
        right_on='bbref_id'
    )
    bc = await post_batting_cards(bc)
    
    # Post Batting Ratings
    # Only merge the columns we need to avoid corrupting dict columns in br
    br = pd.merge(
        left=br,
        right=bc[['key_bbref', 'player_id', 'battingcard_id']],
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )
    br = await post_batting_ratings(br)

    # Post Positions
    dr = pd.merge(
        left=dr,
        right=all_players,
        how='right',  # 'left',
        left_on='key_bbref',
        right_on='bbref_id'
    )
    await post_positions(dr, delete_existing=True)  # Delete on first call (batters)

    return len(all_players)


async def post_pitcher_data(ps: pd.DataFrame, pc: pd.DataFrame, pr: pd.DataFrame, dr: pd.DataFrame) -> int:
    all_players = await get_or_post_players(pstat_df=ps, pit_rat_df=pr, def_rat_df=dr)
    ps = pd.merge(
        left=all_players,
        right=ps,
        how='left',
        left_on='bbref_id',
        right_on='key_bbref'
    )

    # Post Pitching Cards
    pc = await post_pitching_cards(ps)

    # Post Pitching Ratings
    # Only merge the columns we need to avoid corrupting dict columns in pr
    pr = pd.merge(
        left=pr,
        right=pc[['key_bbref', 'player_id', 'pitchingcard_id']],
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )
    pr = await post_pitching_ratings(pr)

    # Post Positions
    dr = pd.merge(
        left=all_players,
        right=dr,
        how='left',
        left_on='bbref_id',
        right_on='key_bbref'
    )
    await post_positions(dr, delete_existing=False)  # Don't delete on second call (pitchers)

    return len(all_players)
    

async def run_batters(data_input_path: str, start_date: int, end_date: int, post_data: bool = False, season_pct: float = 1.0):
    print(f'Running the batter calcs...')
    # batter_start = datetime.datetime.now()

    # Get batting stats
    batting_stats = get_batting_stats_by_date(f'{RETRO_FILE_PATH}{EVENTS_FILENAME}', start_date=start_date, end_date=end_date)
    bs_len = len(batting_stats)

    # end_calc = datetime.datetime.now()    
    # print(f'Combined batting stats: {(end_calc - batter_start).total_seconds():.2f}s\n')
    running_start = datetime.datetime.now()

    # Get running stats
    running_stats = get_run_stat_df(data_input_path)

    batting_stats = pd.merge(
        left=batting_stats,
        right=running_stats,
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )

    # Handle players who played for multiple teams - keep only highest-level combined totals
    # Players traded during season have multiple rows: one per team + one combined (2TM, 3TM, etc.)
    # Prefer: 3TM > 2TM > TOT > individual teams
    duplicated_mask = batting_stats['key_bbref'].duplicated(keep=False)
    if duplicated_mask.any():
        # Sort by Tm (descending) to prioritize higher-numbered combined totals (3TM > 2TM)
        # Then drop duplicates, keeping only the first (highest priority) row per player
        batting_stats = batting_stats.sort_values('Tm', ascending=False)
        batting_stats = batting_stats.drop_duplicates(subset='key_bbref', keep='first')
        logger.info("Removed team-specific rows for traded batters")
        bs_len = len(batting_stats)  # Update length after removing duplicates

    end_calc = datetime.datetime.now()
    print(f'Running stats: {(end_calc - running_start).total_seconds():.2f}s')

    if len(batting_stats) != bs_len:
        raise DataMismatchError(f'retrosheet_data - run_batters - We started with {bs_len} batting lines and have {len(batting_stats)} after merging with running_stats')
    
    # Calculate batting cards
    card_start = datetime.datetime.now()
    all_batting_cards = calc_batting_cards(batting_stats, season_pct)
    card_end = datetime.datetime.now()

    print(f'Create batting cards: {(card_end - card_start).total_seconds():.2f}s')

    # Calculate batting ratings
    rating_start = datetime.datetime.now()
    batting_stats['battingcard_id'] = batting_stats['key_fangraphs']
    all_batting_ratings = calc_batter_ratings(batting_stats)
    rating_end = datetime.datetime.now()

    print(f'Create batting ratings: {(rating_end - rating_start).total_seconds():.2f}s')

    # Calculate defense ratings
    defense_start = datetime.datetime.now()
    all_defense_ratings = calc_positions(batting_stats)
    defense_end = datetime.datetime.now()

    print(f'Create defense ratings: {(defense_end - defense_start).total_seconds():.2f}s')

    # Post all data
    if post_data:
        print(f'Posting player data...')
        post_start = datetime.datetime.now()
        num_players = await post_batter_data(batting_stats, all_batting_cards, all_batting_ratings, all_defense_ratings)
        post_end = datetime.datetime.now()

        print(f'Post player data: {(post_end - post_start).total_seconds()}s')

        post_msg = f'Posted {num_players} players to the database'
        logger.info(post_msg)
        print(post_msg)
    else:
        post_msg = f'{batting_stats.index.size} total batters\n\nPlayers are NOT being posted to the database'
        logger.warning(post_msg)
        print(post_msg)

    return batting_stats


async def run_pitchers(data_input_path: str, start_date: int, end_date: int, post_data: bool = False, season_pct: float = 1.0):
    # Get pitching stats
    pitching_stats = get_pitching_stats_by_date(f'{RETRO_FILE_PATH}{EVENTS_FILENAME}', start_date=start_date, end_date=end_date)

    # Get peripheral stats
    start_time = datetime.datetime.now()
    periph_stats = get_periph_stat_df(data_input_path)

    pitching_stats = pd.merge(
        left=pitching_stats,
        right=periph_stats,
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )

    # Handle players who played for multiple teams - keep only highest-level combined totals
    # Players traded during season have multiple rows: one per team + one combined (2TM, 3TM, etc.)
    # Prefer: 3TM > 2TM > TOT > individual teams
    duplicated_mask = pitching_stats['key_bbref'].duplicated(keep=False)
    if duplicated_mask.any():
        # Sort by Tm (descending) to prioritize higher-numbered combined totals (3TM > 2TM)
        # Then drop duplicates, keeping only the first (highest priority) row per player
        pitching_stats = pitching_stats.sort_values('Tm', ascending=False)
        pitching_stats = pitching_stats.drop_duplicates(subset='key_bbref', keep='first')
        logger.info(f"Removed team-specific rows for traded players")
    end_time = datetime.datetime.now()
    print(f'Peripheral stats: {(end_time - start_time).total_seconds():.2f}s')

    # Calculate defense ratings
    start_time = datetime.datetime.now()
    df_p = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_p.csv').set_index('key_bbref')
    # Drop 'Tm' from defense data to avoid column name conflicts (we already have it from periph_stats)
    if 'Tm' in df_p.columns:
        df_p = df_p.drop(columns=['Tm'])
    pitching_stats = pd.merge(
        left=pitching_stats,
        right=df_p,
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )
    pitching_stats = pitching_stats.fillna(0)

    all_defense_ratings = calc_pitcher_defense(pitching_stats)
    end_time = datetime.datetime.now()
    print(f'Defense stats: {(end_time - start_time).total_seconds():.2f}s')

    # Calculate pitching cards
    start_time = datetime.datetime.now()
    all_pitching_cards = calc_pitching_cards(pitching_stats, season_pct)
    pitching_stats = pd.merge(
        left=pitching_stats,
        right=all_pitching_cards,
        how='left',
        left_on='key_bbref',
        right_on='key_bbref'
    )
    end_time = datetime.datetime.now()
    print(f'Pit cards: {(end_time - start_time).total_seconds():.2f}s')

    # Calculate pitching card ratings
    start_time = datetime.datetime.now()
    all_pitching_ratings = calc_pitcher_ratings(pitching_stats)
    end_time = datetime.datetime.now()
    print(f'Pit ratings: {(end_time - start_time).total_seconds():.2f}s')

    # Post all data
    if post_data:
        print(f'\nPosting player data...')
        post_start = datetime.datetime.now()
        num_players = await post_pitcher_data(pitching_stats, all_pitching_cards, all_pitching_ratings, all_defense_ratings)
        post_end = datetime.datetime.now()

        print(f'Post player data: {(post_end - post_start).total_seconds()}s')

        post_msg = f'\nPosted {num_players} pitchers to the database'
        logger.info(post_msg)
        print(post_msg)
    else:
        post_msg = f'{pitching_stats.index.size} total pitchers\n\nPlayers are NOT being posted to the database'
        logger.warning(post_msg)
        print(post_msg)
    
    return pitching_stats


async def main(args):
    if len(PROMO_INCLUSION_RETRO_IDS) > 0 and PLAYER_DESCRIPTION == 'Live':
        msg = f'Player description is set to *Live*, but there are {len(PROMO_INCLUSION_RETRO_IDS)} IDs in the promo inclusion list. Clear the promo list or change the player description.'
        log_exception(ValueError, msg=msg, level='error')

    # Temporarily commented out for Ryan Zimmerman full season run
    # if weeks_between(START_DATE, END_DATE) > 5 and len(PROMO_INCLUSION_RETRO_IDS) > 0:
    #     msg = f'More than 5 weeks are included for a promo cardset. Please adjust START_DATE and/or END_DATE.'
    #     log_exception(ValueError, msg=msg, level='error')

    batter_start = datetime.datetime.now()
    batting_stats = await run_batters(f'{DATA_INPUT_FILE_PATH}', start_date=START_DATE, end_date=END_DATE, post_data=POST_DATA, season_pct=SEASON_PCT)
    batting_stats.to_csv(f'batting_stats.csv')
    batter_end = datetime.datetime.now()
    print(f'\nBatter time: {(batter_end - batter_start).total_seconds():.2f}s\n')

    pitcher_start = datetime.datetime.now()
    pitching_stats = await run_pitchers(f'{DATA_INPUT_FILE_PATH}', start_date=START_DATE, end_date=END_DATE, post_data=POST_DATA, season_pct=SEASON_PCT)
    pitching_stats.to_csv(f'pitching_stats.csv')
    pitcher_end = datetime.datetime.now()
    print(f'\nPitcher time: {(pitcher_end - pitcher_start).total_seconds():.2f}s')

    print(f'Total: {(pitcher_end - batter_start).total_seconds():.2f}s\n\nDone!')

    # await store_defense_to_csv(1998)


if __name__ == '__main__':
    asyncio.run(main(sys.argv[1:]))