"""Server-persisted library-backed profiles with validated, typed parameters."""
import json
import re
import threading
import time
import uuid
from pathlib import Path

SCHEMAS={
 'chat':{'context':(512,2097152,8192),'slots':(1,16,1),'threads':(1,256,6),'batch':(1,8192,512),'ubatch':(1,8192,128),'temperature':(0,5,.8),'top_p':(0,1,.95),'top_k':(0,1000,40),'mtp_tokens':(1,8,2),'mtp_min_p':(0,1,.05)},
 'image':{'width':(256,2048,1024),'height':(256,2048,1024),'steps':(1,100,25),'seed':(-1,2147483647,-1),'guidance':(0,30,1)},
 'audio':{'speed':(.25,4,1)},
 'video':{'width':(256,1920,768),'height':(256,1088,512),'frames':(1,241,33),'fps':(1,60,24),'steps':(1,100,20),'seed':(-1,2147483647,-1)}
}
CHAT_GPU_DEFAULTS={'gpu_devices':[], 'split_mode':'none', 'tensor_split':[], 'mtp':False,'gpu_offload':'auto'}
CHAT_SAMPLING={'temperature':.8,'top_p':.95,'top_k':40,'mtp_tokens':2,'mtp_min_p':.05}

def chat_parameters(params):
 params={**CHAT_GPU_DEFAULTS,**CHAT_SAMPLING,**params}
 if params['gpu_offload'] not in ('auto','full'):raise ValueError('Ungültiger GPU-Auslagerungsmodus.')
 if type(params['mtp']) is not bool:raise ValueError('MTP muss an oder aus sein.')
 devices=params['gpu_devices'];split=params['tensor_split']
 if not isinstance(devices,list) or len(devices)>16 or any(not isinstance(v,str) or not re.fullmatch(r'GPU-[0-9a-fA-F-]{36}',v) for v in devices) or len(set(devices))!=len(devices):raise ValueError('GPUs müssen als eindeutige, geordnete GPU-UUIDs angegeben werden.')
 if params['split_mode'] not in ('none','layer','row'):raise ValueError('Ungültiger GPU-Split-Modus.')
 if not isinstance(split,list) or any(isinstance(v,bool) or not isinstance(v,(int,float)) or not 0<v<=100 for v in split):raise ValueError('GPU-Verteilung: positive Gewichte bis 100 verwenden.')
 if split and (len(split)!=len(devices) or len(devices)<2 or params['split_mode']=='none'):raise ValueError('GPU-Verteilung benötigt mehrere ausgewählte GPUs und einen Split-Modus; je GPU einen Wert angeben.')
 if len(devices)>1 and params['split_mode']=='none':raise ValueError('Bei mehreren GPUs Layer- oder Row-Split auswählen.')
 return params

# Explicit model-card recipe. This is a source recommendation, not a runtime test.
QWEN_REPO='abenzerps/Qwen-Image-2.1-Uncensored-GGUF'
QWEN_COMPONENTS={
 'text_encoder':{'label':'Textencoder','files':['text_encoders/qwen3vl_8b_int8_convrot.safetensors','text_encoders/qwen3vl_8b_bf16.safetensors']},
 'vae':{'label':'VAE','files':['vae/qwen_image_2.1_vae_bf16.safetensors']}
}
class Profiles:
 def __init__(self,path,catalog):
  self.path=Path(path);self.catalog=catalog;self.lock=threading.RLock()
  self.image_runtime_ready=lambda:False
  self.chat_blockers=None
  self.rows=json.loads(self.path.read_text()) if self.path.exists() else []
 def status(self):
  with self.lock:
   rows=json.loads(json.dumps(self.rows))
  for p in rows:
   if p['kind']=='chat':p['parameters']={**CHAT_GPU_DEFAULTS,**CHAT_SAMPLING,**p['parameters']}
   try:
    p['model']=self.catalog.entry(p['model_id'])
    p['blockers']=['Für dieses Profil ist noch kein ausführbarer Worker angebunden.']
    if p['kind']=='image' and 'qwen-image-2.1' in p['model']['repo'].lower():
     p['blockers']=['Eine eigene Bildlaufzeit muss eingerichtet werden; llama.cpp führt keine Bildmodelle aus.']
     for role,info in reversed(list(QWEN_COMPONENTS.items())):
      try:self._component(p['model'],role,p.get('components',{}).get(role))
      except ValueError:p['blockers'].insert(0,info['label']+' fehlt oder ist noch nicht zugeordnet.')
   except ValueError as exc:p['model']=None;p['blockers']=[str(exc)]
   if p.get('model') and p['model']['repo']==QWEN_REPO and p['model']['file'].endswith('.gguf') and self.image_runtime_ready():
    p['blockers']=[b for b in p['blockers'] if not b.startswith('Eine eigene Bildlaufzeit')]
   if p['kind']=='chat' and self.chat_blockers and p.get('model'):p['blockers']=self.chat_blockers(p)
   if p['kind']=='image' and (p['parameters']['width']>1024 or p['parameters']['height']>1024):p['blockers'].append('Die Bildlaufzeit unterstützt derzeit maximal 1024 × 1024 Pixel.')
   p['runnable']=not p['blockers'];p['state']='ready' if p['runnable'] else 'configured'
  return {'profiles':rows,'schemas':SCHEMAS}
 def save(self,data):
  if set(data)!={'id','revision','name','kind','model_id','parameters'}:raise ValueError('Ungültige Profilfelder.')
  kind=data['kind'];name=data['name'];params=data['parameters']
  if not isinstance(kind,str) or kind not in SCHEMAS or not isinstance(name,str) or not re.fullmatch('[a-zA-Z0-9][a-zA-Z0-9_-]{1,63}',name):raise ValueError('API-Name: 2–64 Buchstaben, Ziffern, Bindestrich oder Unterstrich.')
  model=self.catalog.entry(data['model_id'])
  if model['repo']==QWEN_REPO and any(model['file'] in r['files'] for r in QWEN_COMPONENTS.values()):raise ValueError('Textencoder und VAE werden über Komponenten zugeordnet, nicht als Hauptmodell.')
  if model['kind']!=kind or not model['profile_eligible']:raise ValueError('Eine Gewichtsdatei dieses Bereichs auswählen, keine Konfiguration.')
  if kind=='chat' and isinstance(params,dict):params=chat_parameters(params)
  if not isinstance(params,dict) or set(params)!=(set(SCHEMAS[kind]) | (set(CHAT_GPU_DEFAULTS) if kind=='chat' else set())):raise ValueError('Unvollständige oder unbekannte Profilparameter.')
  for key,(lo,hi,_) in SCHEMAS[kind].items():
   value=params[key]
   floating=key in ('guidance','speed','temperature','top_p','mtp_min_p')
   if isinstance(value,bool) or not isinstance(value,(float,int) if floating else int) or not lo<=value<=hi:raise ValueError('Ungültiger Parameter: '+key)
  if kind in ('image','video') and (params['width']%64 or params['height']%64):raise ValueError('Breite und Höhe müssen durch 64 teilbar sein.')
  if kind=='chat' and params['ubatch']>params['batch']:raise ValueError('Microbatch darf nicht größer als Batch sein.')
  with self.lock:
   existing=next((p for p in self.rows if p['id']==data['id']),None)
   if data['id'] is not None and not existing:raise ValueError('Profil nicht gefunden.')
   if data['revision']!=(existing['revision'] if existing else 0):raise ValueError('Profil wurde zwischenzeitlich geändert. Ansicht neu laden.')
   if any(p['name']==name and p is not existing for p in self.rows):raise ValueError('API-Profilname bereits vergeben.')
   components=existing.get('components',{}) if existing and existing['model_id']==model['id'] else {}
   row=dict(components=components,id=existing['id'] if existing else uuid.uuid4().hex,revision=data['revision']+1,name=name,kind=kind,model_id=model['id'],parameters=params,updated_at=time.time())
   rows=[row if p is existing else p for p in self.rows] if existing else self.rows+[row]
   self.path.parent.mkdir(parents=True,exist_ok=True,mode=0o700)
   temp=self.path.with_suffix('.tmp');temp.write_text(json.dumps(rows));temp.replace(self.path);self.rows=rows
   return row

 def delete(self,data):
  if set(data)!={'id','revision'}:raise ValueError('Ungültige Profilfelder.')
  with self.lock:
   old=next((p for p in self.rows if p['id']==data['id']),None)
   if not old or old['revision']!=data['revision']:raise ValueError('Profil geändert oder nicht gefunden. Ansicht neu laden.')
   rows=[p for p in self.rows if p is not old]
   temp=self.path.with_suffix('.tmp');temp.write_text(json.dumps(rows));temp.replace(self.path);self.rows=rows
   return {'deleted':old['id']}

 def _component(self,model,role,ident):
  if model['repo']!=QWEN_REPO or role not in QWEN_COMPONENTS:raise ValueError('Für dieses Modell ist kein geprüftes Komponentenrezept hinterlegt.')
  item=self.catalog.entry(ident)
  if item['repo']!=QWEN_REPO or item['kind']!='image' or item['file'] not in QWEN_COMPONENTS[role]['files']:raise ValueError('Die Datei gehört nicht zu dieser Komponente des Modells.')
  return item
 def components(self,model_id):
  model=self.catalog.entry(model_id)
  if model['repo']!=QWEN_REPO or model['kind']!='image':return dict(supported=False,requirements=[],message='Für dieses Modell ist noch kein Komponentenrezept hinterlegt. Keine automatische Zuordnung.')
  source=self.catalog.files(QWEN_REPO);entries=self.catalog.status()['entries'];requirements=[]
  for role,info in QWEN_COMPONENTS.items():
   available=[]
   for item in entries:
    try:
     self._component(model,role,item['id']);available.append(item)
    except ValueError:pass
   candidates=[dict(f,repo=QWEN_REPO,revision=source['revision'],gated=source['gated']) for name in info['files'] for f in source['files'] if f['name']==name]
   requirements.append(dict(role=role,label=info['label'],available=available,candidates=candidates))
  return dict(supported=True,requirements=requirements,source=source['url'],license=source['license'],runtime='ComfyUI + ComfyUI-GGUF',runtime_installed=self.image_runtime_ready(),
              message='Zusatzdateien laut Modellkarte für ComfyUI. Kompatibilität und Speicherbedarf müssen mit der eingerichteten Laufzeit noch praktisch geprüft werden.')
 def assign(self,data):
  if set(data)!={'id','revision','components'} or not isinstance(data['components'],dict) or set(data['components'])-set(QWEN_COMPONENTS):raise ValueError('Ungültige Komponentenzuordnung.')
  with self.lock:
   old=next((p for p in self.rows if p['id']==data['id']),None)
   if not old or old['kind']!='image' or old['revision']!=data['revision']:raise ValueError('Profil geändert oder nicht gefunden. Ansicht neu laden.')
   model=self.catalog.entry(old['model_id'])
   components={k:v for k,v in data['components'].items() if v}
   for role,ident in components.items():self._component(model,role,ident)
   updated=dict(old,components=components,revision=old['revision']+1,updated_at=time.time())
   rows=[updated if p is old else p for p in self.rows]
   temp=self.path.with_suffix('.tmp');temp.write_text(json.dumps(rows));temp.replace(self.path);self.rows=rows
   return updated