import argparse
import json
import logging
import os
import random
from pathlib import Path
from typing import Any, Dict, List, Optional, Sequence, Tuple

import numpy as np
import pandas as pd
import torch
import wandb
from torch.utils.data import Dataset
from transformers import (
    AutoModelForMaskedLM,
    AutoTokenizer,
    Trainer,
    TrainingArguments,
)
from transformers.trainer_utils import get_last_checkpoint


logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

BUCKET_TOKENS = {"low": "<sp0>", "mid": "<sp1>", "high": "<sp2>"}
BUCKET_IDS = {"low": 0, "mid": 1, "high": 2}
DNA_BASES = ("A", "C", "G", "T")


def parse_args():
    parser = argparse.ArgumentParser(
        description="Train a bucket-conditioned masked discrete diffusion baseline on DeepSTARR."
    )
    parser.add_argument("--model_name", type=str, required=True)
    parser.add_argument("--dataset_dir", type=str, required=True)
    parser.add_argument("--output_dir", type=str, default="checkpoints/deepstarr_discrete_diffusion")
    parser.add_argument("--saved_model_dir", type=str, default="saved_model/deepstarr_discrete_diffusion")
    parser.add_argument("--sequence_col", type=str, default="sequence")
    parser.add_argument("--label_col", type=str, default="label")
    parser.add_argument("--score_mode", type=str, default="sum", choices=["sum", "mean", "label_0", "label_1", "max"])
    parser.add_argument("--low_quantile", type=float, default=0.25)
    parser.add_argument("--high_quantile", type=float, default=0.75)
    parser.add_argument("--conditioned", action="store_true", help="Prefix each sequence with <low>/<mid>/<high>.")
    parser.add_argument("--max_length", type=int, default=256)
    parser.add_argument("--num_train_epochs", type=float, default=3)
    parser.add_argument("--batch_size", type=int, default=32)
    parser.add_argument("--gradient_accumulation_steps", type=int, default=1)
    parser.add_argument("--learning_rate", type=float, default=5e-5)
    parser.add_argument("--weight_decay", type=float, default=0.01)
    parser.add_argument("--warmup_ratio", type=float, default=0.03)
    parser.add_argument("--logging_steps", type=int, default=20)
    parser.add_argument("--save_steps", type=int, default=1000)
    parser.add_argument("--eval_steps", type=int, default=1000)
    parser.add_argument("--save_total_limit", type=int, default=3)
    parser.add_argument("--mask_prob_min", type=float, default=0.05)
    parser.add_argument("--mask_prob_max", type=float, default=0.95)
    parser.add_argument("--num_diffusion_steps", type=int, default=64)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--bf16", action="store_true")
    parser.add_argument("--fp16", action="store_true")
    parser.add_argument("--gradient_checkpointing", action="store_true")
    parser.add_argument("--report_to", type=str, default="wandb")
    parser.add_argument("--wandb_project", type=str, default="GENERanno-diffusion")
    parser.add_argument("--run_name", type=str, default="deepstarr_discrete_diffusion")
    parser.add_argument("--resume", action="store_true", help="Resume from the latest checkpoint in output_dir.")
    return parser.parse_args()


def setup_wandb(args):
    targets = {item.strip().lower() for item in str(args.report_to).split(",")}
    if "wandb" not in targets:
        return None
    if "WANDB_MODE" not in os.environ:
        os.environ["WANDB_MODE"] = "offline"
    return wandb.init(project=args.wandb_project, name=args.run_name, config=vars(args), reinit=True)


def normalize_label(value: Any) -> List[float]:
    if hasattr(value, "tolist"):
        value = value.tolist()
    if isinstance(value, str):
        value = json.loads(value)
    if not isinstance(value, (list, tuple)) or len(value) < 2:
        raise ValueError(f"Expected a 2D label, got {value!r}")
    return [float(value[0]), float(value[1])]


def compute_activity_score(label: Sequence[float], mode: str) -> float:
    if mode == "sum":
        return float(label[0] + label[1])
    if mode == "mean":
        return float((label[0] + label[1]) / 2.0)
    if mode == "label_0":
        return float(label[0])
    if mode == "label_1":
        return float(label[1])
    if mode == "max":
        return float(max(label[0], label[1]))
    raise ValueError(f"Unsupported score_mode: {mode}")


def assign_bucket(score: float, low_threshold: float, high_threshold: float) -> str:
    if score <= low_threshold:
        return "low"
    if score >= high_threshold:
        return "high"
    return "mid"


def load_split(dataset_dir: str, split: str) -> pd.DataFrame:
    path = Path(dataset_dir) / f"{split}.parquet"
    if not path.exists():
        raise FileNotFoundError(f"Missing split file: {path}")
    return pd.read_parquet(path)


def prepare_splits(args) -> Tuple[pd.DataFrame, pd.DataFrame, Dict[str, Any]]:
    train_df = load_split(args.dataset_dir, "train")
    valid_df = load_split(args.dataset_dir, "valid")

    train_scores = train_df[args.label_col].map(
        lambda value: compute_activity_score(normalize_label(value), args.score_mode)
    )
    low_threshold = float(train_scores.quantile(args.low_quantile))
    high_threshold = float(train_scores.quantile(args.high_quantile))

    def enrich(df: pd.DataFrame, split: str) -> pd.DataFrame:
        out = df.copy()
        out["activity_score"] = out[args.label_col].map(
            lambda value: compute_activity_score(normalize_label(value), args.score_mode)
        )
        out["activity_bucket"] = out["activity_score"].map(
            lambda score: assign_bucket(score, low_threshold, high_threshold)
        )
        out["condition_token"] = out["activity_bucket"].map(BUCKET_TOKENS)
        out["condition_id"] = out["activity_bucket"].map(BUCKET_IDS)
        out["source_split"] = split
        out[args.sequence_col] = out[args.sequence_col].astype(str).str.strip().str.upper()
        return out

    metadata = {
        "dataset_dir": args.dataset_dir,
        "score_mode": args.score_mode,
        "low_quantile": args.low_quantile,
        "high_quantile": args.high_quantile,
        "low_threshold": low_threshold,
        "high_threshold": high_threshold,
    }
    return enrich(train_df, "train"), enrich(valid_df, "valid"), metadata


class DeepSTARRDiffusionDataset(Dataset):
    def __init__(self, df: pd.DataFrame, sequence_col: str, conditioned: bool):
        self.df = df.reset_index(drop=True)
        self.sequence_col = sequence_col
        self.conditioned = conditioned

    def __len__(self):
        return len(self.df)

    def __getitem__(self, index):
        row = self.df.iloc[index]
        sequence = str(row[self.sequence_col]).strip().upper()
        if self.conditioned:
            sequence = str(row["condition_token"]) + sequence
        return {
            "text": sequence,
            "activity_bucket": str(row["activity_bucket"]),
            "condition_token": str(row["condition_token"]),
            "activity_score": float(row["activity_score"]),
        }


class DiscreteDiffusionCollator:
    def __init__(
        self,
        tokenizer,
        max_length: int,
        mask_prob_min: float,
        mask_prob_max: float,
        num_diffusion_steps: int,
        maskable_token_ids: Sequence[int],
    ):
        self.tokenizer = tokenizer
        self.max_length = max_length
        self.mask_prob_min = mask_prob_min
        self.mask_prob_max = mask_prob_max
        self.num_diffusion_steps = num_diffusion_steps
        self.maskable_token_ids = set(int(x) for x in maskable_token_ids if x is not None and int(x) >= 0)
        self.mask_token_id = tokenizer.mask_token_id
        if self.mask_token_id is None:
            raise ValueError("Tokenizer must define a mask token for masked discrete diffusion training.")

    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
        texts = [feature["text"] for feature in features]
        enc = self.tokenizer(
            texts,
            add_special_tokens=True,
            padding=True,
            truncation=True,
            max_length=self.max_length,
            return_tensors="pt",
        )
        enc.pop("token_type_ids", None)
        input_ids = enc["input_ids"]
        attention_mask = enc["attention_mask"]
        labels = torch.full_like(input_ids, -100)

        can_mask = torch.zeros_like(input_ids, dtype=torch.bool)
        for token_id in self.maskable_token_ids:
            can_mask |= input_ids == token_id
        can_mask &= attention_mask.bool()

        for row_idx in range(input_ids.size(0)):
            positions = torch.nonzero(can_mask[row_idx], as_tuple=False).flatten()
            if positions.numel() == 0:
                continue
            t = random.randint(1, self.num_diffusion_steps)
            ratio = t / float(self.num_diffusion_steps)
            mask_prob = self.mask_prob_min + (self.mask_prob_max - self.mask_prob_min) * ratio
            selected = positions[torch.rand(positions.numel()) < mask_prob]
            if selected.numel() == 0:
                selected = positions[torch.randint(positions.numel(), (1,))]
            labels[row_idx, selected] = input_ids[row_idx, selected]
            input_ids[row_idx, selected] = self.mask_token_id

        enc["input_ids"] = input_ids
        enc["labels"] = labels
        return enc


def maybe_add_condition_tokens(tokenizer, model, conditioned: bool):
    if not conditioned:
        return []
    added = tokenizer.add_special_tokens({"additional_special_tokens": list(BUCKET_TOKENS.values())})
    if added:
        model.resize_token_embeddings(len(tokenizer))
        logger.info("Added %d conditioning tokens to tokenizer and resized embeddings.", added)
    return list(BUCKET_TOKENS.values())


def get_maskable_token_ids(tokenizer) -> List[int]:
    token_ids = []
    for base in DNA_BASES:
        token_id = tokenizer.convert_tokens_to_ids(base)
        if token_id is None or token_id == tokenizer.unk_token_id:
            encoded = tokenizer(base, add_special_tokens=False)["input_ids"]
            if len(encoded) == 1:
                token_id = encoded[0]
        if token_id is None or token_id == tokenizer.unk_token_id:
            raise ValueError(f"Could not resolve tokenizer id for DNA base {base!r}.")
        token_ids.append(int(token_id))
    return sorted(set(token_ids))


def save_run_summary(args, metadata: Dict[str, Any], trainer: Trainer, tokenizer, maskable_token_ids: Sequence[int]):
    output_path = Path(args.saved_model_dir)
    output_path.mkdir(parents=True, exist_ok=True)
    summary = {
        "args": vars(args),
        "metadata": metadata,
        "best_model_checkpoint": trainer.state.best_model_checkpoint,
        "best_metric": trainer.state.best_metric,
        "maskable_token_ids": list(maskable_token_ids),
        "mask_token_id": tokenizer.mask_token_id,
    }
    with open(output_path / "run_summary.json", "w", encoding="utf-8") as f:
        json.dump(summary, f, indent=2, ensure_ascii=False)


def main():
    args = parse_args()
    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)

    setup_wandb(args)
    train_df, valid_df, metadata = prepare_splits(args)

    tokenizer = AutoTokenizer.from_pretrained(args.model_name, trust_remote_code=True)
    model = AutoModelForMaskedLM.from_pretrained(args.model_name, trust_remote_code=True)
    maybe_add_condition_tokens(tokenizer, model, args.conditioned)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token or tokenizer.mask_token
    if args.gradient_checkpointing:
        model.gradient_checkpointing_enable()

    maskable_token_ids = get_maskable_token_ids(tokenizer)
    train_dataset = DeepSTARRDiffusionDataset(train_df, args.sequence_col, args.conditioned)
    valid_dataset = DeepSTARRDiffusionDataset(valid_df, args.sequence_col, args.conditioned)
    collator = DiscreteDiffusionCollator(
        tokenizer=tokenizer,
        max_length=args.max_length,
        mask_prob_min=args.mask_prob_min,
        mask_prob_max=args.mask_prob_max,
        num_diffusion_steps=args.num_diffusion_steps,
        maskable_token_ids=maskable_token_ids,
    )

    training_args = TrainingArguments(
        output_dir=args.output_dir,
        num_train_epochs=args.num_train_epochs,
        per_device_train_batch_size=args.batch_size,
        per_device_eval_batch_size=args.batch_size,
        gradient_accumulation_steps=args.gradient_accumulation_steps,
        learning_rate=args.learning_rate,
        weight_decay=args.weight_decay,
        warmup_ratio=args.warmup_ratio,
        logging_steps=args.logging_steps,
        save_steps=args.save_steps,
        eval_steps=args.eval_steps,
        save_strategy="steps",
        eval_strategy="steps",
        save_total_limit=args.save_total_limit,
        load_best_model_at_end=True,
        metric_for_best_model="eval_loss",
        greater_is_better=False,
        bf16=args.bf16,
        fp16=args.fp16,
        report_to=args.report_to,
        run_name=args.run_name,
        remove_unused_columns=False,
        dataloader_num_workers=4,
    )

    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset,
        eval_dataset=valid_dataset,
        data_collator=collator,
        processing_class=tokenizer,
    )

    resume_from_checkpoint: Optional[str] = None
    if args.resume:
        resume_from_checkpoint = get_last_checkpoint(args.output_dir)
        if resume_from_checkpoint:
            logger.info("Resuming from checkpoint: %s", resume_from_checkpoint)

    train_result = trainer.train(resume_from_checkpoint=resume_from_checkpoint)
    trainer.save_metrics("train", train_result.metrics)
    eval_metrics = trainer.evaluate()
    trainer.save_metrics("eval", eval_metrics)

    Path(args.saved_model_dir).mkdir(parents=True, exist_ok=True)
    trainer.save_model(args.saved_model_dir)
    tokenizer.save_pretrained(args.saved_model_dir)
    save_run_summary(args, metadata, trainer, tokenizer, maskable_token_ids)
    logger.info("Saved diffusion model to %s", args.saved_model_dir)


if __name__ == "__main__":
    main()