import gradio as gr
import pandas as pd
import duckdb
import logging


from scripts.metrics import (
    compute_weekly_metrics_by_market_creator,
    compute_daily_metrics_by_market_creator,
    compute_winning_metrics_by_trader,
)
from tabs.trader_plots import (
    plot_trader_metrics_by_market_creator,
    plot_trader_daily_metrics_by_market_creator,
    default_trader_metric,
    trader_metric_choices,
    get_metrics_text,
    plot_winning_metric_per_trader,
    get_interpretation_text,
    plot_total_bet_amount,
)
from tabs.daily_graphs import (
    get_current_week_data,
    plot_daily_metrics,
    trader_daily_metric_choices,
    default_daily_metric,
)
from scripts.utils import get_traders_family
from tabs.market_plots import (
    plot_kl_div_per_market,
    plot_total_bet_amount_per_trader_per_market,
)


def get_logger():
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    # stream handler and formatter
    stream_handler = logging.StreamHandler()
    stream_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    stream_handler.setFormatter(formatter)
    logger.addHandler(stream_handler)
    return logger


logger = get_logger()


def get_all_data():
    """
    Get parquet files from weekly stats and new generated
    """
    logger.info("Getting traders data")
    con = duckdb.connect(":memory:")
    # Query to fetch data from all_trades_profitability.parquet
    query1 = f"""
    SELECT *
    FROM read_parquet('./data/all_trades_profitability.parquet')
    """
    df1 = con.execute(query1).fetchdf()
    logger.info("Got all data from all_trades_profitability.parquet")

    # Query to fetch data from closed_markets_div.parquet
    query2 = f"""
    SELECT *
    FROM read_parquet('./data/closed_markets_div.parquet')
    """
    df2 = con.execute(query2).fetchdf()
    logger.info("Got all data from closed_markets_div.parquet")

    # Query to fetch daily live data
    query3 = f"""
    SELECT *
    FROM read_parquet('./data/daily_info.parquet')
    """
    df3 = con.execute(query3).fetchdf()
    con.close()

    return df1, df2, df3


def prepare_data():

    all_trades, closed_markets, daily_info = get_all_data()

    all_trades["creation_date"] = all_trades["creation_timestamp"].dt.date

    # nr-trades variable
    volume_trades_per_trader_and_market = (
        all_trades.groupby(["trader_address", "title"])["roi"]
        .count()
        .reset_index(name="nr_trades_per_market")
    )

    trader_agents_data = pd.merge(
        all_trades, volume_trades_per_trader_and_market, on=["trader_address", "title"]
    )
    daily_info["creation_date"] = daily_info["creation_timestamp"].dt.date
    # adding the trader family column
    trader_agents_data["trader_family"] = trader_agents_data.apply(
        lambda x: get_traders_family(x), axis=1
    )
    print(trader_agents_data.head())

    trader_agents_data = trader_agents_data.sort_values(
        by="creation_timestamp", ascending=True
    )

    trader_agents_data["month_year_week"] = (
        trader_agents_data["creation_timestamp"].dt.to_period("W").dt.strftime("%b-%d")
    )

    closed_markets["month_year_week"] = (
        closed_markets["opening_datetime"].dt.to_period("W").dt.strftime("%b-%d")
    )
    return trader_agents_data, closed_markets, daily_info


trader_agents_data, closed_markets, daily_info = prepare_data()

demo = gr.Blocks()
# get weekly metrics by market creator: qs, pearl or all.
weekly_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
    trader_agents_data
)

weekly_agent_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
    trader_agents_data, trader_filter="agent"
)
weekly_non_agent_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
    trader_agents_data, trader_filter="non_agent"
)

weekly_winning_metrics = compute_winning_metrics_by_trader(
    trader_agents_data=trader_agents_data
)
weekly_agent_winning_metrics = compute_winning_metrics_by_trader(
    trader_agents_data=trader_agents_data, trader_filter="agent"
)
weekly_non_agent_winning_metrics = compute_winning_metrics_by_trader(
    trader_agents_data=trader_agents_data, trader_filter="non_agent"
)

with demo:
    gr.HTML("<h1>Trader agents monitoring dashboard </h1>")
    gr.Markdown(
        "This app shows the weekly performance of the trader agents in Olas Predict."
    )

    with gr.Tabs():
        with gr.TabItem("🔥 Weekly metrics"):
            with gr.Row():
                gr.Markdown("# Weekly metrics of all traders")
            with gr.Row():
                trader_details_selector = gr.Dropdown(
                    label="Select a weekly trader metric",
                    choices=trader_metric_choices,
                    value=default_trader_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    trader_markets_plot = plot_trader_metrics_by_market_creator(
                        metric_name=default_trader_metric,
                        traders_df=weekly_metrics_by_market_creator,
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text()

            def update_trader_details(trader_detail):
                return plot_trader_metrics_by_market_creator(
                    metric_name=trader_detail,
                    traders_df=weekly_metrics_by_market_creator,
                )

            trader_details_selector.change(
                update_trader_details,
                inputs=trader_details_selector,
                outputs=trader_markets_plot,
            )
            # Agentic traders graph
            with gr.Row():
                gr.Markdown("# Weekly metrics of trader Agents 🤖")
            with gr.Row():
                trader_a_details_selector = gr.Dropdown(
                    label="Select a weekly trader metric",
                    choices=trader_metric_choices,
                    value=default_trader_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    a_trader_markets_plot = plot_trader_metrics_by_market_creator(
                        metric_name=default_trader_metric,
                        traders_df=weekly_agent_metrics_by_market_creator,
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text()

            def update_a_trader_details(trader_detail):
                return plot_trader_metrics_by_market_creator(
                    metric_name=trader_detail,
                    traders_df=weekly_agent_metrics_by_market_creator,
                )

            trader_a_details_selector.change(
                update_a_trader_details,
                inputs=trader_a_details_selector,
                outputs=a_trader_markets_plot,
            )

            # Non-agentic traders graph
            with gr.Row():
                gr.Markdown("# Weekly metrics of Non-agent traders")
            with gr.Row():
                trader_na_details_selector = gr.Dropdown(
                    label="Select a weekly trader metric",
                    choices=trader_metric_choices,
                    value=default_trader_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    na_trader_markets_plot = plot_trader_metrics_by_market_creator(
                        metric_name=default_trader_metric,
                        traders_df=weekly_non_agent_metrics_by_market_creator,
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text()

            def update_na_trader_details(trader_detail):
                return plot_trader_metrics_by_market_creator(
                    metric_name=trader_detail,
                    traders_df=weekly_non_agent_metrics_by_market_creator,
                )

            trader_na_details_selector.change(
                update_na_trader_details,
                inputs=trader_na_details_selector,
                outputs=na_trader_markets_plot,
            )
        with gr.TabItem("📅 Daily metrics"):
            current_week_trades = get_current_week_data(trades_df=trader_agents_data)
            live_trades_current_week = get_current_week_data(trades_df=daily_info)
            if len(current_week_trades) > 0:
                daily_prof_metrics_by_market_creator = (
                    compute_daily_metrics_by_market_creator(current_week_trades)
                )
            else:
                print("No profitability info about the current week")
                daily_prof_metrics_by_market_creator = pd.DataFrame()
            live_metrics_by_market_creator = compute_daily_metrics_by_market_creator(
                live_trades_current_week, trader_filter=None, live_metrics=True
            )

            with gr.Row():
                gr.Markdown("# Daily live metrics for all trades")
            with gr.Row():
                trade_live_details_selector = gr.Dropdown(
                    label="Select a daily live metric",
                    choices=trader_daily_metric_choices,
                    value=default_daily_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    trade_live_details_plot = plot_daily_metrics(
                        metric_name=default_daily_metric,
                        trades_df=live_metrics_by_market_creator,
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text(daily=True)

            def update_trade_live_details(trade_detail, trade_live_details_plot):
                new_a_plot = plot_daily_metrics(
                    metric_name=trade_detail, trades_df=live_metrics_by_market_creator
                )
                return new_a_plot

            trade_live_details_selector.change(
                update_trade_live_details,
                inputs=[trade_live_details_selector, trade_live_details_plot],
                outputs=[trade_live_details_plot],
            )

            with gr.Row():
                gr.Markdown("# Daily live metrics for trader Agents 🤖")
            with gr.Row():
                a_trader_live_details_selector = gr.Dropdown(
                    label="Select a daily live metric",
                    choices=trader_daily_metric_choices,
                    value=default_daily_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    a_trader_live_details_plot = plot_daily_metrics(
                        metric_name=default_daily_metric,
                        trades_df=live_metrics_by_market_creator,
                        trader_filter="agent",
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text(daily=True)

            def update_a_trader_live_details(trade_detail, a_trader_live_details_plot):
                a_trader_plot = plot_daily_metrics(
                    metric_name=trade_detail,
                    trades_df=live_metrics_by_market_creator,
                    trader_filter="agent",
                )
                return a_trader_plot

            a_trader_live_details_selector.change(
                update_a_trader_live_details,
                inputs=[a_trader_live_details_selector, a_trader_live_details_plot],
                outputs=[a_trader_live_details_plot],
            )
            with gr.Row():
                gr.Markdown("# Daily live metrics for Non-agent traders")
            with gr.Row():
                na_trader_live_details_selector = gr.Dropdown(
                    label="Select a daily live metric",
                    choices=trader_daily_metric_choices,
                    value=default_daily_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    na_trader_live_details_plot = plot_daily_metrics(
                        metric_name=default_daily_metric,
                        trades_df=live_metrics_by_market_creator,
                        trader_filter="non_agent",
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_metrics_text(daily=True)

            def update_na_trader_live_details(
                trade_detail, na_trader_live_details_plot
            ):
                na_trader_plot = plot_daily_metrics(
                    metric_name=trade_detail,
                    trades_df=live_metrics_by_market_creator,
                    trader_filter="non_agent",
                )
                return na_trader_plot

            na_trader_live_details_selector.change(
                update_na_trader_live_details,
                inputs=[na_trader_live_details_selector, na_trader_live_details_plot],
                outputs=[na_trader_live_details_plot],
            )

            # with gr.Row():
            #     gr.Markdown("# Daily profitability metrics available for all trades")
            # if len(current_week_trades) > 0:
            #     with gr.Row():
            #         trader_daily_details_selector = gr.Dropdown(
            #             label="Select a daily trade metric",
            #             choices=trader_metric_choices,
            #             value=default_trader_metric,
            #         )

            #     with gr.Row():
            #         with gr.Column(scale=3):
            #             trader_daily_details_plot = plot_daily_metrics(
            #                 metric_name=default_trader_metric,
            #                 trades_df=daily_prof_metrics_by_market_creator,
            #             )
            #         with gr.Column(scale=1):
            #             trader_details_text = get_metrics_text(daily=True)

            #     def update_trader_daily_details(
            #         trade_detail, trader_daily_details_plot
            #     ):
            #         new_a_plot = plot_daily_metrics(
            #             metric_name=trade_detail,
            #             trades_df=daily_prof_metrics_by_market_creator,
            #         )
            #         return new_a_plot

            #     trader_daily_details_selector.change(
            #         update_trader_daily_details,
            #         inputs=[trader_daily_details_selector, trader_daily_details_plot],
            #         outputs=[trader_daily_details_plot],
            #     )
            # else:
            #     gr.Markdown("Data not available yet")

        with gr.TabItem("📉 Markets Kullback–Leibler divergence"):
            with gr.Row():
                gr.Markdown(
                    "# Weekly Market Prediction Accuracy for Closed Markets (Kullback-Leibler Divergence)"
                )
            with gr.Row():
                gr.Markdown(
                    "Aka, how much off is the market prediction’s accuracy from the real outcome of the event. Values capped at 20 for market outcomes completely opposite to the real outcome."
                )
            with gr.Row():
                trade_details_text = get_metrics_text()
            with gr.Row():
                with gr.Column(scale=3):
                    kl_div_plot = plot_kl_div_per_market(closed_markets=closed_markets)
                with gr.Column(scale=1):
                    interpretation = get_interpretation_text()

        with gr.TabItem("💰 Money invested per trader type"):
            with gr.Row():
                gr.Markdown("# Weekly total bet amount per trader type for all markets")
            with gr.Row():
                total_bet_amount = plot_total_bet_amount(
                    trader_agents_data, market_filter="all"
                )

            with gr.Row():
                gr.Markdown(
                    "# Weekly total bet amount per trader type for Pearl markets"
                )
            with gr.Row():
                a_trader_total_bet_amount = plot_total_bet_amount(
                    trader_agents_data, market_filter="pearl"
                )

            with gr.Row():
                gr.Markdown(
                    "# Weekly total bet amount per trader type for Quickstart markets"
                )
            with gr.Row():
                na_trader_total_bet_amount = plot_total_bet_amount(
                    trader_agents_data, market_filter="quickstart"
                )
        with gr.TabItem("💰 Money invested per market"):
            with gr.Row():
                gr.Markdown("# Weekly bet amounts per market for all traders")
            with gr.Row():
                bet_amounts = plot_total_bet_amount_per_trader_per_market(
                    trader_agents_data
                )

            with gr.Row():
                gr.Markdown("# Weekly bet amounts per market for traders Agents 🤖")
            with gr.Row():
                a_trader_bet_amounts = plot_total_bet_amount_per_trader_per_market(
                    trader_agents_data, trader_filter="agent"
                )

            with gr.Row():
                gr.Markdown("# Weekly bet amounts per market for Non-agent traders")
            with gr.Row():
                na_trader_bet_amounts = plot_total_bet_amount_per_trader_per_market(
                    trader_agents_data, trader_filter="non_agent"
                )

        with gr.TabItem("🎖️Weekly winning trades % per trader"):
            with gr.Row():
                gr.Markdown("# Weekly winning trades percentage from all traders")
            with gr.Row():
                metrics_text = get_metrics_text()
            with gr.Row():
                winning_metric = plot_winning_metric_per_trader(weekly_winning_metrics)

            # Agentic traders
            with gr.Row():
                gr.Markdown("# Weekly winning trades percentage from traders Agents")
            with gr.Row():
                metrics_text = get_metrics_text()
            with gr.Row():
                winning_metric = plot_winning_metric_per_trader(
                    weekly_agent_winning_metrics
                )

            # Non_agentic traders
            with gr.Row():
                gr.Markdown("# Weekly winning trades percentage from Non-agent traders")
            with gr.Row():
                metrics_text = get_metrics_text()
            with gr.Row():
                winning_metric = plot_winning_metric_per_trader(
                    weekly_non_agent_winning_metrics
                )

demo.queue(default_concurrency_limit=40).launch()