import copy, sys
from pathlib import Path
import torch
from torch import nn
from torch.nn import functional as F
CORE = Path(__file__).resolve().parents[1] / 'vendor/jepa-anything-core/src'
sys.path.insert(0, str(CORE))
from jepa_anything_core import OrthogonalFactorProjection, UnconstrainedMultiHeadPredictor, MLPPredictor
(D, K, R) = (256, 4, 64)

class Overlength(ValueError):
    pass

class DomainEncoder(nn.Module):

    def __init__(self, base_path, max_length=16384):
        super().__init__()
        from transformers import AutoModel, AutoTokenizer
        from peft import LoraConfig, get_peft_model, TaskType
        self.tokenizer = AutoTokenizer.from_pretrained(base_path, local_files_only=True)
        self.tokenizer.pad_token = self.tokenizer.eos_token
        self.tokenizer.padding_side = 'right'
        self.max_length = max_length
        base = AutoModel.from_pretrained(base_path, dtype=torch.bfloat16, local_files_only=True, attn_implementation='sdpa')
        config = LoraConfig(task_type=TaskType.FEATURE_EXTRACTION, r=16, lora_alpha=32, lora_dropout=0.0, target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj'], inference_mode=True)
        self.backbone = get_peft_model(base, config)
        self.backbone.config.use_cache = False
        self.projection = nn.Sequential(nn.Linear(base.config.hidden_size, D), nn.LayerNorm(D))

    def forward(self, texts):
        batch = self.tokenizer(texts, padding=True, truncation=False, return_tensors='pt')
        if batch['input_ids'].shape[-1] > self.max_length:
            raise Overlength('encoder input exceeds explicit limit')
        device = next(self.backbone.parameters()).device
        batch = {k: v.to(device) for (k, v) in batch.items()}
        outputs = self.backbone(**batch, return_dict=True, use_cache=False).last_hidden_state
        mask = batch['attention_mask'].unsqueeze(-1)
        pooled = (outputs.float() * mask).sum(1) / mask.sum(1).clamp_min(1)
        return self.projection(pooled)

class ExecutionWorld(nn.Module):

    def __init__(self, encoder, mode='opf'):
        super().__init__()
        self.mode = mode
        self.online = encoder
        if mode == 'opf':
            self.opf = OrthogonalFactorProjection(D, K, R)
            self.predictor = UnconstrainedMultiHeadPredictor(D, D, K, R, 512)
        elif mode == 'multi':
            self.opf = None
            self.predictor = UnconstrainedMultiHeadPredictor(D, D, K, R, 640)
        elif mode in ('standard', 'ce'):
            self.opf = None
            self.predictor = MLPPredictor(D, D, 640)
        else:
            raise ValueError(mode)
        self.log_temperature = nn.Parameter(torch.zeros(()))
        self.readout = nn.Sequential(nn.LayerNorm(D), nn.Linear(D, 64), nn.GELU(), nn.Linear(64, 6))

    def predict_latent(self, context):
        p = self.predictor(context)
        if self.mode == 'opf':
            return (self.opf.compose(p), p)
        if self.mode == 'multi':
            return (p.flatten(-2), p)
        return (p, p.reshape(-1, K, R))

    def encode(self, texts, microbatch=1):
        encoder = self.online
        rows = []
        for i in range(0, len(texts), microbatch):
            rows.append(encoder(texts[i:i + microbatch]))
        return torch.cat(rows, dim=0)

    @torch.no_grad()
    def score(self, contexts):
        self.eval()
        c = self.encode(contexts)
        (z, _) = self.predict_latent(c)
        p = F.softmax(self.readout(z)[:, :5] / self.log_temperature.exp().clamp(0.2, 5.0), -1)
        return p

    @torch.no_grad()
    def details(self, contexts):
        self.eval()
        z = self.encode(contexts)
        (latent, _) = self.predict_latent(z)
        out = self.readout(latent)
        return (F.softmax(out[:, :5] / self.log_temperature.exp().clamp(0.2, 5.0), -1), F.softplus(out[:, 5]))

    @classmethod
    def load(cls, path, base_path, device='cuda'):
        from artifacts import checkpoint_manifest
        from peft.utils.save_and_load import load_peft_weights, set_peft_model_state_dict
        (metadata, identity) = checkpoint_manifest(path)
        path = Path(path)
        encoder = DomainEncoder(base_path, max_length=metadata.get('encoder_max_length', 8192))
        model = cls(encoder, metadata['mode'])
        result = set_peft_model_state_dict(model.online.backbone, load_peft_weights(str(path / 'online_lora'), device='cpu'), adapter_name='default')
        if result.unexpected_keys:
            raise RuntimeError('Unexpected adapter keys: ' + str(result.unexpected_keys))
        state = torch.load(path / 'domain.pt', map_location='cpu', weights_only=True)
        result = model.load_state_dict(state, strict=False)
        missing = [k for k in result.missing_keys if not k.startswith('online.backbone.') and k != 'log_temperature']
        if result.unexpected_keys or missing:
            raise RuntimeError('Model state mismatch: ' + str((result.unexpected_keys, missing)))
        model.identity = identity
        model.checkpoint_path = str(path)
        return model.to(device).requires_grad_(False).eval()