// Strict browser-side mirror of the bounded local System One request contract.
// The server remains authoritative; this module never edits unsupported fields.
const object = v => v !== null && typeof v === 'object' && !Array.isArray(v);
const keys = (value, allowed, label) => { if (!object(value) || Object.keys(value).some(k => !allowed.includes(k))) throw Error(`${label}: unsupported fields or invalid object.`); };
const content = (v,label) => { if (typeof v === 'string') { if(!v.trim()) throw Error(`${label} must not be empty.`); } else if(!object(v) && !Array.isArray(v)) throw Error(`${label} must be text, an object, or an array.`); };
const id = (v,label,maxLength) => {
  if(typeof v!=='string'||!v.trim())throw Error(`${label} needs a nonempty string.`);
  if(maxLength!==undefined&&v.length>maxLength)throw Error(`${label} needs at most ${maxLength} characters.`);
};
function finiteJSON(value) {
  if(typeof value==='number'&&!Number.isFinite(value))throw Error('JSON numbers must be finite.');
  if(value && typeof value==='object')Object.values(value).forEach(finiteJSON);
}
export function validateRequest(body, expectedModel) {
  finiteJSON(body);
  keys(body,['state','states','model','questions'],'Request');
  if(typeof expectedModel!=='string'||!expectedModel||body.model!==expectedModel)throw Error('Request model does not match the selected model.');
  if(Object.hasOwn(body,'state')===Object.hasOwn(body,'states'))throw Error('Use one context or batch contexts, not both.');
  if(Object.hasOwn(body,'states')){
    if(!Array.isArray(body.states)||body.states.length<1)throw Error('Provide at least one context.');
    const seen=new Set();
    for(const row of body.states){keys(row,['id','state'],'Context');id(row.id,'Context ID',128);if(seen.has(row.id))throw Error('Context IDs must be unique.');seen.add(row.id);content(row.state,`Context ${row.id}`);}
  }else content(body.state,'State');
  if(!object(body.questions)||Object.keys(body.questions).length<1)throw Error('Provide at least one named question.');
  for(const[qid,q]of Object.entries(body.questions)) {
    id(qid,'Question ID');keys(q,['type','instructions','criteria'],qid);
    if(!['choice','noul','score'].includes(q.type))throw Error(`${qid}: unsupported question type.`);
    content(q.instructions,`${qid} instructions`);
    if(q.type==='choice') {
      if(!object(q.criteria)||Object.keys(q.criteria).length<2||Object.keys(q.criteria).length>255)throw Error(`${qid}: Choice needs 2–255 named options.`);
      for(const[name,v]of Object.entries(q.criteria)){id(name,'Option name');if(v!==null)content(v,`${qid} option description`);}
    } else if(q.type==='score') {
      if(!Array.isArray(q.criteria)||q.criteria.length<2||q.criteria.length>10)throw Error(`${qid}: Score needs 2–10 ordered levels.`);
      q.criteria.forEach(v=>content(v,`${qid} level`));
    } else if(q.criteria!==undefined&&q.criteria!==null) {
      keys(q.criteria,['false','true'],`${qid} criteria`);
      Object.values(q.criteria).forEach(v=>{if(v!==null)content(v,`${qid} criterion`);});
    }
  }
  const requestLimit=Object.hasOwn(body,'states')?2*1024*1024:256*1024;
  if(new TextEncoder().encode(JSON.stringify(body)).length>requestLimit)throw Error(`The complete request must fit within ${requestLimit===256*1024?'256 KiB':'2 MiB'}.`);
  const utf8=new TextEncoder(), states=body.states?body.states.map(x=>x.state):[body.state];
  const stateBytes=states.reduce((n,v)=>n+utf8.encode(typeof v==='string'?v:JSON.stringify(v)).length,0);
  const expanded=stateBytes*Object.keys(body.questions).length+utf8.encode(JSON.stringify(body.questions)).length*states.length;
  if(expanded>16*1024*1024)throw Error('Expanded context/question input exceeds 16 MiB; split this workload into requests.');
  return body;
}

export function validateResult(result,request,canonicalModel=request.model){
  if(!object(result))throw Error('The server returned an invalid response.');
  const legacy=Object.hasOwn(result,'source');
  if(legacy){
    if(result.model!==request.model||result.source!=='live_native')throw Error('The server returned a different model or prediction source.');
  }else{
    if(result.model!==canonicalModel)throw Error('The server returned a different model.');
    const fields=request.states?['model','results','usage']:['model','answers','usage'];
    if(Object.keys(result).length!==fields.length||fields.some(key=>!Object.hasOwn(result,key)))throw Error('The server returned a non-standard response.');
  }
  const usage=value=>object(value)&&Object.keys(value).length===2&&Number.isInteger(value.input_tokens)&&value.input_tokens>=0&&Number.isInteger(value.output_tokens)&&value.output_tokens>=0;
  if(!usage(result.usage))throw Error('Invalid response usage.');
  const expectedIds=Object.keys(request.questions);
  const answerSet=answers=>{
    if(!object(answers)||Object.keys(answers).length!==expectedIds.length||expectedIds.some(id=>!Object.hasOwn(answers,id))||legacy&&JSON.stringify(Object.keys(answers))!==JSON.stringify(expectedIds))throw Error('The response does not match the shared questions.');
    for(const id of expectedIds){const a=answers[id],q=request.questions[id];
      if(!object(a)||a.type!==q.type)throw Error('Invalid decision identity.');
      if(legacy){if(!Number.isInteger(a.input_tokens)||a.input_tokens<1)throw Error('Invalid decision token usage.');}
      else{
        const fields=q.type==='noul'?['type','noul']:q.type==='choice'?['type','choice','confidence','probabilities']:['type','score','confidence','legend','probabilities'];
        if(Object.keys(a).length!==fields.length||fields.some(key=>!Object.hasOwn(a,key)))throw Error('The server returned non-standard answer fields.');
      }
      if(q.type==='noul'){if(!Number.isFinite(a.noul)||a.noul<0||a.noul>1)throw Error('Invalid yes probability.');}
      else {const ids=q.type==='choice'?Object.keys(q.criteria):q.criteria.map((_,i)=>String(i));
        if(!object(a.probabilities)||Object.keys(a.probabilities).length!==ids.length||ids.some(k=>!Object.hasOwn(a.probabilities,k)))throw Error('Invalid candidate identity.');
        const p=ids.map(k=>a.probabilities[k]);if(p.some(v=>!Number.isFinite(v)||v<0||v>1)||Math.abs(p.reduce((a,b)=>a+b,0)-1)>2e-5)throw Error('Invalid candidate probabilities.');
        if(!legacy&&(!Number.isFinite(a.confidence)||a.confidence<0||a.confidence>1))throw Error('Invalid decision confidence.');
        if(q.type==='choice'&&!ids.includes(a.choice)||q.type==='score'&&(!Number.isFinite(a.score)||a.score<0||a.score>ids.length-1))throw Error('Invalid decision value.');
        if(q.type==='score'&&(!object(a.legend)||JSON.stringify(Object.keys(a.legend))!==JSON.stringify(ids)))throw Error('Invalid score legend.');
      }
    }
  };
  if(request.states){
    if(!Array.isArray(result.results)||result.results.length!==request.states.length)throw Error('Incomplete context results.');
    result.results.forEach((r,i)=>{if(!object(r)||r.id!==request.states[i].id||!usage(r.usage))throw Error('Context order or identity mismatch.');if(!legacy&&(Object.keys(r).length!==3||['id','answers','usage'].some(key=>!Object.hasOwn(r,key))))throw Error('The server returned non-standard context fields.');answerSet(r.answers);});
  }else answerSet(result.answers);
  return result;
}

export function validateServingResult(result,request,canonicalModel,backend){
  const native=result!==null&&typeof result==='object'&&Object.hasOwn(result,'source');
  if(backend==='native_rocm'&&!native||backend==='direct'&&native||!['native_rocm','direct','pull_queue'].includes(backend))throw Error('The server returned an unexpected prediction format.');
  return validateResult(result,request,canonicalModel);
}