from datetime import datetime, timedelta
import csv, random
import matplotlib.dates as mdates
import pandas as pd
import matplotlib.pyplot as plt

# Get user inputs for date range
start_date = input("Enter start date (YYYY-MM-DD): ")
end_date = input("Enter end date (YYYY-MM-DD): ")

# Read the CSV file into a DataFrame

df = pd.read_csv("G:/Other computers/My Laptop/PyProjects/Top20/Top20_Total_03_24/VWAP_USD/result_with_timestamp.csv")

# Filter the DataFrame based on the user-defined date range
df = df[(df['Column 2 Name'] >= start_date) & (df['Column 2 Name'] <= end_date)]

# Calculate the percent change between days
df['Percent_Change'] = df['Column 1 Name'].pct_change() * 100

# Create a list of percent changes, dropping the first NaN value
percent_changes = df['Percent_Change'].dropna().tolist()

# Print the first few percent changes to verify
print(percent_changes[:5])

# Get user inputs
days = int(input("Number of days to simulate: "))
starting_price = float(input("Starting price: "))
number_of_simulations = int(input("Number of simulations: "))
wins = 0

# Initialize a list to store daily prices for averaging
daily_prices = [[] for _ in range(days)]

# Open the CSV file for writing results
with open('C:/PyProjects/Predictor/simulation_results.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Simulation', 'Date', 'Price'])  # Write header
    
    for sim in range(number_of_simulations):
        # Initialize the price list with the starting price for each simulation
        prices = [starting_price]
        reached_100k = False

        # Initialize the starting date
        current_date = datetime.now()  # or set to a specific start date
        writer.writerow([sim + 1, current_date.strftime('%Y-%m-%d'), starting_price])
        # Simulate price changes
        for day in range(days):
            percent_change = random.choice(percent_changes)
            new_price = prices[-1] * (1 + percent_change / 100)
            prices.append(new_price)

            current_date += timedelta(days=1)
            # Store the simulation number, date, and new price
            writer.writerow([sim + 1, current_date.strftime('%Y-%m-%d'), new_price])

            # Store the new price for averaging
            daily_prices[day].append(new_price)

            # Check if price has exceeded 100,000 at any point
            if new_price > 100_000 and not reached_100k:
                reached_100k = True
                wins += 1

        # Print the results for the simulation
        print(f"\nSimulation {sim + 1}:")
        print(f"Final price after {days} days: ${prices[-1]:.2f}")
        print(f"Total change: {((prices[-1] - starting_price) / starting_price * 100):.2f}%")
        print(f"Reached $100,000: {'Yes' if reached_100k else 'No'}")

print(f"\nNumber of simulations reaching $100,000 or more: {wins}")
print(f"Probability of reaching $100,000 or more: {(wins / number_of_simulations) * 100:.2f}%")

# Create a figure and axis for the plot
plt.figure(figsize=(12, 6))
results_df = pd.read_csv('C:/PyProjects/Predictor/simulation_results.csv')
results_df.columns = results_df.columns.str.strip()  # Remove any leading/trailing whitespace
results_df['Date'] = pd.to_datetime(results_df['Date'])

# Loop through each unique simulation number
for sim in results_df['Simulation'].unique():
    sim_data = results_df[results_df['Simulation'] == sim]
    plt.plot(sim_data['Date'], sim_data['Price'], marker='o')  # Group by simulation number

# Add labels and title
plt.xlabel('Date')
plt.ylabel('Price')
plt.title('Price vs Date for Each Simulation')
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m'))
plt.xticks(rotation=45)  # Rotate x-axis labels for better readability
plt.grid()  # Add grid for better readability
plt.tight_layout()
plt.gca().set_xlim(left=results_df['Date'].min(), right=results_df['Date'].max())
plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.15)

# Mirror the y-axis on the right
ax = plt.gca()
ax2 = ax.twinx()
ax2.set_ylabel('Price')
ax2.yaxis.set_label_position('right')
ax2.yaxis.tick_right()
ax2.set_ylim(ax.get_ylim())

# Export the plot
plt.show()

# Uncomment 2 lines below and replace with actual path
# file_name = f"{current_date:%m}-{current_date:%d}-{current_date:%H}-{current_date:%M}-{current_date:%S}.png" 
# plt.savefig(f'C:/PyProjects/Predictor/{file_name}')

# Create a figure and axis for the plot
plt.figure(figsize=(12, 6))
results_df = pd.read_csv('C:/PyProjects/Predictor/simulation_results.csv')

# Extract the last price for each simulation
last_prices = results_df.groupby('Simulation')['Price'].last()

# Create bins for the price ranges
bins = range(int(last_prices.min()), int(last_prices.max()) + 1000, 1000)

# Create a histogram of the last prices
plt.figure(figsize=(12, 6))
counts, _, patches = plt.hist(last_prices, bins=bins, edgecolor='black')

# Calculate min, max, and mode
min_price = last_prices.min()
max_price = last_prices.max()
mode_price = last_prices.mode()[0]  # Get the first mode if there are multiple

# Label the columns with min, max, and mode prices
plt.text(min_price, counts.max() * 0.9, f'Min: {min_price:.0f}', color='blue', fontsize=13)
plt.text(max_price - len(bins)*150, counts.max() * 0.9, f'Max: {max_price:.0f}', color='green', fontsize=13)
# plt.text(mode_price, counts.max() * 0.8, f'Mode: {mode_price}', color='green', fontsize=10)

# Set labels and title
plt.xlabel('Price on Last Day of Each Simulation')
plt.ylabel('Number of Simulations')
plt.title('Histogram of Simulations by Price on Last Day')

# Show the plot
plt.show()

# Uncomment 2 lines below and replace with actual path
# file_name = f"{current_date:%m}-{current_date:%d}-{current_date:%H}-{current_date:%M}-{current_date:%S}_2C.png" 
# plt.savefig(f'C:/PyProjects/Predictor/{file_name}')

# from datetime import datetime, timedelta
import pyperclip
import matplotlib.dates as mdates
import pandas as pd
import matplotlib.pyplot as plt
import pandas as pd

start_date = '2012-01-01' #input("Enter start date (YYYY-MM-DD): ")
end_date = '2024-11-09' #input("Enter end date (YYYY-MM-DD): ")

# Read the CSV file into a DataFrame
df = pd.read_csv("C:/PyProjects/Predictor/result_with_timestamp.csv")

# Filter the DataFrame based on the user-defined date range
df = df[(df['Column 2 Name'] >= start_date) & (df['Column 2 Name'] <= end_date)]

# Calculate the percent change between days
df['Percent_Change'] = df['Column 1 Name'].pct_change() * 100

# Get user inputs
days = int(input("Number of past days to match: "))

# Get the most recent sequence of percent changes
recent_percent_changes = df['Percent_Change'].tail(days).dropna().tolist()

# Initialize a list to store closeness rankings
closeness_rankings = []

# Iterate through the DataFrame to find matching sequences
for i in range(len(df) - days + 1):
    # Get the current sequence of percent changes
    past_percent_changes = df['Percent_Change'].iloc[i:i + days].dropna().tolist()
    
    # Ensure we have a valid sequence
    if len(past_percent_changes) == days:
        # Calculate the deltas
        deltas = [abs(recent - past) for recent, past in zip(recent_percent_changes, past_percent_changes)]
        
        # Calculate the sum of deltas as the closeness ranking
        closeness_ranking = sum(deltas)
        
        # Store the result with the starting index
        closeness_rankings.append((i, closeness_ranking, past_percent_changes))

# Sort the closeness rankings by the ranking value
closeness_rankings.sort(key=lambda x: x[1])  # Sort by closeness ranking

n = 1
post = []
colors = ['black', 'red', 'orange', 'blue', 'green']
for x in colors:
    if len(closeness_rankings) > 1:
        second_best_index, second_best_ranking, past_changes = closeness_rankings[n]
        starting_date = df['Column 2 Name'].iloc[second_best_index]
    else:
        print("Not enough closeness rankings found.")
        exit()

    close_score = (second_best_ranking/days)

    print(f'Closeness ({close_score}): {starting_date}')
    series = f'Close score: ({close_score:.5f}) [color={x}]Range start date: {starting_date}[/color]'
    post.append(series)

    # Get the next percent changes starting from 'second_best_index + days'
    next_percent_changes = df['Percent_Change'].iloc[second_best_index + days:second_best_index + days + days].dropna().tolist()

    # Set the starting price as the last price in the DataFrame
    starting_price = float(df['Column 1 Name'].iloc[-1])

    # Initialize a list to store predicted prices
    predicted_prices = [starting_price]

    # Simulate the price changes using the next percent changes
    for percent_change in next_percent_changes:
        new_price = predicted_prices[-1] * (1 + percent_change / 100)
        predicted_prices.append(new_price)

    last_date = pd.to_datetime(df['Column 2 Name'].iloc[-1])
    predicted_dates = pd.date_range(start=last_date, periods=len(predicted_prices), freq='D')

    # Prepare data for saving to CSV
    predicted_df = pd.DataFrame({
        'Date': predicted_dates,
        'Predicted_Price': predicted_prices
    })

    # Save the predicted prices to a CSV file
    predicted_df.to_csv(f'C:/PyProjects/Predictor/predicted_simulation{n}.csv', index=False)
    n += 1

import pandas as pd
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))

# Function to plot data
def plot_data(plt, file, label, color):
    results_df = pd.read_csv(file)
    results_df.columns = results_df.columns.str.strip()  # Strip whitespace from column names
    results_df['Date'] = pd.to_datetime(results_df['Date'])  # Convert 'Date' to datetime
    plt.plot(results_df['Date'], results_df['Predicted_Price'], label=label, color=color)
    return results_df  # Return the DataFrame for later use

# Plot each predicted simulation and collect DataFrames
dfs = []
dfs.append(plot_data(plt, 'C:/PyProjects/Predictor/predicted_simulation1.csv', 'Best Past Match', 'black')) 
dfs.append(plot_data(plt, 'C:/PyProjects/Predictor/predicted_simulation2.csv', '2nd Best', 'red'))
dfs.append(plot_data(plt, 'C:/PyProjects/Predictor/predicted_simulation3.csv', '3rd Best', 'orange'))
dfs.append(plot_data(plt, 'C:/PyProjects/Predictor/predicted_simulation4.csv', '4th Best', 'blue'))
dfs.append(plot_data(plt, 'C:/PyProjects/Predictor/predicted_simulation5.csv', '5th Best', 'green'))

# Set x-axis limits based on the min and max dates from all DataFrames
all_dates = pd.concat([df['Date'] for df in dfs])  
plt.gca().set_xlim(left=all_dates.min(), right=all_dates.max())

# Add labels and title
plt.xlabel('Date')
plt.ylabel('Predicted Price')
plt.title(f'Predicted Prices for Best Past Matches over {days} days in the past')
plt.xticks(rotation=45)  
plt.grid()  
plt.tight_layout()

# Show the plot
plt.legend()
plt.show()

comment = f"{post}"
print (comment)
pyperclip.copy(comment)

import matplotlib.pyplot as plt
import pandas as pd
 
start_date = '2012-01-01' #input("Enter start date (YYYY-MM-DD): ")
end_date = '2024-11-09' #input("Enter end date (YYYY-MM-DD): ")

df = pd.read_csv("PriceDate.csv")
df['Percent_Change'] = df['Price'].pct_change() * 100
days = int(input("Number of past days to match: "))
recent_percent_changes = df['Percent_Change'].tail(days).dropna().tolist()

closeness_rankings = []
tries = len(df) - days
for i in range(0, tries):
    past_percent_changes = df['Percent_Change'].iloc[i:i + days].tolist()
    deltas = [abs(recent - past) for recent, past in zip(recent_percent_changes, past_percent_changes)]
    closeness_ranking = sum(deltas)
    closeness_rankings.append((i, closeness_ranking, past_percent_changes))
    
closeness_rankings.sort(key=lambda x: x[1])
second_best_index, second_best_ranking, past_changes = closeness_rankings[1]
starting_date = df['Date'].iloc[second_best_index]
print(starting_date)
df.to_csv(f'PercentChange.csv', index=False)
next_percent_changes = df['Percent_Change'].iloc[second_best_index + days:second_best_index + days + days].tolist()
starting_price = float(df['Price'].iloc[-1])
predicted_prices = [starting_price]

for percent_change in next_percent_changes:
    new_price = predicted_prices[-1] * (1 + percent_change / 100)
    predicted_prices.append(new_price)

last_date = pd.to_datetime(df['Date'].iloc[-1])
predicted_dates = pd.date_range(start=last_date, periods=len(predicted_prices))
predicted_df = pd.DataFrame({'Date': predicted_dates,'Predicted_Price': predicted_prices})
predicted_df.to_csv('try_two_simulation.csv', index=False)

plt.figure(figsize=(12, 6))
def plot_data(plt, file, label, color):
    results_df = pd.read_csv(file)
    results_df.columns = results_df.columns.str.strip()  
    results_df['Date'] = pd.to_datetime(results_df['Date'])  
    plt.plot(results_df['Date'], results_df['Predicted_Price'], label=label, color=color)
    return results_df  

dfs = []
dfs.append(plot_data(plt, 'try_two_simulation.csv', 'Best Past Match', 'black')) 

all_dates = pd.concat([df['Date'] for df in dfs])  
plt.gca().set_xlim(left=all_dates.min(), right=all_dates.max())
plt.xlabel('Date')
plt.ylabel('Predicted Price')
plt.title(f'Predicted Prices for Best Past Matches over {days} days in the past')
plt.xticks(rotation=45)  
plt.grid()  
plt.tight_layout()
plt.legend()
plt.show()

https://pastebin.com/3C67XqKW

# import pyperclip
import datetime, sys
import matplotlib.dates as mdates
import pandas as pd
import matplotlib.pyplot as plt
import pandas as pd

# constants
CSVFILE = "prices23nov24.csv"
start_date = '2012-01-01' #input("Enter start date (YYYY-MM-DD): ")
end_date = '2024-11-23' #input("Enter end date (YYYY-MM-DD): ")
diversity = True # diversity mode ensures the dates aren't too close to each other
div_days = 60
next_days = 60

def readarg(flag, default=None):
    if flag in sys.argv:
        if type(default) == bool:
            return True
        index = sys.argv.index(flag)
        if len(sys.argv) >= (index + 1):
            result = sys.argv[index + 1]
            if type(default) == int:
                return int(result)
            else:
                return result
    return default


def toocloseto(date_raw, ranks, days_raw):
    # for diversity mode: can't be too close
    date = datetime.date.fromisoformat(date_raw)
    days = datetime.timedelta(days_raw)
    # print("Comparing dates:", date_raw, ranks)
    for rkdate_raw in ranks:
        rkdate = datetime.date.fromisoformat(rkdate_raw)
        diff = abs(date - rkdate)
        if diff < days:
            # print("Too close:", diff)
            return True
    return False

# Function to plot data
def plot_data(plt, file, label, color):
    results_df = pd.read_csv(file)
    results_df.columns = results_df.columns.str.strip()  # Strip whitespace from column names
    results_df['Date'] = pd.to_datetime(results_df['Date'])  # Convert 'Date' to datetime
    plt.plot(results_df['Date'], results_df['Predicted_Price'], label=label, color=color)
    return results_df  # Return the DataFrame for later use

# ARGUMENTS
# days: length of the timeframe to compare, in days
days = readarg("-d", 90)
# diverse: ensure that the dates aren't too close one to another (default minimum difference: 60 days, see div_days constant above)
diversity = readarg("--diverse", False)
# next_days: length of the timeframe to add.
next_days = readarg("-n", 90)

# Read the CSV file into a DataFrame
df = pd.read_csv(CSVFILE)

# Filter the DataFrame based on the user-defined date range
df = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]

# Calculate the percent change between days
df['Percent_Change'] = df['Price'].pct_change() * 100

# Get user inputs
# days = int(input("Number of past days to match: "))

# Get the most recent sequence of percent changes
recent_percent_changes = df['Percent_Change'].tail(days).dropna().tolist()

# Initialize a list to store closeness rankings
closeness_rankings = []

# Iterate through the DataFrame to find matching sequences
for i in range(len(df) - days + 1):
    # Get the current sequence of percent changes
    past_percent_changes = df['Percent_Change'].iloc[i:i + days].dropna().tolist()
    past_dates = df['Date'].iloc[i:i + days].dropna().tolist()

    # Ensure we have a valid sequence
    if len(past_percent_changes) == days:

        # Calculate the deltas
        deltas = [abs(recent - past) for recent, past in zip(recent_percent_changes, past_percent_changes)]

        # Calculate the sum of deltas as the closeness ranking
        closeness_ranking = sum(deltas)
        # print(past_dates[0], past_dates[-1], closeness_ranking)

        # Store the result with the starting index
        closeness_rankings.append((i, closeness_ranking, past_percent_changes, past_dates[0], past_dates[-1]))

# Sort the closeness rankings by the ranking value
closeness_rankings.sort(key=lambda x: x[1])  # Sort by closeness ranking

n = 1 # n cycles through the ranks of the original dataframe.
m = 1 # m cycles through the actual ranks
post = []
colors = ['black', 'red', 'orange', 'blue', 'green', 'yellow', 'grey']
bestranks = []
for x in colors:
    if len(closeness_rankings) > 1:
        while True:
            second_best_index, second_best_ranking, past_changes = closeness_rankings[n][:3]
            starting_date = df['Date'].iloc[second_best_index]
            if diversity and toocloseto(starting_date, bestranks, div_days):
                # print(starting_date, "too close to the date of one of the selected best ranks")
                n += 1
                continue
            else:
                # Get the next percent changes starting from 'second_best_index + days'
                next_percent_changes = df['Percent_Change'].iloc[second_best_index + days:second_best_index + days + next_days].dropna().tolist()
                if len(next_percent_changes) < next_days:
                    print(f"Series too short: {starting_date}, {len(next_percent_changes)} days.")
                    n += 1
                    continue
                bestranks.append(starting_date)
                break
    else:
        print("Not enough closeness rankings found.")
        exit()

    print("Rank", n)
    close_score = (second_best_ranking/days)

    print(f'Closeness ({close_score}): {starting_date}')
    # series = f'Close score: ({close_score:.5f}) [color={x}]Range start date: {starting_date}[/color]'
    # post.append(series)

    # Set the starting price as the last price in the DataFrame
    starting_price = float(df['Price'].iloc[-1])

    # Initialize a list to store predicted prices
    predicted_prices = [starting_price]

    # Simulate the price changes using the next percent changes
    for percent_change in next_percent_changes:
        new_price = predicted_prices[-1] * (1 + percent_change / 100)
        predicted_prices.append(new_price)

    last_date = pd.to_datetime(df['Date'].iloc[-1])
    predicted_dates = pd.date_range(start=last_date, periods=len(predicted_prices), freq='D')

    # Prepare data for saving to CSV
    predicted_df = pd.DataFrame({
        'Date': predicted_dates,
        'Predicted_Price': predicted_prices
    })


    # Save the predicted prices to a CSV file
    predicted_df.to_csv(f'predicted_simulation{m}.csv', index=False)
    n += 1
    m += 1


# Test:
for i in range(7):
    print("Rank", i, bestranks[i])

plt.figure(figsize=(12, 6))

# Plot each predicted simulation and collect DataFrames
dfs = []
dfs.append(plot_data(plt, 'predicted_simulation1.csv', 'Best Past Match: start {}'.format(bestranks[0]), 'black'))
dfs.append(plot_data(plt, 'predicted_simulation2.csv', '2nd Best: start {}'.format(bestranks[1]), 'red'))
dfs.append(plot_data(plt, 'predicted_simulation3.csv', '3rd Best: start {}'.format(bestranks[2]), 'orange'))
dfs.append(plot_data(plt, 'predicted_simulation4.csv', '4th Best: start {}'.format(bestranks[3]), 'blue'))
dfs.append(plot_data(plt, 'predicted_simulation5.csv', '5th Best: start {}'.format(bestranks[4]), 'green'))
dfs.append(plot_data(plt, 'predicted_simulation6.csv', '6th Best: start {}'.format(bestranks[5]), 'yellow'))
dfs.append(plot_data(plt, 'predicted_simulation7.csv', '7th Best: start {}'.format(bestranks[6]), 'grey'))

# Set x-axis limits based on the min and max dates from all DataFrames
all_dates = pd.concat([df['Date'] for df in dfs])
plt.gca().set_xlim(left=all_dates.min(), right=all_dates.max())

# Add labels and title
plt.xlabel('Date')
plt.ylabel('Predicted Price')
plt.title(f'Predicted Prices for Best Past Matches over {days} days in the past (prediction length: {next_days} days)')
plt.xticks(rotation=45)
plt.grid()
plt.tight_layout()

# Show the plot
plt.legend()
plt.show()

# comment = f"{post}"
# print(comment)
# pyperclip.copy(comment)