import os
import random

import numpy as np
import torch
from torch.utils.data import Dataset

from util.icbhi_util import get_annotations, get_individual_cycles_torchaudio, cut_pad_sample_torchaudio
from util.augmentation import augment_raw_audio
from util.wave_preproc import augment_wave, condition_wave, dbfs, or_label, or_mix

# Chest location is the third field of an ICBHI filename (101_1b1_Al_sc_Meditron). 0 is unknown.
LOC_TO_ID = {'Al': 1, 'Ar': 2, 'Ll': 3, 'Lr': 4, 'Pl': 5, 'Pr': 6, 'Tc': 7}


def get_frame_pos_weights(dataset, cap=None):
    """pos_weight for crackle/wheeze BCE from train cycle counts.

    cap limits the ratio so a 98% normal file list cannot push the head
    to fire on every frame.
    """
    n = len(dataset)
    c_pos = w_pos = 0
    for i in range(n):
        label = int(dataset.audio_images[i][1])
        if label in (1, 3):
            c_pos += 1
        if label in (2, 3):
            w_pos += 1
    c_neg = n - c_pos
    w_neg = n - w_pos
    weights = {
        'crackle': c_neg / max(c_pos, 1),
        'wheeze': w_neg / max(w_pos, 1),
    }
    if cap is not None and float(cap) > 0:
        limit = float(cap)
        weights = {key: min(limit, float(value)) for key, value in weights.items()}
    return weights


class ICBHIDataset(Dataset):
    def __init__(self, train_flag, args, print_flag=True):
        random.seed(args.seed)
        np.random.seed(args.seed)
        torch.manual_seed(args.seed)

        data_folder = os.path.join(args.data_folder, 'icbhi_dataset/audio_test_data')
        folds_file = os.path.join(args.data_folder, 'icbhi_dataset/patient_list_foldwise.txt')
        official_folds_file = os.path.join(args.data_folder, 'icbhi_dataset/official_split.txt')
        test_fold = args.test_fold

        self.data_folder = data_folder
        self.train_flag = train_flag
        self.split = 'train' if train_flag else 'test'
        self.args = args
        self.sample_rate = args.sample_rate
        self.desired_length = args.desired_length
        self.pad_types = args.pad_types
        self.device_to_id = {'Meditron': 0, 'LittC2SE': 1, 'Litt3200': 2, 'AKGC417L': 3}

        cache_candidates = [
            './data/training.pt' if train_flag else './data/test.pt',
            './data/training_v3_cs0.0_ra0.pt' if train_flag else './data/test_v3_cs0.0_ra0.pt',
        ]
        cache_path = next((p for p in cache_candidates if os.path.isfile(p)), None)

        if cache_path:
            self.audio_images = torch.load(cache_path, weights_only=False)
            if print_flag:
                print('Loaded cache {}'.format(cache_path))
            self._finalize(print_flag)
            return

        annotation_dict = get_annotations(args, data_folder)
        filenames = sorted(os.listdir(data_folder))
        filenames = sorted(set(f.strip().split('.')[0] for f in filenames if f.endswith('.wav') or f.endswith('.txt')))

        self.file_to_device = {}
        for f in filenames:
            device = f.strip().split('_')[-1]
            self.file_to_device[f] = self.device_to_id[device]

        if test_fold in ['0', '1', '2', '3', '4']:
            patient_dict = {}
            for line in open(folds_file):
                idx, fold = line.strip().split(' ')
                if train_flag and int(fold) != int(test_fold):
                    patient_dict[idx] = fold
                elif not train_flag and int(fold) == int(test_fold):
                    patient_dict[idx] = fold
            if print_flag:
                print('*' * 20)
                print('Train and test 80-20% split with test_fold {}'.format(test_fold))
                print('Patient number in {} dataset: {}'.format(self.split, len(patient_dict)))
        else:
            patient_dict = {}
            for line in open(official_folds_file):
                fpath, fold = line.strip().split('\t')
                if train_flag and fold == 'train':
                    patient_dict[fpath] = fold
                elif not train_flag and fold == 'test':
                    patient_dict[fpath] = fold
            if print_flag:
                print('*' * 20)
                print('Train and test 60-40% split with test_fold {}'.format(test_fold))
                print('File number in {} dataset: {}'.format(self.split, len(patient_dict)))

        self.filenames = []
        for f in filenames:
            key = f.split('_')[0] if test_fold in ['0', '1', '2', '3', '4'] else f
            if key in patient_dict:
                self.filenames.append(f)

        if print_flag:
            print('*' * 20)
            print('Extracting individual breathing cycles..')

        cycle_list = []
        for filename in self.filenames:
            sample_data = get_individual_cycles_torchaudio(
                args, annotation_dict[filename], data_folder, filename,
                args.sample_rate, args.n_cls)
            patient_id = filename.split('_')[0]
            for cycle_idx, (audio, label) in enumerate(sample_data):
                cycle_list.append((audio, label, patient_id, filename, cycle_idx))

        self.audio_images = []
        for audio, label, patient_id, filename, _ in cycle_list:
            device_label = self.file_to_device[filename]
            parts = filename.split('_')
            loc_id = LOC_TO_ID.get(parts[2], 0) if len(parts) >= 3 else 0
            if isinstance(audio, torch.Tensor):
                wave = audio.squeeze(0) if audio.dim() > 1 else audio
            else:
                wave = torch.tensor(audio, dtype=torch.float32)
            self.audio_images.append((wave, int(label), int(device_label), int(patient_id), int(loc_id)))

        class_nums = np.zeros(args.n_cls)
        for sample in self.audio_images:
            class_nums[sample[1]] += 1
        if print_flag:
            print('[Preprocessed {} dataset information]'.format(self.split))
            print('total number of audio data: {}'.format(len(self.audio_images)))
            cls_names = getattr(args, 'cls_list', ['normal', 'crackle', 'wheeze', 'both'])
            for i, n in enumerate(class_nums):
                pct = n / max(class_nums.sum(), 1) * 100
                name = cls_names[i] if i < len(cls_names) else str(i)
                print('Class {} ({:<9}): {:<4} ({:.1f}%)'.format(i, name, int(n), pct))
        self._finalize(print_flag)

    @staticmethod
    def _as_wave(item):
        wave = item[0]
        if isinstance(wave, list):
            wave = wave[0]
        if not isinstance(wave, torch.Tensor):
            wave = torch.tensor(wave, dtype=torch.float32)
        return wave.reshape(-1).float()

    def _finalize(self, print_flag):
        """Deterministic wave conditioning (train + test) and train-only augmentation pools."""
        args = self.args
        if float(getattr(args, 'wave_highpass_hz', 0.0) or 0.0) > 0 or getattr(args, 'wave_rms_norm', None) is not None:
            before = [dbfs(self._as_wave(it)) for it in self.audio_images[:200]]
            self.audio_images = [
                (condition_wave(self._as_wave(it), args),) + tuple(it[1:]) for it in self.audio_images]
            if print_flag:
                after = [dbfs(self._as_wave(it)) for it in self.audio_images[:200]]
                print('Wave conditioning ({}): highpass {} Hz, rms_norm {} dBFS | RMS {:.1f}+-{:.1f} -> {:.1f}+-{:.1f} dBFS'.format(
                    self.split, getattr(args, 'wave_highpass_hz', 0), getattr(args, 'wave_rms_norm', None),
                    np.mean(before), np.std(before), np.mean(after), np.std(after)))

        self.normal_idx = [i for i, it in enumerate(self.audio_images) if int(it[1]) == 0]
        self.crackle_only_idx = [i for i, it in enumerate(self.audio_images) if int(it[1]) == 1]
        self.wheeze_only_idx = [i for i, it in enumerate(self.audio_images) if int(it[1]) == 2]
        self.wave_aug_p = float(getattr(args, 'wave_aug_p', 0.0) or 0.0) if self.train_flag else 0.0
        self.or_mix_p = float(getattr(args, 'or_mix_p', 0.0) or 0.0) if self.train_flag else 0.0
        if print_flag and (self.wave_aug_p > 0 or self.or_mix_p > 0):
            print('Train aug: wave_aug_p {} (normal pool {}), or_mix_p {} (crackle-only {}, wheeze-only {})'.format(
                self.wave_aug_p, len(self.normal_idx), self.or_mix_p,
                len(self.crackle_only_idx), len(self.wheeze_only_idx)))

    def __getitem__(self, index):
        item = self.audio_images[index]
        wave = item[0]
        if isinstance(wave, list):
            wave = wave[0]
        label, patient_id = int(item[1]), item[3]
        meta_cond = bool(getattr(self.args, 'meta_cond', False))
        if self.train_flag and getattr(self.args, 'raw_augment', 0) > 0:
            aug = augment_raw_audio(wave.numpy(), self.sample_rate, self.args)
            wave = torch.tensor(aug, dtype=torch.float32)
            wave = cut_pad_sample_torchaudio(wave, self.args)
        if wave.dim() > 1:
            wave = wave.squeeze(0)
        device_id = int(item[2]) if len(item) > 2 else 0
        loc_id = int(item[4]) if len(item) > 4 else None
        if self.or_mix_p > 0 and label in (1, 2) and random.random() < self.or_mix_p:
            pool = self.wheeze_only_idx if label == 1 else self.crackle_only_idx
            if pool:
                partner = self.audio_images[pool[random.randrange(len(pool))]]
                wave = or_mix(wave.float(), self._as_wave(partner))
                label = or_label(label, int(partner[1]))
        if self.wave_aug_p > 0:
            noise_pool = _NormalPool(self.audio_images, self.normal_idx, self._as_wave)
            wave = augment_wave(wave.float(), self.wave_aug_p, self.sample_rate, noise_pool)
        label_t = torch.tensor(label, dtype=torch.long)
        patient_t = torch.tensor(patient_id, dtype=torch.long)
        if meta_cond:
            if loc_id is None:
                raise RuntimeError('meta_cond requires a location id on each cycle; the wave cache has none')
            return (
                wave,
                label_t,
                patient_t,
                torch.tensor(device_id, dtype=torch.long),
                torch.tensor(loc_id, dtype=torch.long),
            )
        return wave, label_t, patient_t

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


class _NormalPool:
    """Lazy indexable view over normal-class cycles (avoids copying waves per item)."""

    def __init__(self, audio_images, indices, as_wave):
        self.audio_images, self.indices, self.as_wave = audio_images, indices, as_wave

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

    def __getitem__(self, i):
        return self.as_wave(self.audio_images[self.indices[i]])
