"""Official ReLA Swin-Tiny architecture and trained checkpoint adapter."""
from pathlib import Path
import sys,json,os
import numpy as np
from PIL import Image
ROOT=Path(__file__).resolve().parents[1]
class ReLA:
    threshold=.5
    def __init__(self,device='cuda'):
        import torch
        self.torch=torch;self.device=device
        repo=ROOT/'third_party/ReLA-3ca955198da8ace68f8980b6fcbada0791cc51c2';sys.path.insert(0,str(repo))
        if not hasattr(Image, "LINEAR"):Image.LINEAR=Image.Resampling.BILINEAR
        from detectron2.config import get_cfg
        from detectron2.modeling import build_model
        from detectron2.data import transforms as T
        from gres_model import add_maskformer2_config,add_refcoco_config
        from transformers import BertTokenizer
        from detectron2.projects.deeplab import add_deeplab_config
        cfg=get_cfg();add_deeplab_config(cfg);add_maskformer2_config(cfg);add_refcoco_config(cfg)
        cfg.merge_from_file(str(repo/'configs/referring_swin_tiny.yaml'))
        cfg.MODEL.DEVICE=device;cfg.REFERRING.BERT_TYPE=str(ROOT/'models/bert-base-uncased')
        self.model=build_model(cfg).eval()
        checkpoint=torch.load(ROOT/'models/gres_swin_tiny.pth',map_location='cpu',weights_only=False)
        state=checkpoint['model'] if 'model' in checkpoint else checkpoint
        key='text_encoder.embeddings.position_ids'
        if key in state:
            assert torch.equal(state[key],self.model.text_encoder.embeddings.position_ids.cpu())
            state.pop(key)  # Identical deterministic buffer is nonpersistent in current Transformers.
        incompat=self.model.load_state_dict(state,strict=True)
        self.model.to(device);self.tokenizer=BertTokenizer.from_pretrained(cfg.REFERRING.BERT_TYPE,local_files_only=True)
        self.max_tokens=cfg.REFERRING.MAX_TOKENS;self.size=cfg.INPUT.IMAGE_SIZE
        self.resize=T.Resize((self.size,self.size))
        print('RELA_STRICT_LOAD_OK',len(state),self.size,self.max_tokens,str(incompat),flush=True)
    def predict(self,image,texts):
        t=self.torch;arr=np.array(image);resized=self.resize.get_transform(arr).apply_image(arr)
        rgb=t.as_tensor(np.ascontiguousarray(resized.transpose(2,0,1)))
        out={};nt={};official={}
        with t.inference_mode():
            for start in range(0,len(texts),2):
                batch=texts[start:start+2];inputs=[]
                for q in batch:
                    ids=self.tokenizer.encode(text=q,add_special_tokens=True)[:self.max_tokens]
                    padding=[0]*(self.max_tokens-len(ids))
                    inputs.append(dict(image=rgb,lang_tokens=t.tensor(ids+padding).unsqueeze(0),lang_mask=t.tensor([1]*len(ids)+padding).unsqueeze(0)))
                outputs=self.model(inputs)
                for q,p in zip(batch,outputs):
                    official[q]=p['ref_seg'].argmax(dim=0).bool().cpu().numpy()
                    nt[q]=bool(p['nt_label'].argmax(dim=0).item())
                    # Monotone foreground/background margin for the optional
                    # shared repair interface. Native scores use exact argmax.
                    margin=(p['ref_seg'][1]-p['ref_seg'][0]+1)/2
                    out[q]=t.nn.functional.interpolate(margin[None,None],size=(image.height,image.width),mode='bilinear',align_corners=False)[0,0].float().cpu().numpy()
        return out,dict(language_queries=len(texts),nt=nt,official_masks=official,sam_boxes=0,truncated_boxes=0)

if __name__=='__main__':
    import torch
    torch.set_num_threads(4)
    engine=ReLA(device=os.getenv('R2_DEVICE','cuda'))
    old=ROOT.parent/'refseg_scale_20260906'
    row=next(json.loads(s) for s in (old/'data/manifest.jsonl').read_text().splitlines() if json.loads(s)['domain']=='natural' and json.loads(s)['split']=='fit')
    image=Image.open(old/row['image_path']).convert('RGB')
    maps,stats=engine.predict(image,[row['query']])
    print('RELA_PILOT_OK',image.size,row['query'],{q:dict(shape=v.shape,min=float(v.min()),max=float(v.max())) for q,v in maps.items()},stats['nt'],flush=True)