// Local port of client-table-extract's native codec, with GridFight schema modes.
import * as e from './extract.mjs';
const {
  fs,
  path,
  fail,
  cat,
  matches,
  escapeRE,
  zigzag,
  small
} =e;
export class NativeCodec {
  constructor(dump='', assembly='', evidence='', mode='stages'){
    this.assembly=assembly;
    this.evidence=evidence;
    this.mode=mode;
    this.blocks=Object.fromEntries(matches(dump, /\/\/ Full Name: ([\w.]+)\n(.*?)(?=\n\/\/ TypeDefIndex:|$)/gs).map(m=>[m[1], m[2]]));
    this.rvas=[...new Set(matches(dump, /RVA: (0x[\da-fA-F]+)/g).map(m=>Number(m[1])))].sort((a, b)=>a-b);
    this.schemas={
    };
    this.methods={
    };
    this.subtypes={
    };
    this.readers=new Map();
    for(const name of Object.keys(this.blocks))for(const [, rva]of this.binary_methods(name)){
      if(!this.readers.has(rva))this.readers.set(rva, new Set());
      this.readers.get(rva).add(name);
    }
  }
  binary_methods(name){
    if(!(name in this.blocks))fail('Missing native metadata class '+name);
    return matches(this.blocks[name], new RegExp('^    public static void (\\w+)\\(FCOEMCEDLNL, '+escapeRE(name)+'\\) .*?RVA: (0x[\\da-fA-F]+)', 'gm')).map(m=>[m[1], Number(m[2])]);
  }
  disassemble(rva, size=null){
    const end=this.rvas.find(v=>v>rva)??rva+8192;
    const [address, dis]=e.disassemble(this.assembly, rva, size??Math.min(end-rva, 8192));
    return [address, dis.slice(dis.indexOf('Disassembly'))];
  }
  proof(name, dis){
    fs.mkdirSync(this.evidence, {
      recursive:true
    });
    fs.writeFileSync(path.join(this.evidence, name+'.asm'), dis);
  }
  fields(name){
    const body=this.blocks[name]??fail('Missing native metadata class '+name),
    base=body.match(/public class \w+ : (RPG\.GameCore\.\w+)/),
    result=base&&base[1]in this.blocks?this.fields(base[1]):new Map();
    for(const m of matches(body, /^    public (.+?) (\w+) \/\/ Offset: (0x[\da-fA-F]+)/gm))result.set(Number(m[3]), [m[2], m[1]]);
    return result;
  }
  schema(name){
    if(name in this.schemas)return this.schemas[name];
    let known=this.fields(name);
    if(this.mode==='rounds')known=new Map([...known].filter(([, v])=>!v[1].startsWith('static ')));
    for(const [method, rva]of this.binary_methods(name)){
      const [, dis]=this.disassemble(rva),
      tests=matches(dis, this.mode==='stages'?/(?:test\s+(?:bl|ebx|rbx|al|eax|rax),0x([\da-f]+)|bt\s+rbx,0x([\da-f]+))/g:/test\s+(?:bl|ebx|rbx|al|eax|rax),0x([\da-f]+)/g),
      ordered=new Map(),
      used=new Set();
      for(let i=0; i<tests.length; i++){
        const m=tests[i],
        bit=m[1]?BigInt('0x'+m[1]):1n<<BigInt('0x'+m[2]);
        if(!bit||(bit&(bit-1n)))continue;
        const part=dis.slice(m.index+m[0].length, tests[i+1]?.index??dis.length);
        const mov=this.mode==='rounds'?/mov(?:ss)?\s+(?:(?:BYTE|WORD|DWORD|QWORD) PTR )?\[r(?!sp\b)\w+\+0x([\da-f]+)\],(?:[a-z][a-z0-9]*)/g:/mov\s+(?:BYTE|WORD|DWORD|QWORD) PTR \[r(?!sp\b)\w+\+0x([\da-f]+)\],\w+/g;
        const offsets=[...matches(part, mov), ...matches(part, /add\s+r(?!sp\b)\w+,0x([\da-f]+)/g), ...matches(part, /lea\s+r\w+,\[r(?!sp\b)\w+\+0x([\da-f]+)\]/g)];
        const found=new Set(offsets.map(m=>parseInt(m[1], 16)).filter(v=>known.has(v)&&!used.has(v)));
        if(found.size!==1)break;
        const offset=[...found][0];
        used.add(offset);
        const [key, type]=known.get(offset);
        ordered.set(bit.toString(2).length-1, {
          name:key,
          type
        });
        if(this.mode==='stages'&&ordered.size===known.size)break;
      }
      if(ordered.size&&Array.from({
        length:ordered.size
      }, (_, i)=>ordered.has(i)).every(Boolean)){
        if(this.mode==='rounds'&&ordered.size<known.size&&!name.endsWith('GridFightLevelConfigRow'))fail('Incomplete native schema '+name);
        this.schemas[name]=Array.from({
          length:ordered.size
        }, (_, i)=>ordered.get(i));
        this.methods[name]={
          method,
          rva
        };
        this.proof(name.split('.').at(-1), dis);
        return this.schemas[name];
      }
    }
    fail('Unproved native field order: '+name);
  }
  polymorphic(name){
    if(name in this.subtypes)return this.subtypes[name];
    for(const [, rva]of this.binary_methods(name)){
      const [address, dis]=this.disassemble(rva),
      limit=dis.match(/cmp\s+eax,0x([\da-f]+)/),
      table=dis.match(/lea\s+rcx,\[rip\+[^\n]+# (0x[\da-f]+)\s*\n[^\n]*movsxd rax,DWORD PTR \[rcx\+rax\*4\]/);
      if(!limit||!table||!dis.includes('jmp    rax'))continue;
      const count=parseInt(limit[1], 16)+1;
      if(count>64)fail('Unsupported subtype dispatch size');
      const base=address-BigInt(rva),
      ta=BigInt(table[1]),
      [, raw]=e.pe_method(this.assembly, Number(ta-base), count*4),
      targets=Array.from({
        length:count
      }, (_, i)=>ta+BigInt(raw.readInt32LE(i*4))),
      result={
      };
      for(let tag=0; tag<count; tag++){
        const target=targets[tag],
        end=[...targets, ta].filter(v=>v>target).sort((a, b)=>a<b?-1:1)[0];
        if(end===undefined)fail('Missing subtype boundary');
        const [, part]=this.disassemble(Number(target-base), Number(end-target)),
        types=new Set();
        for(const m of matches(part, /jmp\s+(0x[\da-f]+)/g))for(const typ of this.readers.get(Number(BigInt(m[1])-base))??[])if(typ===name||new RegExp('public class \\w+ : '+escapeRE(name)).test(this.blocks[typ]))types.add(typ);
        if(types.size!==1)fail('Ambiguous native subtype '+name+':'+tag);
        result[tag]=[...types][0];
        this.proof(name.split('.').at(-1)+'_case'+tag, part);
      }
      this.proof(name.split('.').at(-1)+'_dispatch', dis);
      this.subtypes[name]=result;
      return result;
    }
    fail('No verified native subtype dispatch: '+name);
  }
  verify_dynamic_reader(){
    const method=this.blocks['RPG.GameCore.DynamicValue']?.match(/public static void FromByteBinary\([^\n]+RVA: (0x[\da-fA-F]+)/);
    if(!method)fail('Missing native DynamicValue reader');
    const rva=Number(method[1]), [address, dis]=this.disassemble(rva),
    result=verify_dynamic_dispatch(dis, address, (table, size)=>e.pe_method(this.assembly, rva+Number(table-address), size)[1]);
    this.proof('DynamicValue_FromByteBinary', dis);
    e.atomic_json(path.join(this.evidence, 'DynamicValue_reader.json'), {rva, ...result});
    return {rva, ...result};
  }
  dynamic(cursor){
    const tag=zigzag(cursor.varint());
    let v;
    if(tag===0)v=zigzag(cursor.varint());
    else if(tag===1){
      if(cursor.at+8>cursor.data.length)fail('Truncated DynamicValue double');
      v={
        double_wire:cursor.data.subarray(cursor.at, cursor.at+8).toString('hex')
      };
      cursor.at+=8;
    } else if(tag===2)v=e.field(cursor, 'bool');
    else if(tag===3)v=Array.from({
      length:cursor.length()
    }, ()=>this.dynamic(cursor));
    else if(tag===4)v=Array.from({
      length:cursor.length()
    }, ()=>[this.dynamic(cursor), this.dynamic(cursor)]);
    else if(tag===5)v=e.field(cursor, 'string');
    else if(tag===6)v=null;
    else fail('Unsupported DynamicValue tag');
    return {
      [this.mode==='rounds'?'tag':'wire_tag']:tag,
      value:v
    };
  }
  encode_dynamic(v){
    const tag=v[this.mode==='rounds'?'tag':'wire_tag'],
    x=v.value,
    b=e.encode_varint(tag*2);
    if(tag===0){
      const a=BigInt(x);
      return cat(b, e.encode_varint((a<<1n)^(a>>63n)));
    }
    if(tag===1)return cat(b, Buffer.from(x.double_wire, 'hex'));
    if(tag===2)return cat(b, e.encode_field(x, 'bool'));
    if(tag===3)return cat(b, e.encode_varint(x.length*2), x.map(a=>this.encode_dynamic(a)));
    if(tag===4)return cat(b, e.encode_varint(x.length*2), x.flatMap(([a, z])=>[this.encode_dynamic(a), this.encode_dynamic(z)]));
    if(tag===5)return cat(b, e.encode_field(x, 'string'));
    if(tag===6)return b;
    fail('Unsupported DynamicValue tag');
  }
  field(cursor, typ){
    if(typ==='RPG.GameCore.DynamicValue')return this.dynamic(cursor);
    if(['RPG.Client.TextID', 'RPG.GameCore.FixPoint'].includes(typ))return e.field(cursor, typ);
    if(typ.endsWith('[]'))return Array.from({
      length:cursor.length()
    }, ()=>this.field(cursor, typ.slice(0, -2)));
    if(['uint', 'ushort'].includes(typ)){
      const v=cursor.varint();
      if(v>=2**(typ==='ushort'?16:32))fail('Unsigned integer overflow');
      return v;
    }
    if(['short', 'int'].includes(typ)||(typ in this.blocks&&this.blocks[typ].includes('public enum '))){
      const bits=typ==='short'?16:32;
      if(typ in this.blocks&&!/public int value__/.test(this.blocks[typ]))fail('Unsupported enum storage');
      const v=cursor.varint();
      if(v>=2**bits)fail('Signed integer overflow');
      return zigzag(v);
    }
    if(typ==='double'){
      if(cursor.at+8>cursor.data.length)fail('Truncated double');
      const v={double_wire:cursor.data.subarray(cursor.at,cursor.at+8).toString('hex')};
      cursor.at+=8;return v;
    }
    if(typ==='float'){
      if(cursor.at+4>cursor.data.length)fail('Truncated float');
      const v={
        float_wire:cursor.data.subarray(cursor.at, cursor.at+4).toString('hex')
      };
      cursor.at+=4;
      return v;
    }
    if(['string', 'bool'].includes(typ))return e.field(cursor, typ);
    if(typ.startsWith('System.Collections.Generic.Dictionary<')){
      const m=typ.match(/^System.Collections.Generic.Dictionary<(.+?), (.+)>$/);
      if(!m)fail('Unsupported dictionary');
      return Array.from({
        length:cursor.length()
      }, ()=>[this.field(cursor, m[1]), this.field(cursor, m[2])]);
    }
    if(typ==='RPG.GameCore.FloorCustomValueConfig'){
      const tag=cursor.varint(),
      sub=this.polymorphic(typ);
      if(!(tag in sub))fail('Unknown native subtype: '+tag);
      return {
        tag,
        value:this.record(cursor, sub[tag])
      };
    }
    return this.record(cursor, typ);
  }
  record(cursor, typ, through=null){
    const cols=this.schema(typ),
    mask=BigInt(cursor.varint());
    if(mask>>BigInt(cols.length))fail('Unsupported presence mask');
    const row={
    };
    for(let i=0; i<cols.length; i++){
      const col=cols[i];
      if(mask&(1n<<BigInt(i)))row[col.name]=this.field(cursor, col.type);
      if(col.name===through)break;
    }
    return row;
  }
  encode_field(v, t){
    if(t==='RPG.GameCore.DynamicValue')return this.encode_dynamic(v);
    if(['RPG.Client.TextID', 'RPG.GameCore.FixPoint'].includes(t))return e.encode_field(v, t);
    if(t.endsWith('[]'))return cat(e.encode_varint(v.length*2), v.map(x=>this.encode_field(x, t.slice(0, -2))));
    if(t.startsWith('System.Collections.Generic.Dictionary<')){
      const m=t.match(/^System.Collections.Generic.Dictionary<(.+?), (.+)>$/);
      return cat(e.encode_varint(v.length*2), v.flatMap(([k, x])=>[this.encode_field(k, m[1]), this.encode_field(x, m[2])]));
    }
    if(t==='RPG.GameCore.FloorCustomValueConfig')return cat(e.encode_varint(v.tag), this.encode_record(v.value, this.polymorphic(t)[v.tag]));
    if(t==='double')return Buffer.from(v.double_wire, 'hex');
    if(t==='float')return Buffer.from(v.float_wire, 'hex');
    if(['short', 'int'].includes(t)||(t in this.blocks&&this.blocks[t].includes('public enum '))){
      const x=BigInt(v);
      return e.encode_varint((x<<1n)^(x>>BigInt(t==='short'?15:31)));
    }
    if(['uint', 'ushort', 'string', 'bool'].includes(t))return e.encode_field(v, t);
    return this.encode_record(v, t);
  }
  encode_record(row, typ){
    const cols=this.schema(typ);
    if(Object.keys(row).some(k=>!cols.some(col=>col.name===k)))fail('Unknown field during round trip');
    return cat(e.encode_varint(cols.reduce((m, col, i)=>col.name in row?m|(1n<<BigInt(i)):m, 0n)), cols.filter(col=>col.name in row).map(col=>this.encode_field(row[col.name], col.type)));
  }
}
export function indexed_entries(data, id, size){
  const marker=Buffer.from(id, 'hex'),
  at0=data.indexOf(marker);
  if(at0<0||data.indexOf(marker, at0+16)>=0)fail('Missing or ambiguous DesignV blob: '+id);
  const at=at0+16;
  if(at+12>data.length)fail('Truncated DesignV header');
  const expected=data.readBigUInt64BE(at),
  count=data.readUInt32BE(at+8);
  if(expected!==BigInt(size)||!count||at+12+count*16>data.length)fail('DesignV index does not match installed blob');
  const entries=[],
  hashes=new Set();
  for(let i=0; i<count; i++){
    const p=at+12+i*16,
    key=data.readBigUInt64BE(p),
    length=data.readUInt32BE(p+8),
    offset=data.readUInt32BE(p+12);
    if(offset+length>size||hashes.has(key))fail('Invalid or overlapping DesignV asset ranges');
    entries.push({
      hash:key,
      offset,
      length
    });
    hashes.add(key);
  }
  const sorted=entries.toSorted((a, b)=>a.offset-b.offset);
  if(sorted.some((a, i)=>i+1<sorted.length&&a.offset+a.length>sorted[i+1].offset))fail('Overlapping DesignV asset ranges');
  return entries;
}
// XXH64, seed zero, with explicit 64-bit arithmetic rather than a native FFI.
const MASK=(1n<<64n)-1n, P1=11400714785074694791n, P2=14029467366897019727n, P3=1609587929392839161n, P4=9650029242287828579n, P5=2870177450012600261n;
const rot=(x, n)=>((x<<BigInt(n))|(x>>BigInt(64-n)))&MASK;
const round=(a, x)=>rot((a+x*P2)&MASK, 31)*P1&MASK;
export function asset_hash(text){
  const b=Buffer.from(text);
  let p=0,
  h;
  if(b.length>=32){
    let v=[(P1+P2)&MASK, P2, 0n, (-P1)&MASK];
    while(p<=b.length-32){
      for(let i=0;
      i<4;
      i++)v[i]=round(v[i], b.readBigUInt64LE(p+i*8));
      p+=32;
    }
    h=(rot(v[0], 1)+rot(v[1], 7)+rot(v[2], 12)+rot(v[3], 18))&MASK;
    for(const x of v)h=((h^round(0n, x))*P1+P4)&MASK;
  } else h=P5;
  h=(h+BigInt(b.length))&MASK;
  while(p+8<=b.length){
    h=(rot(h^round(0n, b.readBigUInt64LE(p)), 27)*P1+P4)&MASK;
    p+=8;
  }
  if(p+4<=b.length){
    h=(rot(h^(BigInt(b.readUInt32LE(p))*P1&MASK), 23)*P2+P3)&MASK;
    p+=4;
  }
  while(p<b.length){
    h=rot(h^(BigInt(b[p++])*P5&MASK), 11)*P1&MASK;
  }
  h^=h>>33n;
  h=h*P2&MASK;
  h^=h>>29n;
  h=h*P3&MASK;
  return h^(h>>32n);
}

// Both beta readers have this dispatch layout; resolve the RVA from matching metadata.
export function verify_dynamic_dispatch(dis, address, read){
  const table=dis.match(/lea\s+rcx,\[rip\+[^\n]+# (0x[\da-f]+)\s*\n[^\n]*movsxd rax,DWORD PTR \[rcx\+rax\*4\]/);
  if(!table||![/cmp\s+rax,0x5/, /shr\s+edx,1/, /neg\s+eax/, /xor\s+eax,edx/, /jmp\s+rax/].every(p=>p.test(dis)))fail('DynamicValue native reader changed');
  const ta=BigInt(table[1]), raw=read(ta,24),
  offsets=[0x85,0xc5,0x102,0x14f,0x18a,0x1cf],
  targets=offsets.map((_,i)=>ta+BigInt(raw.readInt32LE(i*4)));
  if(ta-address!==0x2b0n||targets.some((v,i)=>v-address!==BigInt(offsets[i])))fail('DynamicValue native tag binding changed');
  const fallback=dis.match(/cmp\s+rax,0x5\s*\n[^\n]*ja\s+(0x[\da-f]+)/),
    defaultTarget=fallback?BigInt(fallback[1]):0n,
    tail=dis.slice(dis.indexOf(defaultTarget.toString(16)+':'),dis.indexOf(targets[5].toString(16)+':'));
  if(defaultTarget-address!==0x1c6n||!/nop/.test(tail)||!/add\s+rsp,0x30/.test(tail)||!/ret/.test(tail)||/\b(?:call|jmp)\s/.test(tail))fail('DynamicValue native null/default case changed');
  const checks=[[/shr\s+rdx,1/, /neg\s+rax/, /xor\s+rax,rdx/, /mov\s+QWORD PTR \[rcx\+0x28\],rax/],
    [/movsd\s+xmm0,QWORD PTR \[rsp\+0x28\]/, /movsd\s+QWORD PTR \[rax\+0x28\],xmm0/],
    [/mov\s+edx,0x1/, /movzx\s+ecx,bl/, /mov\s+QWORD PTR \[rax\+0x28\],rcx/],
    [/add\s+rbx,0x20/, /jmp\s+0x/], [/add\s+rbx,0x18/, /call\s+0x/], [/add\s+rbx,0x10/, /jmp\s+0x/]];
  for(let i=0;i<targets.length;i++){
    const start=dis.indexOf(targets[i].toString(16)+':'),
    end=i<5?dis.indexOf(targets[i+1].toString(16)+':'):dis.length,
    part=dis.slice(start,end);
    if(start<0||!checks[i].every(p=>p.test(part)))fail('DynamicValue native case changed: '+i);
  }
  return {dispatch_offset:0x2b0, default_offset:0x1c6, case_offsets:offsets, tags:['int64-zigzag','double-le','bool-byte','array','map','string','null'], wire_layout:'beta-4.6.51/4.6.53'};
}