import torch
import math
import os
import random
import eegdash
print(dir(eegdash))
import time
from joblib import Parallel, delayed
from torch.utils.data import DataLoader
from pathlib import Path
from torch import optim
from torch.nn.functional import l1_loss
from braindecode.preprocessing import create_fixed_length_windows
from braindecode.datasets.base import EEGWindowsDataset, BaseConcatDataset, BaseDataset
#from braindecode.models import EEGNeX
from eegdash import EEGChallengeDataset

MAX_RETRIES = 10                   # number of retry attempts per file\\


# ------------------------------------------------
# Helper functions
# ------------------------------------------------
def dataset_exists(release: str, cache_dir: Path) -> bool:
    """Check if dataset folder for this release already exists."""
    release_dir = cache_dir / release
    required_files = [
        release_dir / "dataset_description.json",
        release_dir / "participants.tsv",
    ]
    return release_dir.exists() and all(f.exists() for f in required_files)

def ensure_resume_download_s3(cache_dir: Path):
    """Make sure partially downloaded files are resumed instead of re-downloaded."""
    print("🔄 Enabling S3 resume logic...")
    # fsspec/S3fs will automatically resume downloads if local file exists & size < expected
    # But ensure the directory has read/write permissions
    os.system(f"chmod -R 777 {cache_dir}")

# ----------------------------------------
# Helper function for resilient download
# ----------------------------------------
def safe_load_raw(dataset_obj, attempt=1):
    """Safely load a raw EEG dataset with retry logic."""
    try:
        raw = dataset_obj.raw
        return raw
    except Exception as e:
        if attempt < MAX_RETRIES:
            print(f"⚠️ [Retry {attempt}/{MAX_RETRIES}] Error loading {dataset_obj}: {e}")
            time.sleep(10 * attempt)  # exponential backoff
            return safe_load_raw(dataset_obj, attempt + 1)
        else:
            print(f"❌ Failed to load {dataset_obj} after {MAX_RETRIES} retries.")
            return None

start_time = time.time()

device = "cuda" if torch.cuda.is_available() else "cpu"
if device == "cuda":
    msg = "CUDA-enabled GPU found. Training should be faster."
else:
    msg = (
        "No GPU found. Training will be carried out on CPU, which might be "
        "slower.\n\nIf running on Google Colab, you can request a GPU runtime by"
        " clicking\n`Runtime/Change runtime type` in the top bar menu, then "
        "selecting 'T4 GPU'\nunder 'Hardware accelerator'."
    )
print(msg)

import os
os.environ["EEGDASH_CACHE_DIR"] = "~/disk_3tb/eeg_challenge/challenge_2/data"

# The first step is to define the cache folder!
DATA_DIR = Path("~/disk_3tb/eeg_challenge/challenge_2/data")

# Creating the path if it does not exist
DATA_DIR.mkdir(parents=True, exist_ok=True)

ensure_resume_download_s3(DATA_DIR)

# We define the list of releases to load.
# Here, only release 5 is loaded.
release_list = ["R5"]

loaded_datasets = []
for release in release_list:
    release_dir = DATA_DIR / release
    if dataset_exists(release, DATA_DIR):
        print(f"✅ {release} already cached in {release_dir}, skipping new download.")
    else:
        print(f"⬇️ Downloading {release} into {release_dir} (resume enabled)...")

    ds = EEGChallengeDataset(
        release=release,
        task="contrastChangeDetection",
        mini=False,
        description_fields=[
            "subject", "session", "run", "task", "age",
            "gender", "sex", "p_factor"
        ],
        cache_dir=DATA_DIR,
    )
    loaded_datasets.append(ds)

print("Datasets loaded")

sub_rm = ["NDARWV769JM7", "NDARME789TD2", "NDARUA442ZVF", "NDARJP304NK1",
          "NDARTY128YLU", "NDARDW550GU6", "NDARLD243KRE", "NDARUJ292JXV", "NDARBA381JGH"]

all_datasets = BaseConcatDataset(loaded_datasets)
print(all_datasets.description)

raws = Parallel(n_jobs=os.cpu_count())(
    #delayed(lambda d: d.raw)(d) for d in all_datasets.datasets
    delayed(safe_load_raw)(d, MAX_RETRIES) for d in all_datasets.datasets
)

# Filter out failed loads
raws = [r for r in raws if r is not None]

# raw = all_datasets.datasets[0].raw  # mne.io.Raw object
# print(raw.info)
# raw.plot(duration=10, scalings="auto", show=True)

# print(raw.annotations)

SFREQ = 100

class DatasetWrapper(BaseDataset):
    def __init__(
        self,
        dataset: EEGWindowsDataset,
        crop_size_samples: int,
        target_name: str = "externalizing",
        seed=None,
    ):
        self.dataset = dataset
        self.crop_size_samples = crop_size_samples
        self.target_name = target_name
        self.rng = random.Random(seed)

    def __len__(self):
        return len(self.dataset)

    def __getitem__(self, index):
        X, _, crop_inds = self.dataset[index]

        target = self.dataset.description[self.target_name]
        target = float(target)

        # Additional information:
        infos = {
            "subject": self.dataset.description["subject"],
            "sex": self.dataset.description["sex"],
            "age": float(self.dataset.description["age"]),
            "task": self.dataset.description["task"],
            "session": self.dataset.description.get("session", None) or "",
            "run": self.dataset.description.get("run", None) or "",
        }

        # Randomly crop the signal to the desired length:
        i_window_in_trial, i_start, i_stop = crop_inds
        #assert i_stop - i_start >= self.crop_size_samples, f"{i_stop=} {i_start=}"
        start_offset = self.rng.randint(0, i_stop - i_start - self.crop_size_samples)
        i_start = i_start + start_offset
        i_stop = i_start + self.crop_size_samples
        X = X[:, start_offset : start_offset + self.crop_size_samples]

        return X, target, (i_window_in_trial, i_start, i_stop), infos

# Filter out recordings that are too short
all_datasets = BaseConcatDataset(
    [
        ds
        for ds in all_datasets.datasets
        if not ds.description.subject in sub_rm
        and ds.raw.n_times >= 4 * SFREQ
        and len(ds.raw.ch_names) == 129
        and not math.isnan(ds.description["p_factor"])
    ]
)

# Create 4-seconds windows with 2-seconds stride
windows_ds = create_fixed_length_windows(
    all_datasets,
    window_size_samples=4 * SFREQ,
    window_stride_samples=2 * SFREQ,
    drop_last_window=True,
)

# Wrap each sub-dataset in the windows_ds
windows_ds = BaseConcatDataset(
    [DatasetWrapper(ds, crop_size_samples=2 * SFREQ) for ds in windows_ds.datasets]
)

print(windows_ds)

# Initialize model
#model = EEGNeX(n_chans=129, n_outputs=1, n_times=2 * SFREQ).to(device)

# Specify optimizer
#optimizer = optim.Adamax(params=model.parameters(), lr=0.002)

#print(model)

# Create PyTorch Dataloader

#from torch.utils.data import DataLoader

num_workers = 0  # We are using a single worker, but you can increase this for faster data loading
dataloader = DataLoader(windows_ds, batch_size=128, shuffle=True, num_workers=num_workers)

import numpy as np

Xs, ys = [], []

for X, y, crop_inds, infos in dataloader:
    X = X.to(dtype=torch.float32, device=device)
    y = y.to(dtype=torch.float32, device=device).unsqueeze(1)
    Xs.append(X.cpu().numpy())
    ys.append(y.cpu().numpy())

# Concatenate along the batch axis
Xs = np.concatenate(Xs, axis=0)
ys = np.concatenate(ys, axis=0)

np.savez_compressed("r5_full.npz", Xs=Xs, ys=ys)

print("✅ Saved r5_full.npz")

end_time = time.time()

completion_time = end_time - start_time

print("Time to complete datasets: {:.2f} seconds".format(completion_time))

#train_set = np.load("r5.npz", allow_pickle=True)
