"""Optional native interpreter generated from the discovered tensor certificate.

Compilation is an explicit one-time cost. The portable NumPy interpreter remains
available; this backend does not change the declared arithmetic algorithms.
"""
from __future__ import annotations
import ctypes
import json
from pathlib import Path
import shutil
import subprocess
import sys
import time
import numpy as np
from arithmetic import Kernel, P, validate
from synthesis import verify_tensor, digest

TEMPLATE = r'''
#include <vector>
#include <array>
#include <map>
#include <tuple>
#include <algorithm>
#include <cstdint>
using I=long long;
static const I P=65537;
static const int A[3][2]=@@A@@;
static const int B[3][2]=@@B@@;
static const int C[3][3]=@@C@@;
static const int IA=@@IA@@, OA=@@OA@@;
static I mod(I x){x%=P;return x<0?x+P:x;}
struct Plan{I mul,add;int split;};
static std::map<std::tuple<int,int,int>,Plan> cache;
static Plan plan(int n,int m,int d){
 auto key=std::make_tuple(n,m,d);auto it=cache.find(key);
 if(it!=cache.end())return it->second;
 Plan r{I(n)*m,I(n)*m-(n+m-1),0};
 if(d>0 && std::min(n,m)>1){
  int h=(std::max(n,m)+1)/2;auto q=plan(h,h,d-1);
  Plan c{3*q.mul,3*q.add+I(IA)*h+I(OA+2)*(2*h-1),1};
  if(c.mul+c.add<r.mul+r.add)r=c;
  if(std::max(n,m)>=2*std::min(n,m)){
   int half=std::max(n,m)/2;Plan x,y;int extra;
   if(n>=m){x=plan(half,m,d);y=plan(n-half,m,d);extra=n-half+m-1;}
   else{x=plan(n,half,d);y=plan(n,m-half,d);extra=n+m-half-1;}
   Plan rect{x.mul+y.mul,x.add+y.add+extra,2};
   if(rect.mul+rect.add<r.mul+r.add)r=rect;
  }
 }
 cache[key]=r;return r;
}
static void base(const I*a,int n,const I*b,int m,I*z){
 for(int t=0;t<n+m-1;++t){
  int lo=std::max(0,t-m+1),hi=std::min(n-1,t);
  I s=a[lo]*b[t-lo];for(int j=lo+1;j<=hi;++j)s+=a[j]*b[t-j];z[t]=mod(s);
 }
}
static void recurse(const I*a,int n,const I*b,int m,I*z,I*work,int depth){
 auto q=plan(n,m,depth);
 if(!q.split){base(a,n,b,m,z);return;}
 if(q.split==2){
  int h=std::max(n,m)/2;
  int l1=(n>=m?h+m-1:n+h-1),l2=(n>=m?n-h+m-1:n+m-h-1);
  I*left=work;I*right=left+l1;I*next=right+l2;
  if(n>=m){recurse(a,h,b,m,left,next,depth);recurse(a+h,n-h,b,m,right,next,depth);}
  else{recurse(a,n,b,h,left,next,depth);recurse(a,n,b+h,m-h,right,next,depth);}
  std::fill(z,z+n+m-1,0);std::copy(left,left+l1,z);
  for(int j=0;j<l2;++j)z[h+j]=mod(z[h+j]+right[j]);return;
 }
 int h=(std::max(n,m)+1)/2,l=2*h-1;
 I*aa=work;I*bb=aa+2*h;I*left=bb+2*h;I*right=left+h;
 I*q0=right+h;I*q1=q0+l;I*q2=q1+l;I*next=q2+l;
 std::fill(aa,aa+2*h,0);std::fill(bb,bb+2*h,0);
 std::copy(a,a+n,aa);std::copy(b,b+m,bb);
 I*products[3]={q0,q1,q2};
 for(int t=0;t<3;++t){
  for(int i=0;i<h;++i){left[i]=mod(A[t][0]*aa[i]+A[t][1]*aa[h+i]);
                          right[i]=mod(B[t][0]*bb[i]+B[t][1]*bb[h+i]);}
  recurse(left,h,right,h,products[t],next,depth-1);
 }
 std::fill(z,z+n+m-1,0);
 for(int t=0;t<3;++t)for(int j=0;j<l && t*h+j<n+m-1;++j){
  I v=mod(C[t][0]*q0[j]+C[t][1]*q1[j]+C[t][2]*q2[j]);
  z[t*h+j]=mod(z[t*h+j]+v);
 }
}
extern "C" int sorilun_mul(const I*a,int n,const I*b,int m,int d,I*out){
 try{
  if(n<1||m<1||n>8192||m>8192||d<0||d>20)return 1;
  if(!plan(n,m,d).split){base(a,n,b,m,out);return 0;}
  // Geometrically shrinking operands bound the arena by 32*n+128.
  std::vector<I> workspace(32*std::max(n,m)+128);
  recurse(a,n,b,m,out,workspace.data(),d);return 0;
 }catch(...){return 2;}
}

static std::map<std::pair<int,bool>,std::vector<I>> rootcache;
static I fpow(I a,I k,I*counter){I r=1;while(k){if(k&1){r=r*a%P;++counter[1];}
 k>>=1;if(k){a=a*a%P;++counter[1];}}return r;}
static const std::vector<I>& roots(int n,bool inv,I*counter){
 auto key=std::make_pair(n,inv);auto it=rootcache.find(key);if(it!=rootcache.end())return it->second;
 I w=fpow(3,(P-1)/n,counter);if(inv)w=fpow(w,P-2,counter);
 std::vector<I> r(n/2,1);for(int i=1;i<n/2;++i){r[i]=r[i-1]*w%P;++counter[1];}
 rootcache[key]=r;return rootcache[key];
}
static void transform(std::vector<I>&a,bool inv,I*counter){
 int n=a.size();for(int i=1,j=0;i<n;++i){int bit=n>>1;for(;j&bit;bit>>=1)j^=bit;j^=bit;if(i<j)std::swap(a[i],a[j]);}
 for(int size=2;size<=n;size<<=1){const auto&r=roots(size,inv,counter);
  for(int i=0;i<n;i+=size)for(int j=0;j<size/2;++j){I u=a[i+j],v=a[i+j+size/2]*r[j]%P;
   a[i+j]=(u+v)%P;a[i+j+size/2]=mod(u-v);}
  counter[0]+=n;counter[1]+=n/2;
 }
 if(inv){I c=fpow(n,P-2,counter);for(auto&x:a)x=x*c%P;counter[1]+=n;}
}
extern "C" int sorilun_ntt(const I*a,int n,const I*b,int m,I*out,I*counts){
 try{
  if(n<1||m<1||n>8192||m>8192)return 1;
  counts[0]=counts[1]=0;counts[2]=1;
  int len=1,lg=0;while(len<n+m-1){len<<=1;++lg;}
  I estimate=9LL*len*lg/2+2*len,bmul=I(n)*m,badd=I(n)*m-(n+m-1);
  if(bmul+badd<=estimate){base(a,n,b,m,out);counts[0]=badd;counts[1]=bmul;return 0;}
  std::vector<I> aa(len),bb(len);std::copy(a,a+n,aa.begin());std::copy(b,b+m,bb.begin());
  transform(aa,false,counts);transform(bb,false,counts);
  for(int i=0;i<len;++i)aa[i]=aa[i]*bb[i]%P;counts[1]+=len;
  transform(aa,true,counts);std::copy(aa.begin(),aa.begin()+n+m-1,out);return 0;
 }catch(...){return 2;}
}
extern "C" void sorilun_clear_cache(){cache.clear();rootcache.clear();}

'''


def _cpp_array(rows):
    return '{' + ','.join('{' + ','.join(map(str, r)) + '}' for r in rows) + '}'


def build(law, directory):
    if not verify_tensor(law)[0]:
        raise ValueError('Cannot generate code from an invalid certificate')
    compiler = shutil.which('g++') or shutil.which('clang++')
    if not compiler:
        return {'available': False, 'reason': 'No C++ compiler', 'wall_seconds': 0}
    if sys.platform == 'win32':
        return {'available': False, 'reason': 'Use portable Python backend on Windows', 'wall_seconds': 0}
    directory = Path(directory)
    directory.mkdir(parents=True, exist_ok=True)
    k = Kernel(law, 0)
    text = TEMPLATE
    for key in ('A', 'B', 'C'):
        text = text.replace('@@'+key+'@@', _cpp_array(law[key]))
    text = text.replace('@@IA@@', str(k.input_adds)).replace('@@OA@@', str(k.output_adds))
    source, target = directory/'discovered_kernel.cpp', directory/'discovered_kernel.so'
    source.write_text(text)
    command = [compiler, '-O3', '-std=c++17', '-fPIC', '-shared', str(source), '-o', str(target)]
    start = time.perf_counter()
    proc = subprocess.run(command, capture_output=True, text=True, timeout=60)
    if proc.returncode:
        raise RuntimeError(proc.stderr)
    return {'available': True, 'source': str(source), 'library': str(target),
            'command': command, 'wall_seconds': time.perf_counter()-start,
            'law_sha256': digest(law),
            'compiler': subprocess.check_output([compiler, '--version'], text=True).splitlines()[0]}


class NativeKernel(Kernel):
    def __init__(self, law, cap, library):
        super().__init__(law, cap)
        self.library = ctypes.CDLL(str(library))
        self.function = self.library.sorilun_mul
        arr = np.ctypeslib.ndpointer(dtype=np.int64, ndim=1, flags='C_CONTIGUOUS')
        self.function.argtypes = [arr, ctypes.c_int, arr, ctypes.c_int,
                                  ctypes.c_int, arr]
        self.function.restype = ctypes.c_int

    def _counts(self, n, m, cap):
        cm, ca, split = self.plan(n, m, cap)
        if not split:
            return cm, ca, 1
        if split == 2:
            h = max(n,m)//2
            if n >= m:
                x = self._counts(h,m,cap)
                y = self._counts(n-h,m,cap)
            else:
                x = self._counts(n,h,cap)
                y = self._counts(n,m-h,cap)
            return cm, ca, 1+x[2]+y[2]
        h = (max(n,m)+1)//2
        _, _, calls = self._counts(h, h, cap-1)
        return cm, ca, 1+3*calls

    def mul(self, a, b):
        a = np.ascontiguousarray(validate(a))
        b = np.ascontiguousarray(validate(b))
        self.trace[(len(a),len(b))] += 1
        out = np.empty(len(a)+len(b)-1, dtype=np.int64)
        cm, ca, calls = self._counts(len(a),len(b),self.cap)
        self.meter.mul += cm
        self.meter.add += ca
        self.meter.calls += calls
        self.meter.allocations += len(out)
        status = self.function(a,len(a),b,len(b),self.cap,out)
        if status:
            raise RuntimeError('Native kernel error code %d' % status)
        return out


class NativeNTTKernel:
    def __init__(self, law, library):
        from arithmetic import Meter
        from collections import Counter
        self.meter = Meter()
        self.trace = Counter()
        self.library = ctypes.CDLL(str(library))
        self.function = self.library.sorilun_ntt
        arr = np.ctypeslib.ndpointer(dtype=np.int64, ndim=1, flags='C_CONTIGUOUS')
        self.function.argtypes = [arr, ctypes.c_int, arr, ctypes.c_int, arr, arr]
        self.function.restype = ctypes.c_int

    def mul(self, a, b):
        a = np.ascontiguousarray(validate(a))
        b = np.ascontiguousarray(validate(b))
        self.trace[(len(a),len(b))] += 1
        out = np.empty(len(a)+len(b)-1, dtype=np.int64)
        counts = np.zeros(3, dtype=np.int64)
        status = self.function(a,len(a),b,len(b),out,counts)
        if status:
            raise RuntimeError('Native NTT error code %d' % status)
        self.meter.add += int(counts[0])
        self.meter.mul += int(counts[1])
        self.meter.calls += int(counts[2])
        self.meter.allocations += len(out)
        return out