from os import environ, path
from transformers import BertTokenizerFast, FlaxAutoModel
import jax.numpy as jnp
import jax
from flax.training.train_state import TrainState
import pandas as pd
from tyrec.trainer import BaseTrainer, loss, HFConfig
from tyrec.recommendations.model import RecommendationModel
from tyrec.utils import compute_mean, logger
from tyrec.evaluator import RetrivalEvaluator
from tyrec.utils import trange


class RecommendationsTrainer(BaseTrainer):
    def __init__(
        self,
        hf_config: HFConfig,
        data_dir,
        event_to_train,
        threshold=0,
        dimensions=0,
        other_features=False,
        *args,
        **kwargs,
    ):
        self.model_name = hf_config.model_name
        self.data_dir = data_dir
        self.query_prompt = hf_config.query_prompt
        self.doc_prompt = hf_config.doc_prompt
        self.event_to_train = event_to_train
        self.other_features = other_features
        self.text_encoder = FlaxAutoModel.from_pretrained(self.model_name)
        self.tokenizer = BertTokenizerFast.from_pretrained(self.model_name)
        self.base_path = (
            "/content/drive/MyDrive/"
            if "COLAB_ENV" in environ and environ["COLAB_ENV"] == "true"
            else "./"
        )
        self.train_file = path.join(self.base_path, data_dir, "train.jsonl")
        self.eval_file = path.join(self.base_path, data_dir, "test.jsonl")
        self.items_file = path.join(self.base_path, data_dir, "items.jsonl")
        self.item_embeddings_file = path.join(
            self.base_path, data_dir, "item_embeds.jsonl"
        )
        self.train_user_embeddings_file = path.join(
            self.base_path, data_dir, "train_user_embeds.jsonl"
        )
        self.test_user_embeddings_file = path.join(
            self.base_path, data_dir, "test_user_embeds.jsonl"
        )
        self.dimensions = (
            dimensions if dimensions > 0 else self.text_encoder.config.hidden_size
        )
        model = RecommendationModel(self.dimensions)
        super().__init__(*args, model=model, **kwargs)
        self.dataloader = pd.read_json(self.train_file, lines=True)
        self.dataloader = self.dataloader[
            self.dataloader["event"] == self.event_to_train
        ].reset_index(drop=True)
        self.test_dataset = pd.read_json(self.eval_file, lines=True)
        self.test_dataset = self.test_dataset[
            self.test_dataset["event"] == self.event_to_train
        ].reset_index(drop=True)
        unique_did = (
            pd.concat([self.dataloader, self.test_dataset], ignore_index=True)["did"]
            .unique()
            .tolist()
        )
        self.items = pd.read_json(self.items_file, lines=True)
        self.items = self.items[self.items["did"].isin(unique_did)].reset_index(
            drop=True
        )
        self.threshold = threshold
        self.evaluator: RetrivalEvaluator | None = None
        self.item_embeds = []
        self.train_user_embeds = []
        self.train_label_embeds = []
        self.test_user_embeds = []
        self.test_label_embeds = []
        self.rng = jax.random.PRNGKey(0)

    def embed_items(self, examples):
        texts = [self.doc_prompt + x for x in examples["text"].tolist()]
        tokens = self.tokenizer(
            texts,
            truncation=True,
            padding="max_length",
            return_tensors="jax",
            max_length=70,
        )
        embeddings = self.text_encoder(**tokens).last_hidden_state
        embeddings = self.mean_pooling(embeddings, tokens["attention_mask"])
        embeddings = embeddings / jnp.linalg.norm(embeddings, axis=-1, keepdims=True)
        if self.other_features:
            embeddings = [embeddings[i] for i in range(embeddings.shape[0])]
            features = examples["features"].tolist()
            for i in range(len(embeddings)):
                embeddings[i] = jnp.concatenate([embeddings[i], jnp.array(features[i])])
            embeddings = jnp.array(embeddings)
        return [embeddings[i] for i in range(embeddings.shape[0])]

    def embed_events(self, df):
        user_vecs = []
        label_vecs = []
        for _, row in df.iterrows():
            label = self.items[self.items["did"] == row["label"]["did"]].index.tolist()[
                0
            ]
            history = [x["did"] for x in row["data"]]
            multi_hot = [0] * len(self.item_embeds)
            indexes = (
                self.items[self.items["did"].isin(history)]
                .index.reindex(
                    self.items[self.items["did"].isin(history)]["did"]
                    .map(dict(zip(history, range(len(history)))))
                    .sort_values()
                    .index
                )[0]
                .tolist()
            )
            for idx in indexes:
                multi_hot[idx] = 1
            multi_hot = jnp.array(multi_hot)
            user_vecs.append(compute_mean(self.item_embeds, multi_hot))
            label_vecs.append(label)
        return jnp.array(user_vecs), jnp.array(label_vecs)

    def group_events(self, df):
        df = df.sort_values(["sid", "ts"])

        def group_to_dict_array(to_dict):
            return to_dict.drop(["sid", "event"], axis=1).to_dict("records")

        grouped_data = []
        for (sid,), group in df.groupby(["sid"]):
            data = group_to_dict_array(group)
            if len(data) > 2:
                grouped_data.append(
                    {
                        "sid": sid,
                        "data": data[:-1],
                        "label": data[-1],
                    }
                )
        grouped_data = pd.DataFrame(grouped_data)
        return grouped_data

    @staticmethod
    def users_to_sessions(file_path, threshold):
        df = pd.read_json(file_path, lines=True)
        if threshold > 0:

            def create_intervals(group):
                group = group.copy()
                group["time_diff"] = group["ts"].diff()
                group["interval"] = (group["time_diff"] > threshold).cumsum()
                return group.drop("time_diff", axis=1)

            df_list = [create_intervals(group) for _, group in df.groupby("sid")]
            df = pd.concat(df_list, ignore_index=True)
        else:
            df["interval"] = 0

        return df

    def load_item_embeddings(self):
        item_embeds = pd.read_json(self.item_embeddings_file, lines=True)
        item_with_embeds = pd.merge(self.items, item_embeds, on="did", how="left")
        return [jnp.array(x) for x in item_with_embeds["embed"]]

    def load_user_embeddings(self, df, file_path):
        user_embeds = pd.read_json(file_path, lines=True)
        user_with_embeds = pd.merge(df, user_embeds, on="sid", how="left")
        return jnp.array([jnp.array(x) for x in user_with_embeds["embed"]]), jnp.array(
            [
                self.items[self.items["did"] == x["did"]].index.tolist()[0]
                for x in user_with_embeds["label"]
            ]
        )

    def setup(self):
        corpus = {
            f"{self.items.loc[x]['did']}": self.items.loc[x]["text"]
            for x in range(len(self.items))
        }
        if path.exists(self.item_embeddings_file):
            logger.info("Found a saved item embedding file...")
            self.item_embeds = self.load_item_embeddings()
        else:
            for start in trange(0, len(self.items), 128, desc="Embedding items"):
                end = min(start + 128, len(self.items))
                e = self.embed_items(self.items.loc[start : end - 1])
                self.item_embeds.extend(e)
        self.item_embeds = jnp.array(self.item_embeds)
        self.dataloader = self.group_events(self.dataloader)
        self.dataset_len = len(self.dataloader)
        self.test_dataset = self.group_events(self.test_dataset)
        self.dataset_len = len(self.dataloader)

        if path.exists(self.train_user_embeddings_file):
            logger.info("Found a saved train embedding file...")
            self.train_user_embeds, self.train_label_embeds = self.load_user_embeddings(
                self.dataloader, self.train_user_embeddings_file
            )
        else:
            self.train_user_embeds, self.train_label_embeds = self.embed_events(
                self.dataloader
            )

        if path.exists(self.test_user_embeddings_file):
            logger.info("Found a saved test embedding file...")
            self.test_user_embeds, self.test_label_embeds = self.load_user_embeddings(
                self.test_dataset, self.test_user_embeddings_file
            )
        else:
            self.test_user_embeds, self.test_label_embeds = self.embed_events(
                self.test_dataset
            )
        users = {
            f"{self.test_dataset.loc[x]['sid']}": self.test_dataset.loc[x]["sid"]
            for x in range(len(self.test_dataset))
        }
        relevant_docs = {
            f"{self.test_dataset.loc[x]['sid']}": [
                f"{self.test_dataset.loc[x]['label']['did']}"
            ]
            for x in range(len(self.test_dataset))
        }
        self.evaluator = RetrivalEvaluator(
            queries=users,
            corpus=corpus,
            relevant_docs=relevant_docs,
            corpus_chunk_size=40000,
            batch_size=512,
            show_progress_bar=True,
        )

    def get_initial_params(self):
        batch = jnp.array([jnp.zeros(self.text_encoder.config.hidden_size)])
        params = self.model.init(jax.random.PRNGKey(0), batch, batch, training=False)
        return params["params"]

    def train_step(self, _batch, start, end):
        self.rng, rng = jax.random.split(self.rng)
        batch = jax.random.permutation(rng, jnp.array(self.train_user_embeds))[
            start:end
        ]
        labels = jax.random.permutation(rng, jnp.array(self.train_label_embeds))[
            start:end
        ]
        user_vec = jnp.array(batch)
        items_vec = jnp.array(self.item_embeds)
        state, l = train_step(self.state, user_vec, items_vec, labels, rng)
        q, d = self.model.apply(
            {"params": self.state.params},
            jnp.array(self.test_user_embeds),
            jnp.array(self.item_embeds),
            training=False,
            rngs=rng,
        )
        q = q / jnp.linalg.norm(q, axis=1, keepdims=True)
        d = d / jnp.linalg.norm(d, axis=1, keepdims=True)
        val_l = loss.sparse_categorical_cross_entropy(
            q,
            d,
            self.test_label_embeds,
        )
        self.val_loss.append(val_l)
        return state, l

    def eval_step(self):
        q, d = self.model.apply(
            {"params": self.state.params},
            jnp.array(self.test_user_embeds),
            jnp.array(self.item_embeds),
            training=False,
        )
        q = q / jnp.linalg.norm(q, axis=1, keepdims=True)
        d = d / jnp.linalg.norm(d, axis=1, keepdims=True)
        self.evaluator(query_embeddings=q, corpus_embeddings=d, metrics=["recall"])


@jax.jit
def train_step(state: TrainState, user_embeds, item_embeds, labels, rng):
    def loss_fn(params):
        u = user_embeds / jnp.linalg.norm(user_embeds, axis=-1, keepdims=True)
        i = item_embeds / jnp.linalg.norm(item_embeds, axis=-1, keepdims=True)
        u, i = state.apply_fn(
            {"params": params},
            u,
            i,
            training=True,
            rngs={"dropout": rng},
        )
        u = u / jnp.linalg.norm(u, axis=-1, keepdims=True)
        i = i / jnp.linalg.norm(i, axis=-1, keepdims=True)
        l = loss.sparse_categorical_cross_entropy(u, i, labels)
        return l

    grad_fn = jax.value_and_grad(loss_fn)
    l, grads = grad_fn(state.params)
    state = state.apply_gradients(grads=grads)
    return state, l