import gradio as gr
import pandas as pd
import yfinance as yf
from datetime import timedelta,datetime
import pytz
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np




def dateoffset(input_date_str):
    
    input_date_dt = datetime.strptime(input_date_str, "%Y-%m-%d")

    
    new_date_dt = input_date_dt - timedelta(days=1)

    
    new_date_str = new_date_dt.strftime("%Y-%m-%d")

    return new_date_str


def setdates(startdate, enddate):
    while startdate not in nifty50["nifty50"].data.index:
        startdate = dateoffset(startdate)

    while enddate not in nifty50["nifty50"].data.index:
        enddate = dateoffset(enddate)

    return startdate, enddate


def organisedata(startdate, enddate):
    
    startdate, enddate = setdates(startdate, enddate)

    
    symbols = list(nifty_stocks.keys())

    
    common_index = nifty50["nifty50"].data.loc[startdate:enddate].index

    
    data_frame = pd.DataFrame(index=symbols, columns=common_index)

    
    for symbol, stock_object in nifty_stocks.items():
        stock_data = stock_object.data.loc[startdate:enddate, 'Close']
        data_frame.loc[symbol] = stock_data.reindex(common_index).values

    return data_frame

def previoustimeframedata(n, startdate):
    
    startdate_dt = pd.to_datetime(startdate)

    
    ndaysagodate = startdate_dt - timedelta(days=int(n))

    
    ndaysagodate_str = ndaysagodate.strftime("%Y-%m-%d")
    startdate_str = startdate_dt.strftime("%Y-%m-%d")

    
    return organisedata(ndaysagodate_str, startdate_str)

def portfoliooperations(equity,startdate,ndaywindow,portfolio):
    
    startdate_dt = pd.to_datetime(startdate)
    windowenddate = startdate_dt + timedelta(days=int(ndaywindow))
    windowenddate_str = windowenddate.strftime("%Y-%m-%d")

    startdate,windowenddate = setdates(startdate,windowenddate_str) 
    
    window_data = organisedata(startdate,windowenddate) 

    differences = window_data.iloc[:, -1] - window_data.iloc[:, 0]  

    next_portfolio = differences[differences > 0].index.tolist() 

    
    portfolio_sum = window_data.loc[portfolio, window_data.columns[0]].sum()

    
    multiplier = equity / portfolio_sum if portfolio_sum != 0 else 0


    portfolio_value = pd.DataFrame(index=window_data.columns, columns=['value'])

    for date in window_data.columns:
    
      portfolio_sum = window_data.loc[portfolio, date].sum()
    
      portfolio_value.loc[date, 'value'] = portfolio_sum * multiplier


    return next_portfolio,portfolio_value

def mainfunction (equity,startdate,enddate,ndaywindow):
    
    pastwindow = previoustimeframedata(n=ndaywindow,startdate=startdate) # No Errors untill here

    differences = pastwindow.iloc[:, -1] - pastwindow.iloc[:, 0]

    portfolio = differences[differences > 0].index.tolist() # No Errors untill here

    portfolio,portfolio_value = portfoliooperations(equity=equity,startdate=startdate,ndaywindow=ndaywindow,portfolio=portfolio)



    enddate_tz = datetime.strptime(enddate,"%Y-%m-%d").replace(tzinfo=pytz.timezone('Asia/Kolkata'))

    while portfolio_value.index[-1] < pd.to_datetime(enddate_tz) - timedelta(days=int(ndaywindow)):

      portfolio,new_portfolio_value = portfoliooperations(equity=equity,startdate=startdate,ndaywindow=ndaywindow,portfolio=portfolio)

      portfolio_value = pd.concat([portfolio_value, new_portfolio_value])

      startdate = (pd.to_datetime(startdate)+ timedelta(days=int(ndaywindow))).strftime("%Y-%m-%d")
      
      equity = portfolio_value.iloc[-1, 0]

    return portfolio_value

def calculate_cagr(series):
    total_return = (series.iloc[-1] / series.iloc[0]) - 1
    num_years = len(series) / 252  
    cagr = (1 + total_return) ** (1 / num_years) - 1
    return cagr * 100


def calculate_volatility(series):
    return series.pct_change().std() * np.sqrt(252) * 100


def calculate_sharpe_ratio(series, risk_free_rate=0):
    cagr = calculate_cagr(series)
    volatility = calculate_volatility(series)
    sharpe_ratio = (cagr - risk_free_rate) / volatility
    return sharpe_ratio


def final_function(equity,startdate,enddate,ndaywindow):

    equity = int(equity)
    ndaywindow = int(ndaywindow)

    portfolio_value = mainfunction(equity=equity,startdate=startdate,enddate=enddate,ndaywindow=ndaywindow)
    nifty_data = nifty50["nifty50"].data
    subset_data = nifty_data[startdate:enddate]
    initial_nifty = subset_data['Close'][0]
    nifty_dataseries = (equity/initial_nifty)*subset_data['Close']
    plt.figure(figsize=(10, 6))
    plt.plot(portfolio_value['value'], label='Strategy')
    plt.plot(nifty_dataseries, label='Nifty50 as Benchmark')
    plt.title('Benchmark vs Strategy')
    plt.xlabel('Date')
    plt.ylabel('Close Price')
    plt.legend()


    image_path = "output_plot.png"
    plt.savefig(image_path)
    plt.close()


    image = Image.open(image_path)

    strategy_cagr = calculate_cagr(portfolio_value['value'])
    strategy_volatility = calculate_volatility(portfolio_value['value'])
    strategy_sharpe_ratio = calculate_sharpe_ratio(portfolio_value['value'])

    benchmark_cagr = calculate_cagr(nifty_dataseries)
    benchmark_volatility = calculate_volatility(nifty_dataseries)
    benchmark_sharpe_ratio = calculate_sharpe_ratio(nifty_dataseries)


    return image, strategy_cagr, strategy_volatility, strategy_sharpe_ratio, benchmark_cagr, benchmark_volatility, benchmark_sharpe_ratio