import pathlib
import warnings
import lightgbm as lgbm
import pandas as pd
import tqdm
import datetime
import matplotlib.pyplot as plt
import japanize_matplotlib
import seaborn as sns
import numpy as np

import sys
sys.path.append(".")
sys.path.append("..")
from src.data_manager.preprocess_tools import DataPreProcessor  # noqa
from src.data_manager.data_loader import DataLoader  # noqa

warnings.filterwarnings("ignore")

root_dir = pathlib.Path(".").absolute().parent
dbpath = root_dir / "data" / "keibadata.db"
start_year = 2000  # DBが持つ最古の年を指定
split_year = 2014  # 学習対象期間の開始年を指定
target_year = 2019  # テスト対象期間の開始年を指定
end_year = 2023  # テスト対象期間の終了年を指定 (当然DBに対象年のデータがあること)

# 各種インスタンスの作成
data_loader = DataLoader(
    start_year,
    end_year,
    dbpath=dbpath  # dbpathは各種環境に合わせてパスを指定してください。絶対パス推奨
)

dataPreP = DataPreProcessor()

df = data_loader.load_racedata()
dfblood = data_loader.load_horseblood()

df = dataPreP.exec_pipeline(
    df, dfblood, ["s", "b", "bs", "bbs", "ss", "sss", "ssss", "bbbs"])

df.columns

targetCol = "toL3F_vel"

idf = df.copy()
idf = idf[~idf["horseId"].isin(
    idf[idf["horseId"].str[:4] < "1998"]["horseId"].unique())]
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "distance", "age"])[
    targetCol].shift()
idf["mochiTime"] = idf.groupby(['horseId', "field", "distance", "age"])["mochiTime_org"].rolling(
    1000, min_periods=1).max().reset_index(level=[0, 1, 2, 3], drop=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "distance"])[
    targetCol].shift()
idf["mochiTime"].fillna(idf.groupby(['horseId', "field", "distance"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1, 2], drop=True), inplace=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "dist_cat"])[
    targetCol].shift()
idf["mochiTime"].fillna(idf.groupby(['horseId', "field", "dist_cat"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1, 2], drop=True), inplace=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field",])[
    targetCol].shift()
idf["mochiTime"].fillna(idf.groupby(['horseId', "field"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1], drop=True), inplace=True)

targetCol = "last3F_vel"

idf = idf[~idf["horseId"].isin(
    idf[idf["horseId"].str[:4] < "1998"]["horseId"].unique())]
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "distance", "age"])[
    targetCol].shift()
idf["mochiTime3F"] = idf.groupby(['horseId', "field", "distance", "age"])["mochiTime_org"].rolling(
    1000, min_periods=1).max().reset_index(level=[0, 1, 2, 3], drop=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "distance"])[
    targetCol].shift()
idf["mochiTime3F"].fillna(idf.groupby(['horseId', "field", "distance"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1, 2], drop=True), inplace=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field", "dist_cat"])[
    targetCol].shift()
idf["mochiTime3F"].fillna(idf.groupby(['horseId', "field", "dist_cat"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1, 2], drop=True), inplace=True)
idf["mochiTime_org"] = idf.groupby(['horseId', "field",])[
    targetCol].shift()
idf["mochiTime3F"].fillna(idf.groupby(['horseId', "field"])["mochiTime_org"].rolling(
    1000, min_periods=1).min().reset_index(level=[0, 1], drop=True), inplace=True)

idf2 = idf.groupby("raceId")[["velocity", "mochiTime"]].mean()
idf2.plot.scatter("velocity", "mochiTime")
plt.grid(ls=":")
plt.show()

idf["mochiRank"] = idf.groupby("raceId")["mochiTime"].rank(ascending=False)
idfdes = pd.concat(
    [
        idf[idf["mochiRank"] < 2]["label"].value_counts().rename("top1") /
        len(idf[idf["mochiRank"] < 2]),
        idf[idf["mochiRank"] >= 2]["label"].value_counts().rename(
            "other")/len(idf[idf["mochiRank"] >= 2]),
    ],
    axis=1
).T
display(idfdes)
idfdes.T.plot()
plt.grid(ls=":")
plt.show()

idf["mochiRank"] = idf.groupby("raceId")["mochiTime"].rank(ascending=False)
idf["mochiRank"] = idf["mochiRank"].apply(
    lambda d: d if pd.isna(d) else int(d))

idfdes = pd.concat(
    [
        idf[idf["mochiRank"].isin([i])]["label"].value_counts().rename(f"top{i}") /
        len(idf[idf["mochiRank"].isin([i])])
        for i in range(1, 6)
    ] + [
        idf[idf["mochiRank"] >= 6]["label"].value_counts().rename(
            "other")/len(idf[idf["mochiRank"] >= 6])
    ],
    axis=1
).T
display(idfdes)
idfdes.T.plot()
plt.grid(ls=":")
plt.show()

idf["mochiRank"] = idf.groupby("raceId")["mochiTime"].rank(ascending=False)
idf["mochiRank"] = idf["mochiRank"].apply(
    lambda d: d if pd.isna(d) else int(d))

idfdes = pd.concat(
    [
        idf[idf["mochiRank"].isin([i])]["favorite"].value_counts().rename(f"top{i}") /
        len(idf[idf["mochiRank"].isin([i])])
        for i in range(1, 6)
    ] + [
        idf[idf["mochiRank"] >= 6]["favorite"].value_counts().rename(
            "other")/len(idf[idf["mochiRank"] >= 6])
    ],
    axis=1
).T
display(idfdes)
idfdes.T.plot()
plt.grid(ls=":")
plt.show()

idfpace = idf.drop_duplicates(
    "raceId", ignore_index=True)  # 処理しやすいように重複を削除しておく

idfpace[["raceId", "rapTime"]]

idfpace["rapTime2"] = idfpace[["rapTime", "distance"]].apply(
    lambda row: row["rapTime"] if row["distance"] % 200 == 0
    else [round(row["rapTime"][0]*200/(row["distance"] % 200), 1)] + row["rapTime"][1:], axis=1)
idfpace[idfpace["distance"].isin([1150])][["rapTime", "rapTime2"]]

idfpace["prePace"] = idfpace["rapTime2"].apply(
    lambda lst: np.mean(lst[:(len(lst)-3)//2]))
idfpace["pastPace"] = idfpace["rapTime2"].apply(
    lambda lst: np.mean(lst[(len(lst)-3)//2:-3]))
idfpace["prePace3F"] = idfpace["rapTime2"].apply(
    lambda lst: np.mean(lst[:-3]))
idfpace["pastPace3F"] = idfpace["rapTime2"].apply(
    lambda lst: np.mean(lst[-3:]))
idfpace[["raceId", "rapTime2", "prePace", "pastPace"]]

xcol = "prePace3F"
ycol = "pastPace3F"

plt.figure(figsize=(20, 8))
for n, f in enumerate(["芝", "ダ"], start=0):
    for m, d in enumerate("SMILE", start=1):
        idfp = idfpace[idfpace["field"].isin(
            [f]) & idfpace["dist_cat"].isin([d]) & ~idfpace["raceId"].str[:4].isin(["2024", "2023", "2022"])]
        if len(idfp) == 0:
            continue
        # region plot
        minV = min(idfp[ycol].min(), idfp[xcol].min())
        plt.subplot(2, 5, int(5*n+m))
        sns.scatterplot(
            idfp,
            x=xcol,
            y=ycol,
            label=f"{f}-{d}",
            edgecolors="black", facecolors="none"
        )
        plt.hlines(
            idfp[ycol].median(),
            xmin=minV-0.25,
            xmax=idfp[xcol].max()+0.25,
            colors="red",
            linestyles=":"
        )
        plt.xlim(
            left=minV-0.25,
            right=idfp[xcol].max()+0.25
        )
        plt.vlines(
            idfp[xcol].median(),
            ymin=minV-0.25,
            ymax=idfp[ycol].max()+0.25,
            colors="red",
            linestyles=":"
        )
        plt.ylim(
            bottom=minV-0.25,
            top=idfp[ycol].max()+0.25
        )
        plt.grid(ls=":")
        # endregion
plt.tight_layout()
plt.show()

# 出力結果は省略する
if 0:
    for d in ['函館', '福島', '新潟', '東京', '中山', '中京', '京都', '阪神', '小倉', '札幌', ]:
        print("競馬場:", d)
        plt.figure(figsize=(15, 6))
        for n, f in enumerate(["芝", "ダ"], start=0):
            for m, dist in enumerate("SMILE", start=1):
                idfp = idfpace[idfpace["field"].isin(
                    [f]) & idfpace["place"].isin([d]) & ~idfpace["raceId"].str[:4].isin(
                        ["2024", "2023", "2022"]) & idfpace["dist_cat"].isin([dist])
                ]
                if len(idfp) == 0:
                    continue
                # region plot
                minV = min(idfp[ycol].min(), idfp[xcol].min())
                plt.subplot(2, 5, int(5*n+m))
                sns.scatterplot(
                    idfp,
                    x=xcol,
                    y=ycol,
                    label=f"{f}-{dist}",
                    edgecolors="black", facecolors="none"
                )
                plt.hlines(
                    idfp[ycol].median(),
                    xmin=minV-0.25,
                    xmax=idfp[xcol].max()+0.25,
                    colors="red",
                    linestyles=":"
                )
                plt.xlim(
                    left=minV-0.25,
                    right=idfp[xcol].max()+0.25
                )
                plt.vlines(
                    idfp[xcol].median(),
                    ymin=minV-0.25,
                    ymax=idfp[ycol].max()+0.25,
                    colors="red",
                    linestyles=":"
                )
                plt.ylim(
                    bottom=minV-0.25,
                    top=idfp[ycol].max()+0.25
                )
                plt.grid(ls=":")
                plt.legend(loc="best")
                # endregion
        plt.tight_layout()
        plt.show()

idfvel = idf.groupby("raceId")[
    ["last3F_vel", "toL3F_vel", "velocity", "mochiTime", "mochiTime3F"]].mean().rename(columns=lambda x: f"{x}_mean").reset_index()
idfvel = pd.merge(idfpace[[
                  "raceId", "prePace", "prePace3F", "pastPace", "pastPace3F",]], idfvel, on="raceId")

idfvel.corr().loc[["mochiTime_mean", "mochiTime3F_mean"]]

idf["vel_lag1"] = idf.groupby("horseId")["velocity"].shift()
idf["l3Fvel_lag1"] = idf.groupby("horseId")["last3F_vel"].shift()
idf["t3Fvel_lag1"] = idf.groupby("horseId")["toL3F_vel"].shift()
idf[["velocity", "last3F_vel", "toL3F_vel", "vel_lag1",
     "l3Fvel_lag1", "t3Fvel_lag1", "mochiTime", "mochiTime3F"]].corr().loc[
    ["vel_lag1", "l3Fvel_lag1", "t3Fvel_lag1", "mochiTime", "mochiTime3F"]][["velocity", "last3F_vel", "toL3F_vel"]]

idfp = pd.merge(
    idf[["raceId",]+list(set(idf.columns) - set(idfvel.columns))],
    idfvel[["raceId", "last3F_vel_mean", "toL3F_vel_mean",
            "mochiTime_mean", "mochiTime3F_mean"]],
    on="raceId"
)
idfp

idfp["mochiTime_diff"] = idfp["mochiTime"] - idfp["mochiTime_mean"]
idfp["mochiTime3F_diff"] = idfp["mochiTime3F"] - idfp["mochiTime3F_mean"]
idfp["last3F_diff"] = idfp["last3F_vel"] - idfp["last3F_vel_mean"]
idfp["toL3F_diff"] = idfp["toL3F_vel"] - idfp["toL3F_vel_mean"]

idfp[["last3F_diff", "toL3F_diff", "mochiTime_diff", "mochiTime3F_diff"]].corr(
).loc[["mochiTime_diff", "mochiTime3F_diff"]][["last3F_diff", "toL3F_diff"]]

from sklearn.cluster import KMeans  # KMeans法のモジュールをインポート

for col in ["label_1C", "label_lastC"]:
    idfp[f"{col}_rate"] = (idfp[col].astype(
        int)/idfp["horseNum"]).convert_dtypes()

# クラスタ数
n_cls = 4
rate = 2.5
# クラスタリングする特徴量を選定
cluster_columns = ["label_1C_rate", "label_lastC_rate"]
cluster_columns2 = ["label_1C_rate", "label_lastC_rate2"]
kmeans = KMeans(n_clusters=n_cls)  # 脚質が4種類なので、クラス数を4とする
idfp["label_lastC_rate2"] = rate*idfp["label_lastC_rate"]

# 後でクラスタ中心を振り直すが、形式上一旦fitしておかないといけない。
kmeans.fit(idfp[cluster_columns2].iloc[:n_cls*2])