from dataloader_fast import FastHAC
from mmaction.apis import init_recognizer
import torch
import argparse
import tqdm
import os
import numpy as np
import torch.nn as nn
import random
from VGGSound.model import AVENet
from VGGSound.models.resnet import AudioAttGenModule
from VGGSound.test import get_arguments
from dataloader_HAC import HACDOMAIN
import torch.nn.functional as F
from losses import SupConLoss
from pid_loss import PIDProjectionHeads, PIDSplittingLoss


def train_one_step(clip, labels, flow, spectrogram, epoch_i):
    labels = labels.cuda()
    if args.use_video:
        clip = clip['imgs'].cuda().squeeze(1)
    if args.use_flow:
        flow = flow['imgs'].cuda().squeeze(1)
    if args.use_audio:
        spectrogram = spectrogram.unsqueeze(1).cuda()

    # ── Feature extraction (backbone frozen beyond layer4) ────────────────
    with torch.no_grad():
        if args.use_flow:
            f_feat = model_flow.module.backbone.get_feature(flow)
        if args.use_video:
            x_slow, x_fast = model.module.backbone.get_feature(clip)
            v_feat = (x_slow.detach(), x_fast.detach())
        if args.use_audio:
            _, audio_feat, _ = audio_model(spectrogram)

    # ── Trainable heads ────────────────────────────────────────────────────
    if args.use_video:
        v_feat = model.module.backbone.get_predict(v_feat)
        predict1, v_emd = model.module.cls_head(v_feat)   # (N, 2304)
        v_dim = v_emd.shape[1] // 2                       # 1152

    if args.use_flow:
        f_feat = model_flow.module.backbone.get_predict(f_feat.detach())
        f_predict, f_emd = model_flow.module.cls_head(f_feat)  # (N, 2048)
        f_dim = f_emd.shape[1] // 2                            # 1024

    if args.use_audio:
        audio_predict, audio_emd = audio_cls_model(audio_feat.detach())  # (N, 512)
        a_dim = audio_emd.shape[1] // 2                                   # 256

    # ── Split embeddings into shared / unique halves ──────────────────────
    # Naming: *_s = shared (first half), *_u = unique (second half)
    if args.use_video:
        v_s = v_emd[:, :v_dim];    v_u = v_emd[:, v_dim:]
    if args.use_audio:
        a_s = audio_emd[:, :a_dim]; a_u = audio_emd[:, a_dim:]
    if args.use_flow:
        f_s = f_emd[:, :f_dim];    f_u = f_emd[:, f_dim:]

    # ── Classification ─────────────────────────────────────────────────────
    if args.use_video and args.use_flow and args.use_audio:
        feat = torch.cat((v_emd, audio_emd, f_emd), dim=1)
    elif args.use_video and args.use_flow:
        feat = torch.cat((v_emd, f_emd), dim=1)
    elif args.use_video and args.use_audio:
        feat = torch.cat((v_emd, audio_emd), dim=1)
    elif args.use_flow and args.use_audio:
        feat = torch.cat((f_emd, audio_emd), dim=1)

    predict = mlp_cls(feat)
    loss = criterion(predict, labels)

    # ── Cross-modal Translation (unchanged from original) ──────────────────
    if args.use_video and args.use_flow and args.use_audio:
        a_emd_t  = mlp_v2a(v_emd)
        v_emd_t  = mlp_a2v(audio_emd)
        f_emd_t  = mlp_v2f(v_emd)
        v_emd_t2 = mlp_f2v(f_emd)
        a_emd_t2 = mlp_f2a(f_emd)
        f_emd_t2 = mlp_a2f(audio_emd)

        def _n(x): return x / torch.norm(x, dim=1, keepdim=True)
        def _tl(t, r): return torch.mean(torch.norm(_n(t) - _n(r), dim=1))

        trans_loss = (
            _tl(a_emd_t,  audio_emd) + _tl(v_emd_t,  v_emd) +
            _tl(f_emd_t,  f_emd)     + _tl(a_emd_t2, audio_emd) +
            _tl(v_emd_t2, v_emd)     + _tl(f_emd_t2, f_emd)
        ) / 6.0
        loss = loss + args.alpha_trans * trans_loss

    elif args.use_video and args.use_flow:
        def _n(x): return x / torch.norm(x, dim=1, keepdim=True)
        f_emd_t  = mlp_v2f(v_emd)
        v_emd_t2 = mlp_f2v(f_emd)
        trans_loss = (
            torch.mean(torch.norm(_n(f_emd_t) - _n(f_emd), dim=1)) +
            torch.mean(torch.norm(_n(v_emd_t2) - _n(v_emd), dim=1))
        ) / 2.0
        loss = loss + args.alpha_trans * trans_loss

    elif args.use_video and args.use_audio:
        def _n(x): return x / torch.norm(x, dim=1, keepdim=True)
        a_emd_t = mlp_v2a(v_emd)
        v_emd_t = mlp_a2v(audio_emd)
        trans_loss = (
            torch.mean(torch.norm(_n(a_emd_t) - _n(audio_emd), dim=1)) +
            torch.mean(torch.norm(_n(v_emd_t) - _n(v_emd), dim=1))
        ) / 2.0
        loss = loss + args.alpha_trans * trans_loss

    elif args.use_flow and args.use_audio:
        def _n(x): return x / torch.norm(x, dim=1, keepdim=True)
        a_emd_t2 = mlp_f2a(f_emd)
        f_emd_t2 = mlp_a2f(audio_emd)
        trans_loss = (
            torch.mean(torch.norm(_n(a_emd_t2) - _n(audio_emd), dim=1)) +
            torch.mean(torch.norm(_n(f_emd_t2) - _n(f_emd), dim=1))
        ) / 2.0
        loss = loss + args.alpha_trans * trans_loss

    # ── Supervised Contrastive Learning on shared halves (unchanged) ───────
    if args.use_video:
        v_emd_proj = v_proj(v_s)
    if args.use_audio:
        a_emd_proj = a_proj(a_s)
    if args.use_flow:
        f_emd_proj = f_proj(f_s)

    if args.use_video and args.use_flow and args.use_audio:
        emd_proj = torch.stack([v_emd_proj, a_emd_proj, f_emd_proj], dim=1)
    elif args.use_video and args.use_flow:
        emd_proj = torch.stack([v_emd_proj, f_emd_proj], dim=1)
    elif args.use_video and args.use_audio:
        emd_proj = torch.stack([v_emd_proj, a_emd_proj], dim=1)
    elif args.use_flow and args.use_audio:
        emd_proj = torch.stack([f_emd_proj, a_emd_proj], dim=1)

    loss_contrast = criterion_contrast(emd_proj, labels)
    loss = loss + args.alpha_contrast * loss_contrast

    # ── PID Splitting Loss  (replaces geometric L_dis) ─────────────────────
    pid_log = {}
    if args.use_pid and (epoch_i >= args.pid_warmup_epochs):
        # Convert labels to one-hot float for covariance computation
        Y_onehot = F.one_hot(labels, num_classes=7).float()  # (N, 7)

        pid_loss, pid_log = pid_criterion(
            v_shared = v_s if args.use_video else None,
            v_unique = v_u if args.use_video else None,
            a_shared = a_s if args.use_audio else None,
            a_unique = a_u if args.use_audio else None,
            f_shared = f_s if args.use_flow  else None,
            f_unique = f_u if args.use_flow  else None,
            # Y_onehot = Y_onehot,
        )
        loss = loss + args.alpha_pid * pid_loss

    else:
        # ── Fallback: keep original geometric distance loss ────────────────
        # This runs for the first `pid_warmup_epochs` epochs so the encoder
        # stabilises before PID gradients are introduced.
        loss_e   = torch.tensor(0.0, device=labels.device)
        num_loss = 0
        if args.use_video:
            loss_e   = loss_e - F.mse_loss(v_s, v_u)
            num_loss += 1
        if args.use_audio:
            loss_e   = loss_e - F.mse_loss(a_s, a_u)
            num_loss += 1
        if args.use_flow:
            loss_e   = loss_e - F.mse_loss(f_s, f_u)
            num_loss += 1
        loss = loss + args.explore_loss_coeff * loss_e / num_loss

    optim.zero_grad()
    loss.backward()
    optim.step()

    return predict, loss, pid_log


# =============================================================================
# Validation / test step  (no gradient, no PID)
# =============================================================================

def validate_one_step(clip, labels, flow, spectrogram):
    if args.use_video:
        clip = clip['imgs'].cuda().squeeze(1)
    labels = labels.cuda()
    if args.use_flow:
        flow = flow['imgs'].cuda().squeeze(1)
    if args.use_audio:
        spectrogram = spectrogram.unsqueeze(1).type(torch.FloatTensor).cuda()

    with torch.no_grad():
        if args.use_video:
            x_slow, x_fast = model.module.backbone.get_feature(clip)
            v_feat = (x_slow.detach(), x_fast.detach())
            v_feat = model.module.backbone.get_predict(v_feat)
            predict1, v_emd = model.module.cls_head(v_feat)
        if args.use_audio:
            _, audio_feat, _ = audio_model(spectrogram)
            audio_predict, audio_emd = audio_cls_model(audio_feat.detach())
        if args.use_flow:
            f_feat = model_flow.module.backbone.get_feature(flow)
            f_feat = model_flow.module.backbone.get_predict(f_feat)
            f_predict, f_emd = model_flow.module.cls_head(f_feat)

        if args.use_video and args.use_flow and args.use_audio:
            feat = torch.cat((v_emd, audio_emd, f_emd), dim=1)
        elif args.use_video and args.use_flow:
            feat = torch.cat((v_emd, f_emd), dim=1)
        elif args.use_video and args.use_audio:
            feat = torch.cat((v_emd, audio_emd), dim=1)
        elif args.use_flow and args.use_audio:
            feat = torch.cat((f_emd, audio_emd), dim=1)

        predict = mlp_cls(feat)

    loss = criterion(predict, labels)
    return predict, loss


class Encoder(nn.Module):
    def __init__(self, input_dim=2816, out_dim=8, hidden=512):
        super(Encoder, self).__init__()
        self.enc_net = nn.Sequential(
          nn.Linear(input_dim, hidden),
          nn.ReLU(),
          nn.Dropout(p=0.5),
          nn.Linear(hidden, out_dim)
        )
        
    def forward(self, feat):
        return self.enc_net(feat)

class EncoderTrans(nn.Module):
    def __init__(self, input_dim=2816, out_dim=8, hidden=512):
        super(EncoderTrans, self).__init__()
        self.enc_net = nn.Sequential(
            nn.Linear(input_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(hidden, out_dim)
        )
        
    def forward(self, feat):
        feat = self.enc_net(feat)
        return feat

class ProjectHead(nn.Module):
    def __init__(self, input_dim=2816, hidden_dim=2048, out_dim=128):
        super(ProjectHead, self).__init__()
        self.head = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.BatchNorm1d(hidden_dim),
                nn.ReLU(inplace=True),
                nn.Linear(hidden_dim, hidden_dim),
                nn.BatchNorm1d(hidden_dim),
                nn.ReLU(inplace=True),
                nn.Linear(hidden_dim, out_dim)
            )
        
    def forward(self, feat):
        feat = F.normalize(self.head(feat), dim=1)
        return feat


if __name__ == '__main__':

    parser = argparse.ArgumentParser()

    # ── Data / domain ──────────────────────────────────────────────────────
    parser.add_argument('-s', '--source_domain', nargs='+',
                        help='Source domains', required=True)
    parser.add_argument('-t', '--target_domain', nargs='+',
                        help='Target domain',  required=True)
    parser.add_argument('--datapath', type=str, default='./data/')

    # ── Training ──────────────────────────────────────────────────────────
    parser.add_argument('--lr',      type=float, default=1e-4)
    parser.add_argument('--bsz',     type=int,   default=16)
    parser.add_argument('--nepochs', type=int,   default=15)
    parser.add_argument('--seed',    type=int,   default=42)

    # ── Loss weights (original SimMMDG) ──────────────────────────────────
    parser.add_argument('--alpha_contrast',    type=float, default=3.0)
    parser.add_argument('--alpha_trans',       type=float, default=0.1)
    parser.add_argument('--explore_loss_coeff',type=float, default=0.7,
                        help='Weight on geometric L_dis (used only during warmup)')
    parser.add_argument('--temp',              type=float, default=0.1)

    # ── PID loss (new) ────────────────────────────────────────────────────
    parser.add_argument('--use_pid',         action='store_true',
                        help='Replace L_dis with PID splitting loss after warmup')
    parser.add_argument('--alpha_pid',       type=float, default=0.7,
                        help='Overall weight on L_pid (replaces explore_loss_coeff)')
    parser.add_argument('--alpha_pid_shared',type=float, default=1.0,
                        help='Weight on L_shared = -R(V_s, A_s; Y)')
    parser.add_argument('--alpha_pid_unique',type=float, default=1.0,
                        help='Weight on L_unique = -U1 -U2 + gamma*R')
    parser.add_argument('--pid_gamma',       type=float, default=0.5,
                        help='gamma: redundancy penalty inside L_unique')
    parser.add_argument('--pid_proj_dim',    type=int,   default=6,
                        help='Projection dim before MI estimation. '
                             'Must be < bsz/2 for full-rank covariance.')
    parser.add_argument('--pid_warmup_epochs', type=int, default=3,
                        help='Epochs to run geometric L_dis before switching to PID')

    # ── Network dims ──────────────────────────────────────────────────────
    parser.add_argument('--trans_hidden_num', type=int, default=2048)
    parser.add_argument('--hidden_dim',       type=int, default=2048)
    parser.add_argument('--out_dim',          type=int, default=128)

    # ── Checkpointing ────────────────────────────────────────────────────
    parser.add_argument('--save_checkpoint', action='store_true')
    parser.add_argument('--save_best',       action='store_true')
    parser.add_argument('--resumef',         action='store_true')
    parser.add_argument('--BestEpoch',       type=int,   default=0)
    parser.add_argument('--BestAcc',         type=float, default=0)
    parser.add_argument('--BestTestAcc',     type=float, default=0)
    parser.add_argument('--appen',           type=str,   default='')

    # ── Modality flags ───────────────────────────────────────────────────
    parser.add_argument('--use_video', action='store_true')
    parser.add_argument('--use_audio', action='store_true')
    parser.add_argument('--use_flow',  action='store_true')

    args = parser.parse_args()

    # ── Reproducibility ───────────────────────────────────────────────────
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)
    random.seed(args.seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark     = False

    # ── Model configs ─────────────────────────────────────────────────────
    config_file       = 'configs/recognition/slowfast/slowfast_r101_8x8x1_256e_kinetics400_rgb.py'
    checkpoint_file   = 'pretrained_models/slowfast_r101_8x8x1_256e_kinetics400_rgb_20210218-0dd54025.pth'
    config_file_flow  = 'configs/recognition/slowonly/slowonly_r50_8x8x1_256e_kinetics400_flow.py'
    checkpoint_file_flow = 'pretrained_models/slowonly_r50_8x8x1_256e_kinetics400_flow_20200704-6b384243.pth'

    device     = torch.device('cuda:0')
    input_dim  = 0
    cfg        = None
    cfg_flow   = None

    # ── Build encoders ────────────────────────────────────────────────────
    if args.use_video:
        model = init_recognizer(config_file, checkpoint_file,
                                device=device, use_frames=True)
        model.cls_head.fc_cls = nn.Linear(2304, 7).cuda()
        cfg   = model.cfg
        model = torch.nn.DataParallel(model)
        v_proj = ProjectHead(input_dim=1152,
                             hidden_dim=args.hidden_dim,
                             out_dim=args.out_dim).cuda()
        input_dim += 2304

    if args.use_flow:
        model_flow = init_recognizer(config_file_flow, checkpoint_file_flow,
                                     device=device, use_frames=True)
        model_flow.cls_head.fc_cls = nn.Linear(2048, 7).cuda()
        cfg_flow   = model_flow.cfg
        model_flow = torch.nn.DataParallel(model_flow)
        f_proj = ProjectHead(input_dim=1024,
                             hidden_dim=args.hidden_dim,
                             out_dim=args.out_dim).cuda()
        input_dim += 2048

    if args.use_audio:
        audio_args  = get_arguments()
        audio_model = AVENet(audio_args)
        checkpoint  = torch.load('pretrained_models/vggsound_avgpool.pth.tar')
        audio_model.load_state_dict(checkpoint['model_state_dict'])
        audio_model = audio_model.cuda()
        audio_model.eval()

        audio_cls_model = AudioAttGenModule()
        audio_cls_model.load_state_dict(checkpoint['model_state_dict'], strict=False)
        audio_cls_model.fc = nn.Linear(512, 7)
        audio_cls_model    = audio_cls_model.cuda()
        a_proj = ProjectHead(input_dim=256,
                             hidden_dim=args.hidden_dim,
                             out_dim=args.out_dim).cuda()
        input_dim += 512

    mlp_cls = Encoder(input_dim=input_dim, out_dim=7).cuda()

    if args.use_video and args.use_flow and args.use_audio:
        mlp_v2f = EncoderTrans(input_dim=2304, out_dim=2048, hidden=args.trans_hidden_num).cuda()
        mlp_f2v = EncoderTrans(input_dim=2048, out_dim=2304, hidden=args.trans_hidden_num).cuda()
        mlp_v2a = EncoderTrans(input_dim=2304, out_dim=512,  hidden=args.trans_hidden_num).cuda()
        mlp_a2v = EncoderTrans(input_dim=512,  out_dim=2304, hidden=args.trans_hidden_num).cuda()
        mlp_f2a = EncoderTrans(input_dim=2048, out_dim=512,  hidden=args.trans_hidden_num).cuda()
        mlp_a2f = EncoderTrans(input_dim=512,  out_dim=2048, hidden=args.trans_hidden_num).cuda()
    elif args.use_video and args.use_flow:
        mlp_v2f = EncoderTrans(input_dim=2304, out_dim=2048, hidden=args.trans_hidden_num).cuda()
        mlp_f2v = EncoderTrans(input_dim=2048, out_dim=2304, hidden=args.trans_hidden_num).cuda()
    elif args.use_video and args.use_audio:
        mlp_v2a = EncoderTrans(input_dim=2304, out_dim=512,  hidden=args.trans_hidden_num).cuda()
        mlp_a2v = EncoderTrans(input_dim=512,  out_dim=2304, hidden=args.trans_hidden_num).cuda()
    elif args.use_flow and args.use_audio:
        mlp_f2a = EncoderTrans(input_dim=2048, out_dim=512,  hidden=args.trans_hidden_num).cuda()
        mlp_a2f = EncoderTrans(input_dim=512,  out_dim=2048, hidden=args.trans_hidden_num).cuda()

    # ── PID loss setup ────────────────────────────────────────────────────
    pid_criterion = None
    if args.use_pid:
        # Build dim map for all active modalities
        # Keys: vs/as/fs = shared half;  vu/au/fu = unique half
        dim_map = {}
        if args.use_video:
            dim_map['vs'] = 1152;  dim_map['vu'] = 1152
        if args.use_audio:
            dim_map['as'] = 256;   dim_map['au'] = 256
        if args.use_flow:
            dim_map['fs'] = 1024;  dim_map['fu'] = 1024

        pid_proj = PIDProjectionHeads(
            dim_map  = dim_map,
            proj_dim = args.pid_proj_dim,
        ).cuda()

        pid_criterion = PIDSplittingLoss(
            pid_proj     = pid_proj,
            gamma        = args.pid_gamma,
            alpha_shared = args.alpha_pid_shared,
            alpha_unique = args.alpha_pid_unique,
            use_video    = args.use_video,
            use_audio    = args.use_audio,
            use_flow     = args.use_flow,
        ).cuda()

    # ── Optimiser (include PID projection heads if active) ────────────────
    params = list(mlp_cls.parameters())
    if args.use_video:
        params += (list(model.module.backbone.fast_path.layer4.parameters()) +
                   list(model.module.backbone.slow_path.layer4.parameters()) +
                   list(model.module.cls_head.parameters()) +
                   list(v_proj.parameters()))
    if args.use_flow:
        params += (list(model_flow.module.backbone.layer4.parameters()) +
                   list(model_flow.module.cls_head.parameters()) +
                   list(f_proj.parameters()))
    if args.use_audio:
        params += list(audio_cls_model.parameters()) + list(a_proj.parameters())

    if args.use_video and args.use_flow and args.use_audio:
        params += (list(mlp_v2a.parameters()) + list(mlp_a2v.parameters()) +
                   list(mlp_v2f.parameters()) + list(mlp_f2v.parameters()) +
                   list(mlp_f2a.parameters()) + list(mlp_a2f.parameters()))
    elif args.use_video and args.use_flow:
        params += list(mlp_v2f.parameters()) + list(mlp_f2v.parameters())
    elif args.use_video and args.use_audio:
        params += list(mlp_v2a.parameters()) + list(mlp_a2v.parameters())
    elif args.use_flow and args.use_audio:
        params += list(mlp_f2a.parameters()) + list(mlp_a2f.parameters())

    if args.use_pid and pid_criterion is not None:
        params += list(pid_criterion.pid_proj.parameters())

    optim = torch.optim.Adam(params, lr=args.lr, weight_decay=1e-4)

    # ── Losses ────────────────────────────────────────────────────────────
    criterion          = nn.CrossEntropyLoss().cuda()
    criterion_contrast = SupConLoss(temperature=args.temp).cuda()
    batch_size         = args.bsz

    # ── Checkpointing paths ───────────────────────────────────────────────
    os.makedirs('checkpoints', exist_ok=True)
    os.makedirs('models',      exist_ok=True)

    log_name = 'PIDlog%s2%s' % (args.source_domain, args.target_domain)
    if args.use_video: log_name += '_video'
    if args.use_flow:  log_name += '_flow'
    if args.use_audio: log_name += '_audio'
    if args.use_pid:   log_name += '_pid'
    log_name  += args.appen
    log_path   = 'checkpoints/' + log_name + '.csv'
    print('Log path:', log_path)

    # ── Tracking variables ────────────────────────────────────────────────
    BestLoss    = float('inf')
    BestEpoch   = args.BestEpoch
    BestAcc     = args.BestAcc
    BestTestAcc = args.BestTestAcc

    # ── Resume ────────────────────────────────────────────────────────────
    if args.resumef:
        resume_file = 'models/' + log_name + '.pt'
        print('Resuming from', resume_file)
        ckpt = torch.load(resume_file)
        starting_epoch = ckpt['epoch'] + 1
        BestLoss    = ckpt['BestLoss']
        BestEpoch   = ckpt['BestEpoch']
        BestAcc     = ckpt['BestAcc']
        BestTestAcc = ckpt['BestTestAcc']

        if args.use_video:
            model.load_state_dict(ckpt['model_state_dict'])
            v_proj.load_state_dict(ckpt['v_proj_state_dict'])
        if args.use_flow:
            model_flow.load_state_dict(ckpt['model_flow_state_dict'])
            f_proj.load_state_dict(ckpt['f_proj_state_dict'])
        if args.use_audio:
            audio_model.load_state_dict(ckpt['audio_model_state_dict'])
            audio_cls_model.load_state_dict(ckpt['audio_cls_model_state_dict'])
            a_proj.load_state_dict(ckpt['a_proj_state_dict'])
        if args.use_video and args.use_flow and args.use_audio:
            mlp_v2a.load_state_dict(ckpt['mlp_v2a_state_dict'])
            mlp_a2v.load_state_dict(ckpt['mlp_a2v_state_dict'])
            mlp_v2f.load_state_dict(ckpt['mlp_v2f_state_dict'])
            mlp_f2v.load_state_dict(ckpt['mlp_f2v_state_dict'])
            mlp_f2a.load_state_dict(ckpt['mlp_f2a_state_dict'])
            mlp_a2f.load_state_dict(ckpt['mlp_a2f_state_dict'])
        elif args.use_video and args.use_flow:
            mlp_v2f.load_state_dict(ckpt['mlp_v2f_state_dict'])
            mlp_f2v.load_state_dict(ckpt['mlp_f2v_state_dict'])
        elif args.use_video and args.use_audio:
            mlp_v2a.load_state_dict(ckpt['mlp_v2a_state_dict'])
            mlp_a2v.load_state_dict(ckpt['mlp_a2v_state_dict'])
        elif args.use_flow and args.use_audio:
            mlp_f2a.load_state_dict(ckpt['mlp_f2a_state_dict'])
            mlp_a2f.load_state_dict(ckpt['mlp_a2f_state_dict'])
        mlp_cls.load_state_dict(ckpt['mlp_cls_state_dict'])

        if args.use_pid and 'pid_proj_state_dict' in ckpt:
            pid_criterion.pid_proj.load_state_dict(ckpt['pid_proj_state_dict'])
        optim.load_state_dict(ckpt['optimizer'])
    else:
        print('Training From Scratch ...')
        starting_epoch = 0

    print('Starting epoch:', starting_epoch)

    # ── Dataloaders ───────────────────────────────────────────────────────
    train_dataset = FastHAC(
        split='train', source=True, domain=args.source_domain,
        cfg=cfg, cfg_flow=cfg_flow, datapath=args.datapath,
        use_video=args.use_video, use_flow=args.use_flow, use_audio=args.use_audio,
    )
    validate_dataset = FastHAC(
        split='test', source=True, domain=args.source_domain,
        cfg=cfg, cfg_flow=cfg_flow, datapath=args.datapath,
        use_video=args.use_video, use_flow=args.use_flow, use_audio=args.use_audio,
    )
    test_dataset = FastHAC(
        split='test', source=False, domain=args.target_domain,
        cfg=cfg, cfg_flow=cfg_flow, datapath=args.datapath,
        use_video=args.use_video, use_flow=args.use_flow, use_audio=args.use_audio,
    )

    train_dataloader    = torch.utils.data.DataLoader(
        train_dataset,    batch_size=batch_size, num_workers=0,
        shuffle=True,  pin_memory=True, drop_last=True)
    validate_dataloader = torch.utils.data.DataLoader(
        validate_dataset, batch_size=batch_size, num_workers=0,
        shuffle=False, pin_memory=True, drop_last=False)
    test_dataloader     = torch.utils.data.DataLoader(
        test_dataset,     batch_size=batch_size, num_workers=0,
        shuffle=False, pin_memory=True, drop_last=False)

    dataloaders = {
        'train': train_dataloader,
        'val':   validate_dataloader,
        'test':  test_dataloader,
    }

    # ── Training loop ─────────────────────────────────────────────────────
    with open(log_path, 'a') as f:
        for epoch_i in range(starting_epoch, args.nepochs):
            print(f'\n{"="*60}')
            print(f'Epoch {epoch_i:02d}  '
                  f'[PID {"ON" if (args.use_pid and epoch_i >= args.pid_warmup_epochs) else "warmup/OFF"}]')
            print(f'{"="*60}')

            for split in ['train', 'val', 'test']:
                acc        = 0
                count      = 0
                total_loss = 0
                print(f'  Split: {split}')

                # ── Set train/eval mode ───────────────────────────────────
                mlp_cls.train(split == 'train')
                if args.use_video:
                    model.train(split == 'train')
                    v_proj.train(split == 'train')
                if args.use_flow:
                    model_flow.train(split == 'train')
                    f_proj.train(split == 'train')
                if args.use_audio:
                    audio_cls_model.train(split == 'train')
                    a_proj.train(split == 'train')
                if args.use_video and args.use_flow and args.use_audio:
                    mlp_v2a.train(split == 'train')
                    mlp_a2v.train(split == 'train')
                    mlp_v2f.train(split == 'train')
                    mlp_f2v.train(split == 'train')
                    mlp_f2a.train(split == 'train')
                    mlp_a2f.train(split == 'train')
                elif args.use_video and args.use_flow:
                    mlp_v2f.train(split == 'train')
                    mlp_f2v.train(split == 'train')
                elif args.use_video and args.use_audio:
                    mlp_v2a.train(split == 'train')
                    mlp_a2v.train(split == 'train')
                elif args.use_flow and args.use_audio:
                    mlp_f2a.train(split == 'train')
                    mlp_a2f.train(split == 'train')
                if args.use_pid and pid_criterion is not None:
                    pid_criterion.train(split == 'train')

                # ── Batch loop ────────────────────────────────────────────
                pid_log_accum = {}   # accumulate PID stats for epoch summary
                with tqdm.tqdm(total=len(dataloaders[split])) as pbar:
                    for i, (clip, flow, spectrogram, labels) in \
                            enumerate(dataloaders[split]):

                        if split == 'train':
                            predict1, loss, pid_log = train_one_step(
                                clip, labels, flow, spectrogram, epoch_i)
                            # accumulate PID log for printing at epoch end
                            for k, v in pid_log.items():
                                pid_log_accum[k] = pid_log_accum.get(k, 0) + v
                        else:
                            predict1, loss = validate_one_step(
                                clip, labels, flow, spectrogram)

                        total_loss += loss.item() * batch_size
                        _, predict  = torch.max(predict1.detach().cpu(), dim=1)
                        acc        += (predict == labels.cpu()).sum().item()
                        count      += predict1.size(0)

                        pbar.set_postfix_str(
                            'AvgLoss:{:.4f} CurLoss:{:.4f} Acc:{:.4f}'.format(
                                total_loss / float(count),
                                loss.item(),
                                acc / float(count)))
                        pbar.update()

                # ── End of split ──────────────────────────────────────────
                if split == 'val':
                    currentvalAcc = acc / float(count)
                    if currentvalAcc >= BestAcc:
                        BestLoss  = total_loss / float(count)
                        BestEpoch = epoch_i
                        BestAcc   = currentvalAcc

                if split == 'test':
                    currenttestAcc = acc / float(count)
                    if currentvalAcc >= BestAcc:
                        BestTestAcc = currenttestAcc

                        if args.save_best:
                            save = {
                                'epoch':       epoch_i,
                                'BestLoss':    BestLoss,
                                'BestEpoch':   BestEpoch,
                                'BestAcc':     BestAcc,
                                'BestTestAcc': BestTestAcc,
                                'optimizer':   optim.state_dict(),
                                'mlp_cls_state_dict': mlp_cls.state_dict(),
                            }
                            if args.use_video:
                                save['model_state_dict']  = model.state_dict()
                                save['v_proj_state_dict'] = v_proj.state_dict()
                            if args.use_flow:
                                save['model_flow_state_dict'] = model_flow.state_dict()
                                save['f_proj_state_dict']     = f_proj.state_dict()
                            if args.use_audio:
                                save['audio_model_state_dict']     = audio_model.state_dict()
                                save['audio_cls_model_state_dict'] = audio_cls_model.state_dict()
                                save['a_proj_state_dict']          = a_proj.state_dict()
                            if args.use_video and args.use_flow and args.use_audio:
                                save['mlp_v2a_state_dict'] = mlp_v2a.state_dict()
                                save['mlp_a2v_state_dict'] = mlp_a2v.state_dict()
                                save['mlp_v2f_state_dict'] = mlp_v2f.state_dict()
                                save['mlp_f2v_state_dict'] = mlp_f2v.state_dict()
                                save['mlp_f2a_state_dict'] = mlp_f2a.state_dict()
                                save['mlp_a2f_state_dict'] = mlp_a2f.state_dict()
                            elif args.use_video and args.use_flow:
                                save['mlp_v2f_state_dict'] = mlp_v2f.state_dict()
                                save['mlp_f2v_state_dict'] = mlp_f2v.state_dict()
                            elif args.use_video and args.use_audio:
                                save['mlp_v2a_state_dict'] = mlp_v2a.state_dict()
                                save['mlp_a2v_state_dict'] = mlp_a2v.state_dict()
                            elif args.use_flow and args.use_audio:
                                save['mlp_f2a_state_dict'] = mlp_f2a.state_dict()
                                save['mlp_a2f_state_dict'] = mlp_a2f.state_dict()
                            if args.use_pid and pid_criterion is not None:
                                save['pid_proj_state_dict'] = \
                                    pid_criterion.pid_proj.state_dict()

                            torch.save(save,
                                'models/' + log_name + f'_best_{epoch_i}.pt')

                    if args.save_checkpoint:
                        save = {
                            'epoch':       epoch_i,
                            'BestLoss':    BestLoss,
                            'BestEpoch':   BestEpoch,
                            'BestAcc':     BestAcc,
                            'BestTestAcc': BestTestAcc,
                            'optimizer':   optim.state_dict(),
                            'mlp_cls_state_dict': mlp_cls.state_dict(),
                        }
                        if args.use_video:
                            save['model_state_dict']  = model.state_dict()
                            save['v_proj_state_dict'] = v_proj.state_dict()
                        if args.use_flow:
                            save['model_flow_state_dict'] = model_flow.state_dict()
                            save['f_proj_state_dict']     = f_proj.state_dict()
                        if args.use_audio:
                            save['audio_model_state_dict']     = audio_model.state_dict()
                            save['audio_cls_model_state_dict'] = audio_cls_model.state_dict()
                            save['a_proj_state_dict']          = a_proj.state_dict()
                        if args.use_video and args.use_flow and args.use_audio:
                            save['mlp_v2a_state_dict'] = mlp_v2a.state_dict()
                            save['mlp_a2v_state_dict'] = mlp_a2v.state_dict()
                            save['mlp_v2f_state_dict'] = mlp_v2f.state_dict()
                            save['mlp_f2v_state_dict'] = mlp_f2v.state_dict()
                            save['mlp_f2a_state_dict'] = mlp_f2a.state_dict()
                            save['mlp_a2f_state_dict'] = mlp_a2f.state_dict()
                        elif args.use_video and args.use_flow:
                            save['mlp_v2f_state_dict'] = mlp_v2f.state_dict()
                            save['mlp_f2v_state_dict'] = mlp_f2v.state_dict()
                        elif args.use_video and args.use_audio:
                            save['mlp_v2a_state_dict'] = mlp_v2a.state_dict()
                            save['mlp_a2v_state_dict'] = mlp_a2v.state_dict()
                        elif args.use_flow and args.use_audio:
                            save['mlp_f2a_state_dict'] = mlp_f2a.state_dict()
                            save['mlp_a2f_state_dict'] = mlp_a2f.state_dict()
                        if args.use_pid and pid_criterion is not None:
                            save['pid_proj_state_dict'] = \
                                pid_criterion.pid_proj.state_dict()
                        torch.save(save, 'models/' + log_name + '.pt')

                # ── CSV logging ───────────────────────────────────────────
                f.write('{},{},{},{}\n'.format(
                    epoch_i, split,
                    total_loss / float(count),
                    acc / float(count)))
                f.flush()

                print(f'  Epoch {epoch_i} | {split} | '
                      f'Loss {total_loss/float(count):.4f} | '
                      f'Acc {acc/float(count):.4f}')
                print(f'  BestValAcc={BestAcc:.4f}  BestTestAcc={BestTestAcc:.4f}')

                if split == 'test':
                    f.write('CurrentBestEpoch,{},BestLoss,{},BestValAcc,{},BestTestAcc,{}\n'.format(
                        BestEpoch, BestLoss, BestAcc, BestTestAcc))
                    f.flush()

            # ── PID summary at end of train epoch ─────────────────────────
            if args.use_pid and pid_log_accum:
                n_batches = len(train_dataloader)
                print('  -- PID averages this epoch --')
                for k, v in sorted(pid_log_accum.items()):
                    print(f'    {k}: {v/n_batches:.4f}')

        # ── Final summary ─────────────────────────────────────────────────
        f.write('BestEpoch,{},BestLoss,{},BestValAcc,{},BestTestAcc,{}\n'.format(
            BestEpoch, BestLoss, BestAcc, BestTestAcc))
        f.flush()
        print(f'\nFinal  BestValAcc={BestAcc:.4f}  BestTestAcc={BestTestAcc:.4f}')