# Dimension 1: Positive Return on Assets
def dimension_1_positive_roa(symbol, years_back=1):

    limit_needed = years_back + 1
    
    income_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    balance_url = (
        f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    
    income_data = requests.get(income_url).json()
    balance_data = requests.get(balance_url).json()
    
    if len(income_data) < limit_needed or len(balance_data) < limit_needed:
        print(f"[Dimension 1] Not enough data for {years_back} year(s).")
        return []
    
    results = []
    for i in range(years_back):
        current_income = income_data[i]
        current_balance = balance_data[i]
        
        year_or_date = current_income.get("calendarYear") or current_income.get("date", f"N/A_{i}")
        
        net_income_current = current_income.get("netIncome", 0)
        ta_current = current_balance.get("totalAssets", 0)
        if i+1 < len(balance_data):
            ta_previous = balance_data[i+1].get("totalAssets", 0)
        else:
            ta_previous = 0
        
        avg_assets = (ta_current + ta_previous) / 2 if ta_previous else 0
        roa_current = net_income_current / avg_assets if avg_assets else 0
        score = 1 if roa_current > 0 else 0
        
        print(
            f"Dimension 1 (Positive ROA) | Year={year_or_date}: {score} => "
            f"NetIncome={net_income_current}, "
            f"AvgAssets={int(avg_assets)}, "
            f"ROA={roa_current:.4f}"
        )
        
        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_1_positive_roa("MSFT", years_back=1)

# Dimension 2: Positive Operating Cash Flow
def dimension_2_positive_cfo(symbol, years_back=1):

    # For CFO, we only need 'years_back' data points, not +1, 
    # because we don't compare current to previous. 
    # However, for consistency, let's keep it at years_back to show the "year" of each record.
    
    limit_needed = years_back
    
    cf_url = (
        f"https://financialmodelingprep.com/api/v3/cash-flow-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    cf_data = requests.get(cf_url).json()

    if len(cf_data) < limit_needed:
        print(f"[Dimension 2] Not enough data for {years_back} year(s).")
        return []
    
    results = []
    for i in range(years_back):
        record = cf_data[i]
        year_or_date = record.get("calendarYear") or record.get("date", f"N/A_{i}")
        
        cfo_current = record.get("operatingCashFlow", 0)
        score = 1 if cfo_current > 0 else 0
        
        print(
            f"Dimension 2 (Positive CFO) | Year={year_or_date}: {score} => CFO={cfo_current}"
        )
        
        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_2_positive_cfo("MSFT", years_back=1)

# Dimension 3: Improvement in ROA
def dimension_3_improved_roa(symbol, years_back=1):
    """
    We need years_back+1 data points, because we compare current ROA to previous ROA.
    """
    limit_needed = years_back + 1

    income_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    balance_url = (
        f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    income_data = requests.get(income_url).json()
    balance_data = requests.get(balance_url).json()

    if len(income_data) < limit_needed or len(balance_data) < limit_needed:
        print(f"[Dimension 3] Not enough data for {years_back} year(s).")
        return []
    
    results = []
    for i in range(years_back):
        current_income = income_data[i]
        current_balance = balance_data[i]
        
        # Attempt to fetch year
        year_or_date = current_income.get("calendarYear") or current_income.get("date", f"N/A_{i}")
        
        net_income_current = current_income.get("netIncome", 0)
        ta_current = current_balance.get("totalAssets", 0)
        
        # For 'previous' data, we need i+1
        if i+1 < len(income_data):
            net_income_previous = income_data[i+1].get("netIncome", 0)
            ta_previous = balance_data[i+1].get("totalAssets", 0)
        else:
            net_income_previous = 0
            ta_previous = 0
        
        # Compute ROA_current
        avg_current = (ta_current + ta_previous) / 2 if ta_previous else 0
        roa_current = net_income_current / avg_current if avg_current else 0
        
        # Now we want the year before that, but let's do a simpler fallback
        # If i+2 is available, we can refine, but let's keep it consistent:
        # We'll compare i to i+1.
        
        # Compute ROA_previous
        # We do not go for i+2 in this code to keep it straightforward.
        net_income_prev = net_income_previous
        # We'll need an additional data point for the 'previous' previous
        # But let's approximate the same approach:
        if i+2 < len(balance_data):
            ta_prev_year = balance_data[i+1].get("totalAssets", 0)
            ta_prev_year_before = balance_data[i+2].get("totalAssets", 0)
            avg_prev = (ta_prev_year + ta_prev_year_before) / 2 if ta_prev_year_before else ta_prev_year
            roa_previous = net_income_prev / avg_prev if avg_prev else 0
        else:
            roa_previous = net_income_prev / ta_previous if ta_previous else 0
        
        score = 1 if roa_current > roa_previous else 0
        
        print(
            f"Dimension 3 (ROA Improvement) | Year={year_or_date}: {score} => "
            f"ROA_current={roa_current:.4f}, ROA_previous={roa_previous:.4f}"
        )

        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_3_improved_roa("MSFT", years_back=1)

# Dimension 4: CFO Exceeds Net Income
def dimension_4_cfo_exceeds_net_income(symbol, years_back=1):
    """
    We only need years_back data points from both statements, not +1,
    because we don't compare to the previous year's CFO/NI. 
    We just compare CFO vs. NI in the same year.
    """
    limit_needed = years_back
    
    cf_url = (
        f"https://financialmodelingprep.com/api/v3/cash-flow-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    income_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )

    cf_data = requests.get(cf_url).json()
    income_data = requests.get(income_url).json()

    if len(cf_data) < limit_needed or len(income_data) < limit_needed:
        print(f"[Dimension 4] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        c = cf_data[i]
        inc = income_data[i]
        
        year_or_date = c.get("calendarYear") or c.get("date", f"N/A_{i}")
        
        cfo_current = c.get("operatingCashFlow", 0)
        net_income_current = inc.get("netIncome", 0)
        score = 1 if cfo_current > net_income_current else 0

        print(
            f"Dimension 4 (CFO > Net Income) | Year={year_or_date}: {score} => "
            f"CFO={cfo_current}, NetIncome={net_income_current}"
        )

        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_4_cfo_exceeds_net_income("MSFT", years_back=1)

# Dimension 5: Decrease in Long-Term Debt Ratio
def dimension_5_lower_leverage(symbol, years_back=1):
    """
    This dimension compares the current year to the previous year => need years_back+1 data.
    """
    limit_needed = years_back + 1
    
    bal_url = (
        f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    balance_data = requests.get(bal_url).json()

    if len(balance_data) < limit_needed:
        print(f"[Dimension 5] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        current_bal = balance_data[i]
        year_or_date = current_bal.get("calendarYear") or current_bal.get("date", f"N/A_{i}")

        ltd_current = current_bal.get("longTermDebt", 0)
        ta_current = current_bal.get("totalAssets", 0)

        if i+1 < len(balance_data):
            ltd_previous = balance_data[i+1].get("longTermDebt", 0)
            ta_previous = balance_data[i+1].get("totalAssets", 0)
        else:
            ltd_previous = 0
            ta_previous = 0

        ratio_current = ltd_current / ta_current if ta_current else 0
        ratio_previous = ltd_previous / ta_previous if ta_previous else 0

        score = 1 if ratio_current < ratio_previous else 0
        print(
            f"Dimension 5 (Lower Debt Ratio) | Year={year_or_date}: {score} => "
            f"DebtRatio_current={ratio_current:.4f}, DebtRatio_previous={ratio_previous:.4f}"
        )

        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_5_lower_leverage("MSFT", years_back=1)

# Dimension 6: Improvement in Current Ratio
def dimension_6_higher_current_ratio(symbol, years_back=1):
    """
    Need years_back+1 data to compare current ratio vs previous year.
    """
    limit_needed = years_back + 1
    
    bal_url = (
        f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    balance_data = requests.get(bal_url).json()

    if len(balance_data) < limit_needed:
        print(f"[Dimension 6] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        current_bal = balance_data[i]
        year_or_date = current_bal.get("calendarYear") or current_bal.get("date", f"N/A_{i}")

        ca_current = current_bal.get("totalCurrentAssets", 0)
        cl_current = current_bal.get("totalCurrentLiabilities", 0)
        cr_current = ca_current / cl_current if cl_current else 0

        if i+1 < len(balance_data):
            ca_previous = balance_data[i+1].get("totalCurrentAssets", 0)
            cl_previous = balance_data[i+1].get("totalCurrentLiabilities", 0)
            cr_previous = ca_previous / cl_previous if cl_previous else 0
        else:
            cr_previous = 0

        score = 1 if cr_current > cr_previous else 0
        print(
            f"Dimension 6 (Higher Current Ratio) | Year={year_or_date}: {score} => "
            f"CR_current={cr_current:.4f}, CR_previous={cr_previous:.4f}"
        )

        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_6_higher_current_ratio("MSFT", years_back=1)

# Dimension 7: No New Shares Issued
def dimension_7_no_new_shares(symbol, years_back=1):
    """
    Need years_back+1 for current vs previous
    """
    limit_needed = years_back + 1
    
    inc_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    inc_data = requests.get(inc_url).json()

    if len(inc_data) < limit_needed:
        print(f"[Dimension 7] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        current_inc = inc_data[i]
        year_or_date = current_inc.get("calendarYear") or current_inc.get("date", f"N/A_{i}")

        shares_current = current_inc.get("weightedAverageShsOut", 0)
        if i+1 < len(inc_data):
            shares_previous = inc_data[i+1].get("weightedAverageShsOut", 0)
        else:
            shares_previous = 0

        score = 1 if shares_current <= shares_previous else 0
        print(
            f"Dimension 7 (No New Shares) | Year={year_or_date}: {score} => "
            f"Shares_current={shares_current}, Shares_previous={shares_previous}"
        )
        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_7_no_new_shares("MSFT", years_back=1)

# Dimension 8: Improvement in Gross Margin
def dimension_8_improved_gross_margin(symbol, years_back=1):
    """
    Need years_back+1 because we compare GM current vs GM previous.
    """
    limit_needed = years_back + 1
    
    inc_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    inc_data = requests.get(inc_url).json()

    if len(inc_data) < limit_needed:
        print(f"[Dimension 8] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        current_inc = inc_data[i]
        year_or_date = current_inc.get("calendarYear") or current_inc.get("date", f"N/A_{i}")

        rev_current = current_inc.get("revenue", 0)
        gp_current = current_inc.get("grossProfit", 0)
        gm_current = gp_current / rev_current if rev_current else 0

        if i+1 < len(inc_data):
            rev_previous = inc_data[i+1].get("revenue", 0)
            gp_previous = inc_data[i+1].get("grossProfit", 0)
            gm_previous = gp_previous / rev_previous if rev_previous else 0
        else:
            gm_previous = 0

        score = 1 if gm_current > gm_previous else 0
        print(
            f"Dimension 8 (Gross Margin Up) | Year={year_or_date}: {score} => "
            f"GM_current={gm_current:.4f}, GM_previous={gm_previous:.4f}"
        )
        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_8_improved_gross_margin("MSFT", years_back=1)

# Dimension 9: Improvement in Asset Turnover
def dimension_9_improved_ato(symbol, years_back=1):
    """
    Need years_back+1 to compare current ATO vs previous ATO.
    """
    limit_needed = years_back + 1
    
    inc_url = (
        f"https://financialmodelingprep.com/api/v3/income-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )
    bal_url = (
        f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}"
        f"?limit={limit_needed}&period=annual&apikey={API_KEY}"
    )

    inc_data = requests.get(inc_url).json()
    bal_data = requests.get(bal_url).json()

    if len(inc_data) < limit_needed or len(bal_data) < limit_needed:
        print(f"[Dimension 9] Not enough data for {years_back} year(s).")
        return []

    results = []
    for i in range(years_back):
        inc_current = inc_data[i]
        bal_current = bal_data[i]
        year_or_date = inc_current.get("calendarYear") or inc_current.get("date", f"N/A_{i}")

        rev_current = inc_current.get("revenue", 0)
        ta_current = bal_current.get("totalAssets", 0)

        if i+1 < len(bal_data):
            ta_prev_for_cur = bal_data[i+1].get("totalAssets", 0)
        else:
            ta_prev_for_cur = 0

        avg_assets_current = (ta_current + ta_prev_for_cur) / 2 if ta_prev_for_cur else 0
        ato_current = rev_current / avg_assets_current if avg_assets_current else 0

        # Compare to previous year ATO
        if i+1 < len(inc_data) and i+2 < len(bal_data):
            # More advanced approach: compare i to i+1 and i+2, but let's keep it simpler:
            rev_previous = inc_data[i+1].get("revenue", 0)
            ta_previous = bal_data[i+1].get("totalAssets", 0)
            ato_previous = rev_previous / ta_previous if ta_previous else 0
        else:
            # Fallback
            rev_previous = 0
            ato_previous = 0

        score = 1 if ato_current > ato_previous else 0
        print(
            f"Dimension 9 (Asset Turnover Up) | Year={year_or_date}: {score} => "
            f"ATO_current={ato_current:.4f}, ATO_previous={ato_previous:.4f}"
        )
        results.append({
            "year": str(year_or_date),
            "score": score
        })
    return results

dimension_9_improved_ato("MSFT", years_back=1)

# Aggregator Over Multiple Years -> DataFrame
def calculate_piotroski_scores_over_time(symbol, years_back=5):
    """
    Calls each dimension function with `years_back` for the given symbol.
    Combines all dimension scores for each 'year index' into a single DataFrame row.

    The DataFrame has columns:
      ["year", "dim1_roa", "dim2_cfo", ..., "dim9_ato", "total_score"]

    The row at index=0 corresponds to the most recent year.
    """
    # 1) Collect dimension data
    d1_list = dimension_1_positive_roa(symbol, years_back)
    d2_list = dimension_2_positive_cfo(symbol, years_back)
    d3_list = dimension_3_improved_roa(symbol, years_back)
    d4_list = dimension_4_cfo_exceeds_net_income(symbol, years_back)
    d5_list = dimension_5_lower_leverage(symbol, years_back)
    d6_list = dimension_6_higher_current_ratio(symbol, years_back)
    d7_list = dimension_7_no_new_shares(symbol, years_back)
    d8_list = dimension_8_improved_gross_margin(symbol, years_back)
    d9_list = dimension_9_improved_ato(symbol, years_back)

    # 2) Prepare rows. We assume each list has length `years_back` or is empty if data is missing.
    rows = []
    for i in range(years_back):
        # Get the year from dimension_1 if available, else fallback
        if i < len(d1_list):
            year_str = d1_list[i]["year"]
        else:
            year_str = f"N/A_{i}"

        # Safely fetch each dimension score
        dim1 = d1_list[i]["score"] if i < len(d1_list) else 0
        dim2 = d2_list[i]["score"] if i < len(d2_list) else 0
        dim3 = d3_list[i]["score"] if i < len(d3_list) else 0
        dim4 = d4_list[i]["score"] if i < len(d4_list) else 0
        dim5 = d5_list[i]["score"] if i < len(d5_list) else 0
        dim6 = d6_list[i]["score"] if i < len(d6_list) else 0
        dim7 = d7_list[i]["score"] if i < len(d7_list) else 0
        dim8 = d8_list[i]["score"] if i < len(d8_list) else 0
        dim9 = d9_list[i]["score"] if i < len(d9_list) else 0

        total_score = sum([dim1, dim2, dim3, dim4, dim5, dim6, dim7, dim8, dim9])
        
        row = {
            "year": year_str,
            "dim1_roa": dim1,
            "dim2_cfo": dim2,
            "dim3_roa_improvement": dim3,
            "dim4_cfo_over_ni": dim4,
            "dim5_lower_debt_ratio": dim5,
            "dim6_higher_current_ratio": dim6,
            "dim7_no_new_shares": dim7,
            "dim8_gross_margin_up": dim8,
            "dim9_asset_turnover_up": dim9,
            "total_score": total_score
        }
        rows.append(row)
    
    df = pd.DataFrame(rows)
    print("\n============== Piotroski Scores DataFrame ==============")
    print(df)
    print("========================================================\n")
    
    return df

symbol = "MSFT"
calculate_piotroski_score(symbol)

Dimension 1 (Positive ROA) | Year=2024: 1 => NetIncome=88136000000, AvgAssets=462069500000, ROA=0.1907
Dimension 2 (Positive CFO) | Year=2024: 1 => CFO=118548000000
Dimension 3 (ROA Improvement) | Year=2024: 1 => ROA_current=0.1907, ROA_previous=0.1756
Dimension 4 (CFO > Net Income) | Year=2024: 1 => CFO=118548000000, NetIncome=88136000000
Dimension 5 (Lower Debt Ratio) | Year=2024: 1 => DebtRatio_current=0.1620, DebtRatio_previous=0.1713
Dimension 6 (Higher Current Ratio) | Year=2024: 0 => CR_current=1.2750, CR_previous=1.7692
Dimension 7 (No New Shares) | Year=2024: 1 => Shares_current=7431000000, Shares_previous=7446000000
Dimension 8 (Gross Margin Up) | Year=2024: 1 => GM_current=0.6976, GM_previous=0.6892
Dimension 9 (Asset Turnover Up) | Year=2024: 1 => ATO_current=0.5305, ATO_previous=0.0000
=======================================
Final Piotroski Score for MSFT = 8
=======================================

df_scores = calculate_piotroski_scores_over_time("MSFT", years_back=10)
df_scores

# Fetch stock price and merge into df_scores
def fetch_stock_prices_for_years(symbol, df_scores):
    """
    Pull the last trading day's close price of that calendar year via yfinance
    """
    import pandas as pd
    from datetime import datetime

    # Convert the 'year' to int
    df_scores["year_int"] = df_scores["year"].astype(int)
    min_year = df_scores["year_int"].min()
    max_year = df_scores["year_int"].max()

    # Download daily data from Jan 1 of min_year to Dec 31 of max_year
    start_date = f"{min_year}-01-01"
    end_date = f"{max_year}-12-31"
    ticker = yf.Ticker(symbol)
    hist = ticker.history(start=start_date, end=end_date)

    # For each year in df_scores, find last trading day's 'Close'
    year_to_price = {}
    for y in df_scores["year_int"].unique():
        # If there's data for year y
        data_y = hist.loc[str(y)]
        if data_y.empty:
            year_to_price[y] = None
        else:
            last_close = data_y["Close"].iloc[-1]
            year_to_price[y] = float(f"{last_close:.2f}")  # round to 2 decimals

    # Map back into df_scores
    df_scores["stock_price"] = df_scores["year_int"].map(year_to_price)
    return df_scores


symbol = "MSFT"

# 1) Add stock prices
df_scores = fetch_stock_prices_for_years(symbol, df_scores)

# Plot stacked bars + total_score label + stock price line
# Define dimension columns
dim_cols = [
    "dim1_roa", "dim2_cfo", "dim3_roa_improvement", 
    "dim4_cfo_over_ni", "dim5_lower_debt_ratio", 
    "dim6_higher_current_ratio", "dim7_no_new_shares", 
    "dim8_gross_margin_up", "dim9_asset_turnover_up"
]

# 1) Set 'year' as index and create a copy for plotting
df_plot = df_scores.set_index("year").copy()

# 2) Ensure dimension columns are integers
df_plot[dim_cols] = df_plot[dim_cols].astype(int)

# 3) Sort index ascending so older years are on the left
df_plot.sort_index(ascending=True, inplace=True)

# 4) Create the figure and main axis
fig, ax = plt.subplots(figsize=(20, 6))

# 5) Plot stacked bar for dimension columns
df_plot[dim_cols].plot(kind="bar", stacked=True, ax=ax, colormap="tab20")

ax.set_ylabel("Dimension Scores (Stacked)")
ax.set_title(f"Piotroski Dimensions for {symbol} + Stock Price")

# 6) Move legend outside the chart
ax.legend(bbox_to_anchor=(1.10, 1), loc="upper left", borderaxespad=0)

# 7) Annotate each bar segment (the 1's)
for container_idx, container in enumerate(ax.containers):
    for bar in container:
        if bar.get_height() > 0:  # It's a "1"
            ax.text(
                bar.get_x() + bar.get_width() / 2,
                bar.get_y() + bar.get_height() / 2,
                f"{int(bar.get_height())}",
                ha="center",
                va="center",
                color="white",
                fontsize=8
            )

# 8) Add text label on top of each bar showing total_score
for i, (idx, row) in enumerate(df_plot.iterrows()):
    total_score = row["total_score"]
    ax.text(
        i,
        total_score + 0.1,  # Slight offset above the bar
        f"Score={int(total_score)}",
        ha="center",
        va="bottom",
        color="black",
        fontsize=9,
        fontweight="bold"
    )

# 9) Create secondary axis for stock price
ax2 = ax.twinx()
ax2.set_ylabel("Stock Price (USD)")

# 10) Plot the stock price as a line
ax2.plot(
    df_plot.index, df_plot["stock_price"], 
    color="red", marker="o", markersize=5, linewidth=1.5, 
    label="Stock Price"
)

# 11) Label each stock price point next to the dot
for i, (idx, row) in enumerate(df_plot.iterrows()):
    price = row["stock_price"]
    if price is not None:
        ax2.text(
            i,
            price,
            f"{price}",
            color="red",
            ha="left",
            va="bottom",
            fontsize=8
        )

ax2.legend(loc="lower left", bbox_to_anchor=(1.10, 0))

plt.tight_layout()
plt.show()